实训第三周/星期四

输入/输出基础

本此介绍Java的两个重要的包：io和applet io包支持Java的基本I/O（输入/输出）系统，包括文件的输入/输出。 applet包支持applet（小应用程序）。

IO，各种流的详细说明
关键字： transient， volatile， instanceof， native以及strictfp。

一：流的概念

1. Java程序通过流来完成输入/输出。流是生产或消费信息的抽象。
   流通过Java的输入/输出系统与物理设备链接。尽管与它们链接的物理设备不尽相同，所有流的行为具有同样的方式。
2. 字节流和字符流
   流分两种

• 字节流（byte stream）为处理字节的输入和输出提供了方便的方法。例如使用字节流读取或书写二进制数据。
• 字符流（characterstream）为字符的输入和输出处理提供了方便。它们采用了统一的编码标准，因而可以国际化。当然，在某些场合，字符流比字节流更有效

3. 字节流的类和方法
   在顶层有两个抽象类： InputStream 和 OutputStream。每个抽象类都有多个具体的子类。顶层类最重要的两个方法：read()和write()
4. 字符流的类和方法
   顶层有两个抽象类： Reader和Writer。这些抽象类处理统一编码的字符流。
5. 预定义流
   java.lang包该包定义了一个名为System的类

都是字节流:但你可以用基于字符的流来包装它们。

inputStream的对象

System.in是标准输入，默认它指的是键盘。

PrintStream的对象

System.out是标准的输出流。默认它是一个控制台。
System.err指的是标准错误流，它默认是控制台。

更多详细内容：
1 . 读取控制台输入
2 . 读取字符
3 .读取字符串
4 .向控制台写输出
5 . PrintWriter类
6 .文件的读写

IO，各种流的详细说明

1.什么是IO

Java中I/O操作主要是指使用Java进行输入，输出操作.
Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。
Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。

2. Java I/O主要包括如下几个层次，包含三个部分：

   1.流式部分：IO的主体部分；

   2.非流式部分：主要包含一些辅助流式部分的类，如：File类、RandomAccessFile类和FileDescriptor等类；

   3.其他类：文件读取部分的与安全相关的类，如：SerializablePermission类，以及与本地操作系统相关的文件系统的类，如：FileSystem类和Win32FileSystem类和WinNTFileSystem类。

3. io流的具体分类

主要的类如下：

1. File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。

2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。

3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。

4. Reader（文件格式操作）：抽象类，基于字符的输入操作。

5. Writer（文件格式操作）：抽象类，基于字符的输出操作。

6. RandomAccessFile（随机文件操作）：它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。

常用流的代码测试：

---

关键字： transient， volatile， instanceof， native以及strictfp。

1. Transient和volatile修饰符
   transient和volatile，这些修饰符用来处理特殊的情况。
   如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。例如：

class T {
transient int a; // will not persist
int b; // will persist
}

这里，如果T类的一个对象被写入一个持久的存储区域， a的内容不被保存，但b将被保存。
Volatile修饰符告诉编译器被volatile修饰的变量可以被程序的其他部分改变。一种这样的情形是多线程程序。在多线程程序里，有时两个或更多的线程共
享一个相同的实例变量。考虑效率的问题，每个线程可以自己保存该共享变量的私有拷贝。
实际的（或主要的）变量副本在不同的时候更新，例如当进入synchronized方法时。当这种方式运行良好时，它在时间上会是低效的。
在某些情况，真正要紧的是变量主副本的值会体现当前的状态。为保证这点，仅需把变量定义成volatile型，它告诉编译器它必须总是使用volatile变量的主副本（或者至少总是保持一些私有的最新的主副本的拷贝，反之亦然），
同时，对主变量的获取必须以简洁次序执行，就像执行私有拷贝一样。

2. 使用instanceof
   有时，在运行时间内知道对象类型是很有用的。例如，你有一个执行线程生成各种类型的对象，其他线程处理这些对象。这种情况下，让处理线程在接受对象时知道每一个对象的类型是大有裨益的。另一种在运行时间内知道对象的类型是很有用的情形是强制类型转换。

Java中非法强制类型转换导致运行时错误。很多非法的强制类型转换在编译时发生。
然而包括类层次结构的强制类型转换可能产生仅能在运行时间里被察觉的非法强制类型转换。

例如，一个名为A的父类能生成两个子类B和C。这样，在强制B对象转换为类型A或强制C对象转换为类型A都是合法的，但强制B对象转换为C对象（或相反）都是不合法的。
因为类型A的一个对象可以引用B或C。但是你怎么知道，在运行时，在强制转换为C之前哪类对象被引用？它可能是A， B或C的一个对象。如果它是B的对象，一个运行时异常被引发。

Java 提供运行时运算符instanceof来解决这个问题。
instanceof运算符具有下面的一般形式：

object instanceof type

这里， object是类的实例，而type是类的类型。如果object是指定的类型或者可以被强制转换成指定类型， instanceof将它评估成true，若不是，则结果为false。这样， instanceof是你的程序获得对象运行时类型信息的方法。
下面的程序说明了instanceof的应用：

class A {            |         class B {
       int i, j;     |           int i, j;
         }           |            }


class C extends A {
int k;
}
class D extends A {
int k;
}
class InstanceOf {
public static void main(String args[]) {
A a = new A();
B b = new B();
C c = new C();
D d = new D();
if(a instanceof A)
System.out.println("a is instance of A");
if(b instanceof B)
System.out.println("b is instance of B");
if(c instanceof C)
System.out.println("c is instance of C");
if(c instanceof A)
System.out.println("c can be cast to A");
if(a instanceof C)
System.out.println("a can be cast to C");
System.out.println();
// compare types of derived types
A ob;
ob = d; // A reference to d
System.out.println("ob now refers to d");
if(ob instanceof D)
System.out.println("ob is instance of D");
System.out.println();
ob = c; // A reference to c

System.out.println("ob now refers to c");
if(ob instanceof D)
System.out.println("ob can be cast to D");
else
System.out.println("ob cannot be cast to D");
if(ob instanceof A)
System.out.println("ob can be cast to A");
System.out.println();
// all objects can be cast to Object
if(a instanceof Object)
System.out.println("a may be cast to Object");
if(b instanceof Object)
System.out.println("b may be cast to Object");
if(c instanceof Object)
System.out.println("c may be cast to Object");
if(d instanceof Object)
System.out.println("d may be cast to Object");
}
}
程序输出如下：
a is instance of A
b is instance of B
c is instance of C
c can be cast to A
ob now refers to d
ob is instance of D
ob now refers to c
ob cannot be cast to D
ob can be cast to A
a may be cast to Object
b may be cast to Object
c may be cast to Object
d may be cast to Object

多数程序不需要instanceof运算符，因为，一般来说，你知道你正在使用的对象类型。
但是，在你编写对复杂类层次结构对象进行操作的通用程序时它是非常有用的。
3. strictfp
Java 2向Java语言增加了一个新的关键字strictfp。与Java 2同时产生的浮点运算计算模型很轻松的使某些处理器可以以较快速度进行浮点运算例如奔腾处理器。
特别指明，在计算过程中，一个不需要切断某些中介值的新的模型产生了。用strictfp来修饰类或方法，可以确保浮点运算（以及所有切断）正如它们在早期Java版本中那样准确。切断只影响某些操作的指数。当一个类被strictfp修饰，所有该类的方法都自动被strictfp修饰。

坦白地说，很多程序员从未用过strictfp，因为它只对非常少的问题有影响。

---

InputStream 和 OutputStream的子类

字符流