[转载]Java完美经典读书笔记
java完美经典读书笔记
第一章 概述
第二章 JAVA语言基础
※关键字：
基本数据类型： byte short int char long float double boolean
循环控制： do while for break continue
分支控制： if else switch case default break
方法 变量 和类得修饰府： private public protected final static abstract
synchronized volatile strictfp transient
字面值常量： false true null
方法相关得关键字： return void
包相关得关键字： package import
异常处理： try catch finally throw throws
对象相关： new extends implements super class instanceof this
※很多算术运算操作可以产生浮点型无法表达的数字，如无限大，无限小等，这些数据的表达通过浮点数封装类（Float和Double）所提供的特殊属性来表达。
Float.NaN 非数字
Float.NEGATIVE_INFINITY 无限小
Float.POSITIVE_INFINITY 无限大
Double.NaN 非数字
Double.NEGATIVE_INFINITY 无限小
Double.POSITIVE_INFINITY 无限大
数据类型的自动转换图：
char--->{
int-->long-->float-->double
byte-->short-->{
※内置类对应的基本类型：
Byte-->byte;Short-->short;Integer-->int;Long-->long;Float-->float;Double-->double
Boolean-->boolean;Character-->char;String-->char[]
※将基本数据类型转为String类型：string str1; int intv1=300; str1=String.valueOf(intv1);
将string类型转为基本数据类型：string str1="126"; int i1=Integer.parseInt(str1);
※取得string对象内含的char[]值，必须使用它的toCharArray()方法来取得。
String str3=new String("this is str3");
char[] c1=str3.toCharArray();
System.out.println("c1数组的第一个字符＝") + c1[0];
※'/n'换行符
'/r'回车符
'/t'制表符
'/b'返回符
'/f'走纸符
'/''单引号
'/"'双引号
'//'反斜线符
※负数取模的计算技巧：a%b可以这样计算，首先将a和b都变成正数进行取模
运算，得到的结果添加上和a相同的正负符号即可。例如：
-10%-3=10%3=-1; 10%-3=10%3=1;
※switch表达式的值类型，只能是 byte 、char 、short 、int 而不能是long、
float、double、boolean
※java包含两个循环语句break、continue；break使程序可以在特定条件满足时跳出循环
体，而continue则使当次的循环忽略当次循环的后续代码，立即开始下一轮的循环。
※可视域修饰符描述了类、方法或值域对外开放的程度，按开放程度由高到低的顺序是：
public -->protected -->默认 -->private
※类的值域和方法前都可以加一个可视域修饰符。对于public成员，外部的任何类都可以访问这个成员；protected的成员可以被同一个包的类及其子类访问；默认的可视域的成员可以被处于同一个包中的类访问；private的成员只能在类内部访问。
※除可视域修饰符外，还可以添加另外两个修饰符，分别是static和final。static称为静态的修饰符，带static的值域表示这个类不管有多少个实例，只会保留一份值域拷贝，即类的多个实例对应同一份变量值，该类的任何一个实例更改了这个值域，该类的其它实例都可以马上看到，所以带static的变量是类级的变量。而带final修饰符的值域表示在第一次赋值后不可改变，这种值域一般用于标识一个常量。
※子类的实例对象可以赋给父类的变量，保存在父类变量中的子类实例可以用
转型将其赋给子类的变量。 super AClass sub BClass
AClass a= new BClass(1,2,3);
Bclass b=(BClass)a;
※一个类只能有一个父类，但却可以同时实现多个接口。
子类或实现了接口的类可以将其实例传给父类或接口的变量。
只实现了父类中部分的虚方法，或只实现接口部分方法的类是虚类，不能进行
实例化。
一个类如果不显示继承一个类，那它就是默认继承java.lang.Object。
接口中的任何值域都是 public static final 类型，接口不允许定义其它类型
的变量。
※static成员变量，它的有效范围可以跨类，甚至可达整个应用程序之内。它除了能在定义它的类内存取，还能直接以“类名.成员变量”的方式在其它的类内使用。它是java程序的“全局变量”。
定义为static的方法有以下几条限制：
1.它只能调用其他的static方法
2.它只能访问static数据
3.它不能以任何方式引用this和super
4.在一个static方法中引用任何实例变量都是非法的。
※super有两种通用形式：1.调用超类的构造函数 2.用来访问被子类的成员隐藏的超类成员
super必须是在子类构造函数中第一个被执行的语句。
动态方法调度：超类的引用变量可以引用子类对象。当一个重载方法通过超类引用被调用，java根据当前被引用对象的类型来决定执行哪个版本的方法。如果引用的对象类型不同，就会调用一个重载方法的不同版本。换句话说，是被引用对象的类型，而不是引用变量的类型。
※final：定义成final的方法不能被重载，定义成final的类不能被继承
第三章 java的数组与对象基础
※两个类型相同的数组GradeA和GradeB可以相互引用，当GradeA引用GradeB数组后，这两个数组的元素值是完全一样的。而当GradeA的元素值改变后，GradeB的元素值也随之改变了，可知GradeA和GradeB数组的实例根本是同一个，而不是复制出另一个实例。
对于一个多维数组，前面维度若未指定索引时，后面维度的索引就不可以先指定。
String 类对象：
String c="dfdkfdf";
String c=new String ("dfdkfdf");
int a="wo shi yi ge cheng xu yuan".length();
String s1="wo shi yi ge cheng xu yuan".getClass().getName();
导入一个 StringBuffer 对象
String ( StringBuffer buffer)
StringBuffer buffer1=new StringBuffer ("fish");
String str1=new String(buffer1);
方法：
1.取得 String 对象中一些与其内含字符串有关的属性：j02060402
int length() 取得内含字符串的长度。
char charAt(int index) 由此对象内含字符串中，取得index参数指定的索引的那个字符
char[] toCharArray() 将此 String 对象含有的字符串转化为char[]类型的值。
byte[] GetBytes() 将此 String 对象含有的字符串转化为byte[]类型的值。
String[] toString 返回此对象本身的实例（引用地址）
2.从 String 对象内含的字符串中找寻字符或字符串，且找到时回传该目标所在的索引位置 j02060403
int indexOf(int ch)
在此对象内含的字符串（char[]类型）中寻找ch参数指定的字符，找到第一个后就返回他的索引，若找不到则返回-1
int indexOf(int ch,int fromIndex)
与前者同名异式，用fromIndex参数指定由此对象内含的字符串（char[]类型）的某个字符（用索引指定）开始向后找
int indexOf(String str)
同名异式，在此字符串中寻找str参数指定的字符串
int indexOf(String str,int fromIndex)
同名异式，在此字符串中寻找str参数指定的字符串，用fromIndex参数指定由此字符串（char[]类型）的某个字符（用索引指定）开始向后对比字符串
int lastIndexOf(int ch)
在此对象内含的字符串（char[]类型）中寻找ch参数指定的字符，若要找的字符有两个以上，会返回最后一个它的索引值，若找不到则返回-1
int lastIndexOf(int ch,int fromIndex)
与前者同名异式，用fromIndex参数指定欲寻找的范围只到该字符为止
int lastIndexOf(String str)
同名异式，在此字符串中寻找某个字符串
int lastIndexOf(String str,int fromIndex)
同名异式，在此字符串中寻找str参数指定的字符串，用fromIndex参数指定欲寻找的范围只到该字符为止
3.比较或检查该 String 对象的字符串内容：j02060404
boolean startsWith(String prefix)
检查此字符串的开头是否为prefix参数指定的字符串内容
boolean startsWith(String prefix,int toffset)
从toffset参数指定的索引开始，往后检查此字符串的开头是否为prefix参数所指的字符串内容
boolean endsWith(String suffix)
检查此字符串的结尾是否为suffix参数所指的字符串内容
int compareTo(String anotherString)
以字符为单位，逐一比较对象的内含字符串与另一个 String 对象内含字符串字符值（编码）的大小，只有遇到一个不同字符，就不往下比较，直接返回。若此对象这方的字符值较大，就返回代表两者之差的正整数，反之，则返回值为负整数；若两个字符串完全相同，就返回0
int compartToIgnoreCase(String str)
与前者相似，不考虑英文的大小写
boolean equals(Object anObject)
与某个对象作比较，若另一个 String 对象和它含有完全相同的字符串，就返回true；反之，返回false。与 Object 和 Integer 等类的equals()不同，参考j02060413
boolean equalsIgnoreCase(String anotherString)
与某个 String 对象作比较，作用与equals()相似，不考虑英文大小写
boolean matches(String regex)
检查内含字符串的样式是否吻合regex参数所指定的规则（正则表达式）。regex参数值的写法看java.util.regex.Pattern
boolean regionMatches(int toffset,String other,int ooffset,int len)
比较内含字符串的某部分内容，是否完全同于other参数导入字符串的某部分内容。toffset参数指定由此对象内含字符串的这个字符开始往后比较，ooffset参数则指定要和other参数的这个字符以后的字符串比较，而且欲比较这部分字符串的长度由len参数指定。
boolean regionMatches(boolean ignoreCse,int toffset,String other,int ooffset,int len)
与前者同名异式，多处的ignoreCase参数用来决定在比较时是否忽略英文字母的大小写差异。若参数为true，就忽略大小写差别；若为false，则得考虑大小写不同。
boolean contentEquals(StringBuffer sb)
比较内含字符串得内容，是否完全同于某个 StringBuffer 对象内得字符串
4.取得 String 对象内含得字符串，经一番处理后，再拿处理后得字符串内容来产生新的 String 对象： j02060405
String concat(String str)
将str参数内含得字符串连接到此对象所含的字符串的尾端，结果类似“＋”运算符的作用
String replace(char oldChar,char newChar)
取得内含的字符串，然后将其中某个特定的字符全部替换成另一个字符。由oldChar参数指定要被替换的字符值，newChar参数指定用来取代的新字符值
String replaceAll(String regex,String replacement)
取得内含的字符串，然后将其中符合某种格式的字符串全部替换成另一个字符串。由regex参数指定要被替换掉的字符串的格式，replacement参数则指定要用来取代的新字符串
String replaceFirst(String regex,String replacement)
取得内含的字符串，然后将其中符合某种格式的字符串第一次出现的地方替换成另一个字符串。由regex参数指定要被替换掉的字符串的格式，replacement参数则指定要用来取代的新字符串
String substring(int beginIndex)
取得此字符串中，beginIndex参数所指定索引之后的所有字符，以此产生一个 String 对象。
String substring(int beginIndex,int endIndex)
取得此字符串中，由beginIndex索引值到endIndex索引之前（不包括它）的所有字符，以此产生一个 string对象
String toLowerCase()
取得此对象内含的字符串，将其中的英文字母全转成小写
String toUpperCase()
取得此对象内含的字符串，将其中的英文字母全转成大写
String trim()
取得此对象内含的字符串，将它去掉尾端的空白符
String[] split(String regex)
以regex参数代表的字符串为分界线，将此字符串分为多个字符串，以此产生一个 String[]数组
String[] splet(String regex,int limit)
以regex参数代表的字符串为分界线，将此字符串分为多个字符串，且由limit参数决定最多只将它分为多少个字符串，以此产生一个 String[]数组
5. String 类可以直接使用的static方法，不需构造对象实例就能使用 j02060406
static String copyValue(char[]data)
复制某个char[]数组所含的所有字符，以产生一个字符串（string 对象）
static String copyValueOf(char[]data,int offset,int count)
复制某个char[]数组所含的部分字符，以产生一个字符串（string 对象）。由offset参数指定由这个字符开始复制，int参数则指定欲复制字符的数量
static String valueOf(参数)
返回一个内含字符串的意义能代表导入参数的 String 对象。且参数形式有许多种。
StringBuffer 类对象：
不能直接使用“字符串常数”来初始化StringBuffer对象
StringBuffer 对象方法：
1.取得此StringBuffer 对象的一些属性：j02060408
int length()
取得内含字符串的长度
int capacity()
取得目前内部缓冲区容量的大小
void getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin)
取得此对象内含字符串中，由srcBegin索引开始到srcEnd索引之前（不包括此字符）的所有字符，然后复制其值作为dst参数代表的数组在 dstBegin参数索引开始后的元素
char charAt(int index)
由此对象内含字符串中，取得index参数所指定的索引的那个字符
String substring(int start)
取得此 StringBuffer 对象内含字符串，start参数指定的索引开始以后的所有字符，以此产生一个 String 对象
String substring(int start,int end)
取得此 StringBuffer 对象内含字符串，start参数指定的索引开始直到end索引之前（不包括此字符）的所有字符，以此产生一个 String 对象
String toString()
取得此StringBuffer 对象内含字符串，以此产生一个 String 对象
CharSequence subsequence(int start,int end)
取得此 StringBuffer 对象内含字符串中，由start索引开始直到end索引之前（不包括此字符）的所有字符，并以charSequence对象的格式返回。
2.赋值与此 StringBuffer 对象内字符串有关的一些属性 j02060409
void setCharAt(int index,char ch)
设定此StringBuffer 对象内含字符串中某个索引位置上的字符值。index参数指定该字符索引的位置，ch参数决定该字符的值
void setLength(int newLength)
设定此StringBuffer 对象内含字符串的长度。若新的长度比原来小，则后面在范围外的字符会被舍弃；若长度比原来大，则后面会新增字符，而且每个都初始化为特殊字符“/u0000”，其意是“回车换行”
void ensureCapacity(int minimumCapacity)
要求此对象的内部缓冲区目前至少要配置到minimumCapacity参数指定的容量。若目前缓冲区已超过参数指定容量，或参数值小于0，其他并不会因此缩小。
3.直接对 StringBuffer 对象内含的字符串作处理，之后会回传它自己本身的实例（引用地址）
j02060410
StringBuffer append(一个参数)
将导入参数的值转为字符串，然后连接到此 StringBuffer 对象所含之字符串的尾端，和“＋”运算符对字符串的处理相似，但此对象本身内含字符串会改变
StringBuffer append(char[]str,int offset,ing len)
从str参数取得字符串连接到此 StringBuffer 对象内含字符串的尾端。而利用offset参数决定从str字符串的这个索引位开始取字符串，且欲取得的字符串长度由len参数指定。
StringBuffer delete(int start,int end)
删除此StringBuffer 对象内含的部分字符串，由start参数指定开始删除第一个字符的索引位置，end参数决定从此字符开始就不删除的索引位置
StringBuffer deleteCharAt(int index)
删除此StringBuffer 对象内含字符串中的一个字符，其索引位置由index参数指定
StringBuffer insert(int offset,char[]str)
将str参数代表的字符串插入到此StringBuffer 对象内含字符串中，而插入的目标索引位置由offset参数决定。
StringBuffer insert(int index,char[]str,int offset,int len)
从str参数取得字符串插入到此StringBuffer 对象内含字符串中。而插入的目标索引位置由offset参数决定，offset参数则决定从str的这个索引位置开始取字符串，且len参数决定欲取得的字符串长度
StringBuffer replace(int start,int end,String str)
将此StringBuffer 对象内的某一部分取代为str参数指定的字符串。而start指定要被取代掉第一个字符的索引位置，end参数则指定由此索引位置开始就不再取代字符，则此字符不会被取代掉。
StringBuffer reverse()
将从StringBuffer 对象内含字符串的排列顺序完全倒转。
4.在StringBuffer 对象内含字符串中寻找某个字符串，然后回传目标所在的索引位置 参考j02060402
int indexOf(String str)
在此对象内含的字符串（char[]类型）中寻找某个字符串。找到第一个符合的字符串后，就返回它第一个字符的索引；若找不到则返回-1
int indexOf(String str,int fromIndex)
同名异式，在此字符串中寻找某个字符串，且由fromIndex参数指定由此字符串（char[]类型）的某字符（用索引指定）开始向后对比字符串，找到第一个符合的字符就返回
int lastIndexOf(String str)
在此对象内含的字符串（char[]类型）中寻找某个字符串。若要找的字符串由两个以上，会返回最后一个它的第一个字符的索引值；若找不到则返回-1
int lastIndexOf(String str,int fromIndex)
同名异式，在此字符串中寻找某个字符串，且由fromIndex参数指定由此字符串（char[]类型）的某字符
（用索引指定）开始向后对比字符串
复制string对象 j02060411 复制stringbuffer对象j02060412
第八章 JAVA的一般类：
类的构造函数：
1.“封住等级”通常是public
2.此“函数名”与“类名”完全相同
3.无返回类型
4.无修饰符
5.构造函数只能配合new来自动调用，而无法让对象使用。
成员的修饰符
abstract
此修饰符只能用在一般“成员函数”，而不能用于成员变量或构造函数，且不能与其他修饰符（封装修饰符除外）同时用于一个成员函数。带此修饰符的成员函数，只会有声明部分，其后只需一个“;”作为结尾，不能有实现部分。在一个类中，只要拥有一个以上有加abstract修饰符的成员函数，就得将其声明为abstract类，且不能以此abstract类的构造函数来产生对象实例。
static
第十章 java的窗体应用程序基础
***** 窗口应用程序通常在窗口内会需要许多组件，通常不直接使用Frame类产生组件，而是要声明一个
继承自 Frame的类，并在里面加入组件作为它的成员，然后再利用该类去产生一个“拥有所需的组件内容
与功能的窗口”。而此类继承自frame组件类，则程序代码结构可以如下：
import java.lang.*;
import java.awt.*;使用到AWT组件
//import javax.swing.*;若使用到Swing组件
[封装] class 窗口类名 extends Frame {
组件区：Button、Label等类的对象（变量）==>类成员
public 窗口类名 (){
决定何种版面布局方式==》窗口框架的setLayout（）方法
构造各组件的对象实例==》使用组件的构造函数
设定各组件的属性：外观位置==》各组件setBounds（）方法
设定各组件所对应的事件监听机制（搭配Inner Class）
将各组件加入此窗口框架中==》此窗口框架的add（）方法
设定此窗口框架的属性：外观位置等等==》setBounds（）等方法
设定此窗口框架对应的事件监听机制（搭配Inner Class）
显示此窗口==》使用show（）、setVisible（）方法
}
public static void main(String args[]){
窗口类名 窗口对象=new 窗口类的构造函数；
//也可在其它类内建立此种窗口对象
操作窗口框架==》窗口对象.方法
操作窗口内的组件==》窗口对象.组件.方法
}
Inner class (自定的事件类)==>类的类型成员
}
倘若此类要继承JFrame组件类，则可按下面的程序代码架构来声明我们的窗口框架类：
import java.lang.*;
//import java.awt.*;若使用到AWT组件
import javax.swing.*;使用到Swing组件
[封装] class 窗口类名 extends JFrame {
组件区：JButton、JLabel等类的对象（变量）==>类成员
public 窗口类名 (){
决定何种版面布局方式==》ContentPane的setLayout（）方法
构造各组件的对象实例==》使用组件的构造函数
将各组件加入ContentPane中==》使用此ContentPane的add（）方法
设定此ContentPane的属性：背景颜色等等==》setBounds（）等方法
设定此窗口框架的属性：外观位置等等==》setBounds（）等方法
设定此窗口框架对应的事件监听机制（搭配Inner Class）
显示此窗口==》使用show（）、setVisible（）方法
}
public static void main(String args[]){
窗口类名 窗口对象=new 窗口类的构造函数；
//也可在其它类内建立此种窗口对象
操作窗口框架==》窗口对象.方法
操作窗口内的组件==》窗口对象.组件.方法
}
Inner class (自定的事件类)==>类的类型成员
}
第十一章 窗口程序的事件机制 //Shijian.java
*****建立GUI事件的做法，主要有两种方式：一.一般标准做法--implements XXXListener
1.加入所需的监听能力 首先为组件注册一个负责处理某方面事件的listener对象（事件监听者），也
就是使组件具备监听某一类事件的能力，方式如下：组件.addXXXListener（XXXListener对象）
2.自定义一个实现XXXListener接口的类（class）
在上一步中需要导入一个XXXListener对象，但java提供的XXXListener接口类，无法直接用来产生对象实例，因此我们得要自定一个继承该接口的一般类。既然是继承接口类，那么就要实现该接口的所有方法。
假设要制定鼠标按键单击该组件时执行的动作，那么就要override它的mouseClickd（MouseEvent e）事件函数
3.产生Listener对象实例
Button1.addMouseListener（new Button1MouseListener（））;
二.继承Adapter类的作法－－extends XXXAdapter
若 XXXAdapter接口中的事件函数有两个以上，java就会提供一个对应它的XXXAdapter类（即：适配器类）给我们，它是一个已经 implements XXXListener的类。此种作法的实现步骤如下：
1.加入所需的监听能力
组件.addXXXListener(给XXXAdapter对象);
2.自定义一个继承XXXAdapter的类：extends XXXAdapter
由于XXXAdapter类是标准的一般类，所以继承此类之后，我们只要override所需要的事件函数即可。
3.产生Listener对象实例
*****AWT事件类
awt的事件类的继承关系图：
java.lang.Object
|
java.EventObject
| |
java.AWTEvent java.beans.PropertyChangeEvent
|
java.awt.event. java.awt.event. java.awt.event. java.awt.event. java.awt.event.
ComponentEvent TextEvent ItemEvent ActionEvent AdjustmentEvent
|
FocusEvent InputEvent ContainerEvent WindowEvent PaintEvent
|
KeyEvent MouseEvent
|6.5
MouseWheelEvent
EventObject 类--所有事件类的始祖
它提供了一个getSource()方法，让我们知道事件源发生自哪个组件。
public Object getSource()
AWTEvent 类--它是继承自EventObject的一个abstract类，它是所有AWT事件的父类。
*****Frame组件拥有的监听能力与常用的Listener接口
一.由Component类继承来的监听能力
Component 类定义的 addXXXListener()方法
void addComponentListener(ComponentListener l)
void addFocusListener(FocusListener l)
void addHierarchyBoundsListener(HierarchyBoundsListener l)
void addHierarchyListener(HierarchyListener l)
void addInputMethodListener(InputMethodListener l)
void addKeyListener(KeyListener l)
void addMouseListener(MouseListener l)
void addMouseMotionListener(MouseMotionListener l)
void addMouseWheelListener(MouseWheelListener l)
这些“监听者”的Listener接口： 所有事件的返回类型皆为void
1.ComponentListener 接口
此接口拥有的事件函数如下：
事件函数 触发时机
componentHidden(ComponentEvent e) 组件从屏幕上隐藏起来，例如使用 setVisible(false)方法，或使用旧版hide()方法
componentShown(ComponentEvent e) 组件由隐藏改为显示到屏幕上，例如使用 setVisible(false)方法，或使用旧版show()方法
componentMoved(ComponentEvent e) 组件在容器内位置变动时，若是独立浮动的Frame 组件，其容器可视为屏幕（screen）
componentResized(ComponentEvent e) 组件的外观大小改变时
2.FocusListener 接口
事件函数 触发时机
focusGained(FocusEvent e) 键盘焦点由另一个组件进入此组件时
focusLost(FocusEvent e) 键盘焦点由此组件进入另一个组件时
注：如果组件本身是一个容器，而其内又容纳了能接受键盘输入焦点的组件，那么FocusListener所处理的FocusEvent事件，会发生在其内所包含
的组件上。因此，对于象Frame这样的窗口，若要针对它是否接受Focus作控制，一般会使用WindowFocusListener来实现。
3.KeyListener 接口
事件函数 触发时机
keyPressed(KeyEvent e) 当键盘焦点在此组件内，将键盘的任何一个按键 按下（在放开或其他按键被按前，会不断侦测到 KeyPressed事件，则按下到放开为止，可能有多 次KeyPressed发生）
keyRelease(KeyEvent e) 当键盘焦点在此组件内，将键盘的任何一个被按 下的按键放开弹起
keyTyped(KeyEvent e) 当键盘焦点在此组件内，将键盘的任何一个文字 输入（包括空格）键按下，亦即每用键盘打一个 字。或按下Esc、Enter特殊功能键时，也会触发 此事件。例如：在一个文本框内输入一个“Y”字 符，总共会触发keyPressed、keyRelease、 keyTyped三个事件。若按下F1键再放开，就只会 触发keyPressed、keyRelease
4.MouseListener 接口
事件函数 触发时机
mousePressed(MouseEvent e) 在此组件内按下鼠标按键（到放开为止，算一次 mousePressed）
mouseClicked(MouseEvent e) 相当经历一回mousePressed+mouseReleased。可 侦测的鼠标点击状况，包括按一下和连按多下
mouseReleased(MouseEvent e) 在此组件内将鼠标按键放开
mouseEntered(MouseEvent e) 鼠标光标移入此组件内
mouseExited(MouseEvent e) 鼠标光标由此组件移出
5.MouseMotionListener 接口
事件函数 触发时机
mouseMoved(MouseEvent e) 鼠标在此组件内移动
mouseDragged(MouseEvent e) 鼠标在此组件内进行拖拽并放开的动作
6.MouseWheelListener 接口
事件函数 触发时机
mouseWheelMoved(MouseWheelEvent e) 鼠标滚轮在此组件内滚动
二.Frame由Container类继承来的监听能力
Container 类定义的addXXXListener()方法
void addContainerListener(ContainerListener l)
void addPropertyChangeListener(PropertyChangeListener l)
void addPropertyChangeListener(String propertyName,PropertyChangeListener listener)
1.ContainerListener 接口
事件函数 触发时机
componentAdded(ContainerEvent e) 有一个组件移入此Container组件中
componentRemoved(ContainerEvent e) 有一个组件由此Container组件中移出
注：因Container的子类Window，覆盖了由Container继承的两个addPropertyChangeListener()方法，而Frame组件又继承自Window类，所以Frame组件使用的是Window类定义的addPropertyChangeListener()方法。
三.有Window类继承而来的监听能力
Window 类定义的addXXXlistener()方法
void addPropertyChangeListener(PropertyChangeListener listener)
void addPropertyChangeListener(String propertyName,PropertyChangeListener listener)
void addWindowFocusListener(WindowFocusListener l)
void addWindowListener(WindowListener l)
void addWindowStateListener(WindowStateListener l)
1.WindowFocusListener 接口：
事件函数 触发时机
windowGainedFocus(WindowEvent e) 当此Window组件取得程序焦点
windowLostFocus(WindowEvent e) 当此Window组件失去程序焦点
2.WindowListener 接口：
事件函数 触发时机
windowActivated(WindowEvent e) 当此Window组件现在设定为活动中的窗口
windowDeactivated(WindowEvent e) 当此Window组件现在要由活动中的窗口改成非 活动中的窗口
windowClosed(WindowEvent e) 当系统确实要处理掉（dispose）此Window组 件，而要关闭此窗口时
windowClosing(WindowEvent e) 用户通过窗口窗体企图关闭此Window组件时
windowDeiconified(WindowEvent e) 此Window组件由最小化的状态变成一般正常大 小时
windowIconified(WindowEvent e) 此Window组件由一般正常大小变成最小化的状 态
windowOpened(WindowEvent e) 此Window组件第一次被设定为visible的时候
3.WindowStateListener 接口：
事件函数 触发时机
windowStateChanged(WindowEvent e) 此Window组件的状态改变时
四.其他组件拥有的监听能力和常用的Listener接口
1.Button 组件拥有的监听能力
Button 类定义了一个注册事件监听者的方法，如下：
public void addActionListener(ActionListener l)
实现此“事件监听者”的Listener 接口如下：
ActionListener 接口:
此接口只拥有一个事件方法，因此没有一个与它对应的Adapter类
事件函数 触发时机
actionPerformed(ActionEvent e) 当ActionEvent对象产生时
2.TextComponent 组件拥有的监听能力
TextComponent 类定义了一个注册事件监听者的方法，如下：
public void addTextListener(TextListener l)
实现此“事件监听者”的Listener 接口如下：
TextListener 接口:
此接口只拥有一个事件方法，因此没有一个与它对应的Adapter类
事件函数 触发时机
textValueChanged(TextListener l) 当此组件的text值改变时
3.List 组件拥有的监听能力
List 类定义了两个注册事件监听者的方法，如下：
List 类定义的addXXXListener()方法
public void addActionListener(ActionListener l)
public void addItemListener(ItemListener l)
ItemListener 接口
此接口只拥有一个事件方法，因此没有一个与它对应的Adapter类
事件函数 触发时机
itemStateChanged(ItemEvent e) 当此组件的一个选项被用户“选取”或“反选”的 时候
4.Scrollbar 组件拥有的监听能力
Scrollbar 类定义了一个注册事件监听者的方法，如下：
public void addAdjustmentListener(AdjustmentListener l)
AdjustmentListener 接口：
此接口只拥有一个事件方法，因此没有一个与它对应的Adapter类
事件函数 触发时机
adjustmentValueChanged(AdjustmentEvent e) 当此组件某个可调整的值被改变的时候
第十三章、I/O处理
*****java内置流类（stream classes）根据它所操作的数据单位的类型分为两大类：一类是以字符（char）为单位的“字符流”（character streams），另一类是以字节为单位的“字节流”（byte streams）。它们负责输入和输出的基本代表分别是Reader和Writer类，以及InputStream和OutPutStream
1.字符流 Reader和Writer
|-CharArrayReader
|-StringReader
|-InputStreamReader---FileReader
Reader|-PipedReader
|-BufferedReader---LineNumberReader
|-FilterReader ---PushbackReader
|-CharArrayWriter
|-StringWriter
|-OutputStreamWriter---FileWriter
Writer |-PipedWriter
|-BufferedWriter
|-FilterWriter
|-PrintWriter
以上字符流类主要可以分为两大类，其中一类是负责不同数据存放方式的流类，如：CharArray、String、Pipe、File；另一类是对数据作额外处理的类，如：Buffered、Filter
2.字节流 InputStream和OutPutStream
一般用来读入和写出二进制数据，例如图象、声音。像字符流无法正常处理的可执行文件、压缩文件等，只要是“非纯文本”的数据，就要以此种流来处理。
|---ByteArrayInputStream
|---FileInputStream
|---StringBufferedInputStream
|---PipedInputStream |--BufferedInputStream
InputStream |---FilterInputStream----------------|--LineNumberInputStream
|---SequenceInputStream |--PushbackInputStream
|---ObjectInputStream |--DataInputStream
|---ByteArrayOutputStream
|---FileOutputStream
|---PipedOutputStream |--BufferedOutputStream
OutputStream |---FilterOutputStream---------------|--DataOutputStream
|---ObjectOutputStream |--PrintStream
以上字符流类主要可以分为两大类，其中一类是负责不同数据存放方式的流类，如：ByteArray、File、StringBuffer、Pipe；另一类是对数据作额外处理的类，如：Buffered、Filter
Buffered这一类得配合前一类的类使用，因此java提供的流类主要可分为：
无Buffer缓冲 有Buffer缓冲
以char为单位 Reader(及其子类) BufferedReader(配合 Reader 及其子类使用 )
Writer(及其子类) BufferedWriter(配合 Writer 及其子类使用 )
以byte为单位 InputStream(及其子类) BufferedInputStream(配合 InputStream 及其子 类使用 )
OutputStream(及其子类) BufferedOutputStream(配合 OutputStream及其
子类使用)
*****InputStream 类---以File存储类型介绍 j02130201
InputStream 定义的方法：
返回 方法 说明
int available()throws IOException 返回目前可由此输入流读入的byte数据的数量。 子类需要覆盖此方法，否则返回值都会是0
abstract int read()throws IOException 由此输入流读取下一个byte数据作为返回值，但 返回的byte值会以int类型的值展现，其值介于0 -255 之间，若已达流结尾，则返回-1。
int read(byte[]b)throws IOException 由输入流读取一些byte数据，并存放在参数代表 的数组中。然后将读取的byte数据的数量以int 值返回，若已达流结尾，则返回-1。
int read(byte[],int off,int len) 由输入流读取一些byte数据，并存放在参数代表
throws IOException 的数组的某段位置。然后将读取的byte数据的数 量以int值返回，若已达流结尾，则返回-1。
void reset() 将流内的位置移到上次以mark()方法标记的位置 。要看该流是否支持mark()和reset()，而 InputStream 的 mark()无实际作用，所以总是 抛出 IOException。
void mark(int readlimit) 标记目前于此输入流内的位置，直到再读入 readlimit个byte为止，这个标记都维持有效。 之后若使用reset()方法，会尝试移到所标记的 位置。但InputStream 的 mark()无实际作用
boolean markSupported() 测试此流是否支持mark()和reset()方法。只要 其中一个不支持，则返回false。
long skip(long n)throws IOException 跳过几个byte数据，并返回跳过的数量。跳过多 少字符由参数指定
void close()throws IOException 关闭此输入流，并释放任何与之关联的系统资源 。但 InputStream 的close()尚无实际作用。
*****OutputStream 类---以File存储类型介绍 j02130202
OutputStream定义的方法：
返回 方法 说明
void write(byte[]b)throws IOException 将一个byte[]数组的数据写到输入流。
void write(byte[]b,int off,int len) 将一个byte[]数组的部分数据写到输入流。
throws IOException
abstract void write(int b)throws IOException 写出一个byte数据到输出流，但代表该byte值的 参数为int类型
void flush() throws IOException 将流内的数据清出，并迫使缓冲区暂存的数据写 出。但OutputStream的flush()尚无实际意义。 void close()throws IOException 关闭此输入流，并释放任何与之关联的系统资源 。但 OutputStream 的close()尚无实际作用。
*****以char位为数据单位的流类
1.Reader 类----以File存储类型介绍 j02130301
返回 方法 说明
boolean ready()throws IOException 判断此数据流是否已就绪，之后能被读取。
int read()throws IOException 读入一个字符。读取的字符会以int类型表示， 其值的范围在0-65535（0x00-0xffff）之间。但 若已读到流结尾，无法在往后读一个字符，则返 回值为-1。
int read(char[] cbuf)throws IOException 将一些字符读入某个char[]数组，并返回所读入 的字符的数量。若已达到流结尾，则返 回值为- 1。
abstract int read(char[] cbuf,int off,int len) 将一些字符读入某个char[]数组的某段位置，并 throws IOException 返回所读入的字符的数量。若已达到流结尾，则 返 回值为-1。
void reset()throws IOException 重新设定流。如果之前此流内被标记了位置，使 用此方法会尝试移到之前标记的位置。若之前未 标记位置，将以适合该流的特定方式重新设定它 ，例如将所在位置设到流的其始点。但并非所有 字符流都支持reset()云作，有些虽支持reset() ，却并不支持mark()云作。
void mark(int readAheadLimit) 标记目前在流内的所在位置，直到再读入 throws IOException readAheadLimit个char为止，这个标记都维持有 效。之后使用reset()方法，会尝试移到流内被 标记的位置。并非所有字符流都支持mark()方法 。
boolean markSupported 判断此数据流是否支持mark()方法。但子类必须 覆盖此方法才有效，否则只返回false。
long skip(long n) 跳过字符 ，并返回所跳过的字符的数量。跳过 多少字符由参数指定，若参数值为负数，会引发 IllegalArgumentException例外
abstract void close() 关闭数据流。当关闭数据流，就不再使用它的 read()，ready()，mark()，reset()方法，否则 会抛出 IOException 例外
2.Writer 类----以File存储类型介绍 j02130302
返回 方法 说明
void write(char[]cbuf)throws IOException 将一个字符数组的数据写出。
abstract void write(char[] cbuf,int off,int len) 将某个字符数组的一部分数据写出。
throws IOException
void write(int c)throws IOException 写出一个字符，但代表该字符的参数为int类型
void write(String str)throws IOException 写出一个字符串。
void write(String str，int off，int len) 将某字符串的一部分写出。
abstract void flush()throws IOException 将流内未输出的数据清出。如果流内经write() 方法在缓冲区暂存了数据，使用此方法会令数据 立即输出到目的地。
abstract void close()throws IOException 让数据由流输出，然后关闭此流。当关闭流之后 ，若再使用write()或flush()方法将导致 IOException 例外。
*****有Buffer缓冲的I/O类
一.有Buffer缓冲的byte流 j02130401
BufferedInputStream 类，它的构造函数：
1.BufferedInputStream(InputStream in)
以缺省的缓冲区大小构造一个byte输入流，以JDK 1.4 而言，此缓冲区缺省大小为2048个byte，而缓冲数据就存于此类的buf字段。至于输入的数据来源，就决定于参数in代表的byte流。
2.BufferedInputStream(InputStream in,int size)
与前者相似，但缓冲区大小由size参数决定。
BufferedOutputStream 类，它的构造函数：
当byte数据写到内部缓冲区时，当下列任何一种情况发生时，里面的数据就会写到输出流中，情况包括：缓冲区内数据已饱和、输出流被关闭、或以flush()明确要求输出流清出。
构造函数：
1.BufferedOutputStream(OutputStream out)
以缺省的缓冲区大小构造一个byte输出流，以JDK 1.4 而言，此缓冲区缺省大小为512个byte，而缓冲数据就存于此类的buf字段。至于输出的数据来源，就决定于参数out代表的byte流。
2.BufferedOutputStream(OutputStream out,int size)
与前者相似，但缓冲区大小由size参数决定。
二.有Buffer缓冲的char流 j02130402
除了能支持mark()、reset()、skip()、flush()方法外，还提供了能就我们一次读写“一行文字”的readLine()和newLine()方法
BufferedReader 类，构造函数：
1.BufferedReader(Reader in)
以缺省的缓冲区大小构造一个char输入流，以JDK 1.4 而言，此缓冲区缺省大小为8192个char，输入的数据来源，就决定于参数in代表的char流。
2.BufferedReader(Reader in,int sz)
与前者相似，但缓冲区大小由sz参数决定。
此类新增的方法为readLine()，方法定义如下：
返回 方法 说明
String readLine()throws IOException 读入一行文字。“一行”意思，就是一连串文字以 '/n'或'/r'等字符做结尾。而此方法将返回代表 读入的内容的 String ，但并不包含该行的结尾 字符。若已达结尾而未读入任何文字，则返null
BufferedWriter 类，构造函数：
1.BufferedWriter(Writer out)
以缺省的缓冲区大小构造一个char输出流，以JDK 1.4 而言，此缓冲区缺省大小为8192个char，输入的数据来源，就决定于参数out代表的char流。
2.BufferedWriter(Writer out,int sz)
与前者相似，但缓冲区大小由sz参数决定。
此类新增的方法为newLine(),方法定义如下：
返回 方法 说明
void newLine()throws IOException 写出一个“一行文字的结尾”。若在windows平台，此方法写出的结尾是 '/n'字符，但并非所有平台都以'/n'字符作为一行的结尾，以何种字符作结尾是由系统的“line.separator”属性决定
*****各种I/O存储类型
基于I/O存储类型，主要可分为：Memory、File和Pipe三大类型。其中，Memory一类的流类，是用来对Memory作存取；File一类的流类，则是对操作系统上的文件作存取；而Pipe一类的流类，则是用来实现构成一个Pipe（管道）的输入及输出流。
数据存储类型 流类
Memory CharArrayReader
CharArrayWriter
ByteArrayInputStream
ByteArrayOutputStream
StringReader
StringWriter
StringBufferInputStream
File FileReader
FileWriter
FileInputStream
FileOutputStream
Pipe PipedReader
PipedWriter
PipedInputStream
PipedOutputStream
1.数组的I/O
利用CharArrayReader或ByteArrayInputStream 能在Memory中现存的数组（char[]或byte[]）建立输入流，也就是以数组作为数据来源。之后就使用read()方法，由来源数组读入数据。利用CharArrayWriter或 ByteArrayOutputStream类建立输出流，建立时会自动在Memory配置一块作为存放输出的数据的数组。之后就使用writer()方法，将数据写出到目的数组，而此数组存储的数据可利用toCharArray()(或toByteArray())和toString()方法取得。
ByteArrayInputStream 的构造函数
ByteArrayInputStream(byte[] buf)
建立一个ByteArrayInputStream流，并以参数代表的byte[]数组的数据，作为输入流的数据来源。
ByteArrayInputStream(byte[] buf,int offset,int length)
建立一个ByteArrayInputStream流，并以参数代表的byte[]数组的某部分数据，作为输入流的数据来源。
ByteArrayInputStream 也支持mark(),reset(),skip()等方法，但close()方法没有实际作用
ByteArrayOutputStream 的构造函数
ByteArrayOutputStream()
建立一个ByteArrayOutputStream流，其目的地数组的初始化长度为默认值。
ByteArrayOutputStream（int size）
建立一个ByteArrayOutputStream流，并以seze参数指定目的地数组的初始化长度
它的flush()和close()都没有实际作用
ByteArrayInputStream 新增方法：
返回 方法 说明
void reset() 将此ByteArrayInputStream的count字段值设定
为0，如此则目前积累输出到目的地的数据将全
被放弃。
int size() 返回此时目的数组的长度
byte[] toByteArray() 返回一个新建的byte[]数组，其长度和数据内 容同于此输出流的目的数组。
String toString() 将目的数组的内容转换为一个字符串。
void writeTo(OutputStream out) 将目的数组内所有内容写出到out参数指定的另
throws IOException 一个字节输出流，其功能如同以out代表的流使 用write(buf,0,count)方法将数据写出。
CharArrayReader 的构造函数
CharArrayReader(char[] buf)
建立一个以buf数组为数据来源的CharArrayReader流
CharArrayReader(char[] buf,int offset,int length)
建立一个以buf数组的部分内容为数据来源的CharArrayReader流
它也支持mark(),reset(),skip()等方法，但它的close()方法会取消对来源数组的参考，使用此方法后就无法再由该流读入数据
CharArrayWriter 的构造函数
CharArrayWriter()
建立一个CharArrayWriter流，其目的地数组的初始化长度为默认值。
CharArrayWriter(int initialSize)
建立一个CharArrayWriter流，并由initialSize参数指定目的地数组的初始化长度
此类的close()方法并不会将目的数组释放，故其内的数据内容仍然会存在。
CharArrayWriter 新增方法：
返回 方法 说明
void reset() 将此CharArrayWriter的count字段值设定为0， 如此则目前积累输出到目的地的数据将全被放 弃，如此可重复利用此流将数据输入到内存
int size() 返回此时目的数组的长度
char[] toCharArray() 返回一个新建的byte[]数组，其长度和数据内
容同于此输出流的目的数组。
String toString() 将输出的目的数组的内容转换为一个字符串。
void writeTo(Writer out) 将目的数组内所有内容写出到out参数指定的另
throws IOException 一个字符输出流
使用上述4个流的例子 j02130501
2.字符串的I/O
StringReader 的构造函数
StringReader(String s)
建立一个以参数指定的 String 为数据来源的StringReader流
它也支持mark(),reset(),skip()等方法，但它的close()方法会取消对来源 String 的参考，使用此方法后就无法再由该流读入数据
StringWriter 构造函数
StringWriter()
建立一个StringWriter流，其目的字符串（ StringBuffer ）的初始化长度为默认值
StringWriter(int initialSize)
建立一个StringWriter流，并以initialSize参数指定其目的字符串（ StringBuffer ）的初始化长度
此类的close()方法并不会将目的字符串释放，故其内的数据内容仍然会存在。
StringWriter 新增的方法；
返回 方法 说明
StringBuffer getBuffer() 返回此输出流本身存储数据的StringBuffer对 象
String toString() 将此输出流的目的StringBuffer内含的字符串 内容转换为一个 String
3.对File的I/O
FileInputStream 的构造函数：
FileInputStream(File File(小写))throws FileNotFoundException
以打开对某一实际文件的连接的方式，建立一个 FileInputStream 流，所连接的源文件是由file参数代表的File对象决定
FileInputStream(FileDescriptor fdObj)
以使用FileDescriptor对象决定源文件的方式，建立一个 FileInputStream 流。而fdObj参数导入的FileDescriptor对象，代表一个目前存在、对某个实际文件的连接
FileInputStream(String name)throws FileNotFoundException
以打开对某一实际文件的连接的方式，建立一个 FileInputStream 流，所连接的源文件是由name参数
决定，而name字符串内容包括文件的目录和名称
FileInputStream 新增的方法：
返回 方法 说明
protected void finalize()throws IOException 确保不再有任何地方参考此流对象时，有调用 它的close()方法，适时关闭流
FileChannel getChannel() 返回此FileInputStream流所结合的 FileChannel对象
FileDescriptor getFD()throws IOException 返回一个代表此FileInputStream流现在所连接 的文件来源的FileDescriptor 对象
FileOutputStream 的构造函数：
FileOutputStream(File File(小写))throws FileNotFoundException
建立一个FileOutputStream流，而输出的目的文件由file参数决定
FileOutputStream(File File,boolean append)throws FileNotFoundException
与前一个构造函数相似，但以append参数决定将byte数据写大目的文件的开头，还是续接于原有数据之后，当append的值为true时，数据就续接于后。
FileOutputStream(FileDescriptor fdObj)
建立一个FileOutputStream流，输出的目的文件由fdObj参数指定，它代表一个目前存在、对某个实际文件的连接。
FileOutputStream(String name)throws FileNotFoundException
建立一个FileOutputStream流，输出的目的文件由name参数指定，而name字符串内容包含文件的目录和名称
FileOutputStream(String name,boolean append)throws FileNotFoundException
与前一个构造函数相似，但以append参数决定将byte数据写大目的文件的开头，还是续接于原有数据之后，当append的值为true时，数据就续接于后。
FileOutputStream 新增的方法：与 FileInputStream 新增的方法相同
FileReader 的构造函数：
FileReader(File File(小写))throws FileNotFoundException
建立一个 FileReader流，并以File类的参数指定源文件
FileReader(FileDescriptor fd)
建立一个FileReader流，并以FileDescriptor类的参数指定源文件
FileReader(String fileName)throws FileNotFoundException
建立一个FileReader流，并以fileName参数指定源文件的目录及名称
FileReader 继承了 FileInputStream ，因此除了继承自 Reader 的基本方法外，它还拥有一个getEncoding()方法(参考 InputStreamReader)，而它的close()也会让此 FileReader 取消对源文件的连接，所以使用后不能再由源文件读取数据。另外 FileReader 拥有的mark()、reset()、skip()方法仍然是由 Reader 提供，无实际作用。
FileWriter 的构造函数：
FileWriter(File File（小写）)throws IOException
建立一个 FileWriter流，并以File类的参数指定源文件
FileWriter(File File,boolean append)throws IOException
与前一个构造函数相似，但以append参数决定将char数据写到目的文件的开头，还是续接于原有数据之后，当append的值为true时，数据就续接于后。
FileWriter(FileDescriptor fd)throws IOException
建立一个 FileWriter 流，并以fd参数指定所连接的目的文件
FileWriter(String fileName)throws IOException
建立一个FileWriter流，输出的目的文件由fileName参数决定，而fileName字符串内容包含文件的目录和名称。
FileWriter(String fileName,boolean append)throws IOException
与前一个构造函数相似，但以append参数决定将char数据写到目的文件的开头，还是续接于原有数据之后，当append的值为true时，数据就续接于后。
FileWriter 流类，它继承来的flush()和close()都已经由 OutputStreamWriter 改写过，因此使用close()之后，就无法再以此 FileWriter 输出数据。它还拥有一个getEncoding()方法(参考 outputstreamreader)
*****File类介绍
File 类的构造函数：
File(File parent,String child)
建立一个 File 对象，以parent参数导入的 File 对象代表的抽象路径作为前半段的路径，以child字符串指定后半段的路径
File(String pathname)
建立一个 File 对象，以pathname参数导入的字符串转换为抽象路径
File(String parent,String child)
建立一个File 对象，以parent参数指定前半段的路径，以child参数指定后半段的路径
File(URI uri)
建立一个File 对象，以uri参数导入的URI（Uniform Resource Identifier）对象转换为抽象路径
File 类的 static 字段
类型 字段名称 说明
static String pathSeparator 以 String 类型的值，代表此操作系统独特的名称分 隔符，windows系统下此字段的值为“；”
static char pathSeparatorChar 与前者相似，但是以char类型的值代表名称分隔符， 则此字段的值为“：”或“；”。
static sting separator 以 String 类型的值，代表此操作系统独特的路径分 隔符，在windows系统下，标准的路径分隔符为“/”， 但java的程序代码要以“//”字符串表示，故此字段的 值为“//”.
static char separatorChar 与前者相似，但是以char类型的值代表路径分隔符，
则此字段的值为“/”或“//”。
File 类基本常用方法：
返回 方法 说明
boolean canRead() 检验此程序是否能读取File代表的文件
boolean canWrite() 检验此程序是否能将数据写入此File代表的文件
String getName() 以 String 类型返回此 File 代表的文件或目录（最 末层）例如：“test/data”,则返回“data”
String getParent() 返回此 File代表的文件或目录所在的抽象路径，如： “test/data/A01”则返回“test/data”，若构造时未指 定上层目录，则返回null
String getPath() 以 String 类型返回此 File 代表的抽象路径，其值 相当于getName()＋getParent()
File getParentFile() 与前者相似，但返回的时代表上层目录的 File 对象
boolean isDirectory() 检验此 File 代表的是否为“目录”
boolean isFile() 检验此 File 代表的是否为“文件”
boolean creatNewFile() 若此 File 代表的文件不存在，且上层目录存在时，
throws IOException 就会新建此文件，但只是一个空的文件。但方法无法 自动判断此 File 是否代表文件，即使抽象路径为“ mydir”，仍会建立一个名为“mydir”的文件（无扩展名
boolean mkdir() 若此 File 代表的目录不存在，且上层目录存在时， 就会新建此目录。但不会自动判断此 File 是否代表 目录，即使抽象路径为"myFile.txt",仍会建立一个名 为“myFile.txt”的目录。
boolean mkdirs() 与前者相似，但上层目录若不存在，会自动建立上层 目录（parent）以及此目录。
boolean delete() 删除此 File 代表的文件或目录，若成功删除则返回 true。它若是目录，则其内不能有任何文件或目录才 能成功删除。
boolean renameTo(File dest) 将此 File 代表的文件或目录改名称，以dest参数代 表的抽象路径指定新路径（包含上层路径）。但前提 是dest的上层路径（parent）必须已经存在，否则更 名行为无效，返回值为false。成功返回true。
long length() 返回此 File 代表的文件的大小，单位是字节（byte ）。若文件不存在，或代表的是目录，都会返回0
boolean exists() 检验此 File 代表的文件或目录是否存在。
int compareTo(File pathname) 比较此 File 与另一 File 所代表的两个抽象路径。 File 型若两者代表的抽象路径相同则返回0，若表示 此 File 的字符串值较大，则返回正数值，反之，则 返回负数值
int compareTo(Object o) 与前者相似，但导入作比较的对象若不满足 File 类 型，则会抛出 ClassCastException 例外.
boolean equals(Object obj) 比较此 File 与obj导入的对象，若参数导入的是 File 类型的对象，而且它代表的抽象路径又同于此
File 时，返回值才会是true。
File 类的方法，用来取得此 File 代表的目录下的各文件或目录，或者用来取得本机系统的所有根目录
返回 方法 说明
String[] List() 以 String[]类型返回此 File 代表的目录内 的所有子目录或文件
String[] List(FilenameFilter filter) 与前者相似，但利用filter参数指定的 FilenameFilter 对象过滤出所要的子目录或 文件
File[] listFiles() 以 File[] 类型返回此 File 代表的目录内的 所有子目录或文件
File[] listFiles(FileFilter filter) 与前者相似，但利用filter参数指定的 FileFilter 对象过滤出所要的子目录或文件
File[] listFiles(FilenameFilter filter) 与前者相似，但利用filter参数指定的 FilenameFilter 对象过滤出所要的子目录或 文件
static File[] listRoots() 返回该平台下所有文件系统根目录，如 :"C:/","D:/"
File 类的其他方法：
返回 方法 说明
boolean setLastModified(long Time) 设定此 File 代表的文件最后一次修改的时 间。以long类型的time参数指定时间，其值 0L代表1970年1月1日0时0分0秒
long lastModified() 以long类型返回最后一次修改此文件的时间
boolean setReadOnly() 将此 File 代表的文件或目录设为“只读”
boolean isHidden() 检验此 File 代表的文件或目录是否处于“隐 藏”状态
boolean isAbsolute() 检验此 File 代表的是否为“绝对路径”
File getAbsoluteFile() 以“绝对路径”的格式返回此 File 对象代表 的抽象路径。若此 File 代表“test/t1.txt” ,此方法返回的 File 可能代表“ c:/test/t1.txt”
String getAbsolutePath() 与前者相似，但返回值是代表路径的字符串
File getCanonicalFile() 以“标准实际路径”的格式返回此 File 对象 代表的抽象路径
String getCanonicalpath() 与前者相似，但返回值是代表路径的字符串
static File createTempFile(String prefix, 以缺省的临时文件路径建立一个空的 File
String suffix) ，并以prefix参数指定文件的前缀，以 suffix参数指定文件的字尾
static File createTempFile(String prefix, 以directory参数指定的路径建立一个空的
String suffix,File directory) File ，并以prefix参数指定文件的前缀， 以 suffix参数指定文件的字尾
void deleteOnExit() 要求此 File 代表的文件或目录在JVM结束 时能删除此文件或目录
int hashCode() 计算此 File 代表的文件或目录的哈希码
String toString() 以string类型返回此 File 代表的抽象路径
URI toURI() 以此file代表的抽象路径建立一个URI对象
URL toURL() 以此file代表的抽象路径建立一个URI对象
利用 File 配合 BufferedInputStream 和 BufferedOutputStream 的例子 j02130502
4.对Pipe的I/O: 例子：j02130503
PipedInputStream 类：
构造函数：
PipedInputStream()
建立一个 PipedInputStream ，但尚未连接到任何的 PipedOutputStream 流
PipedInputStream(PipedOutputStream src)throws IOException
建立一个 PipedInputStream ，并且连接到src参数指定的 PipedOutputStream 流
此类新增的方法：
返回 方法 说明
void connect(PipedOutputStream src) 连接src参数指定的PipedOutputStream流。
throws IOException 但欲连接的流若已经和其他流连接，会抛出 IOException
protected void receive(int b) 将某个byte数据接收到PipedInputStream
throws IOException 的缓冲区中。此方法一般是由此流所连接的
PipedOutputStream 自动调用，当它将数据
写出到Pipe时，会调用此方法让数据接收到
对方的缓冲区。
此外，PipedInputStream 继承自 InputStream 的方法中，availble()和close()都经过了改写，有实际作用，但是mark()和reset()未经过改写，无实际作用
PipedOutputStream 类：
它的构造函数：
PipedOutputStream()
建立一个PipedOutputStream，但尚未连接到任何的 PipedInputStream 流
PipedOutputStream(PipedInputStream snk)throws IOException
建立一个 PipedOutputStream ，并且连接到snk参数指定的 PipedInputStream 流
此类新增方法：
返回 方法 说明
void connect(PipedInputStream snk) 连接snk参数指定的PipedInputStream流。
throws IOException 但欲连接的流若已经和其他流连接，会抛出 IOException
PipedOutputStream 类也覆盖了flush()和close()方法，它的flush()方法除了将缓冲的数据清出外，还会通知Pipe输入流：“在Pipe内有byte数据等待被读取”
PipedInputStream 和 PipedOutputStream 的建立不分先后顺序，都能在两个流之间建立Pipe
PipedReader 类：
它的构造函数：
PipedReader()
建立一个PipedReader，但尚未连接到任何的 PipedWriter 流
PipedReader(PipedWriter src)throws IOException
建立一个 PipedReader ，并且连接到src参数指定的 PipedWriter 流
此类新增方法：
返回 方法 说明
void connect(PipedWriter src) 连接src参数指定的PipedWriter 流。
throws IOException 但欲连接的流若已经和其他流连接，会抛出 IOException
PipedWriter 类：
它的构造函数：
PipedWriter()
建立一个PipedWriter，但尚未连接到任何的 PipedReader 流
PipedWriter(PipedReader,snk)throws IOException
建立一个 PipedWriter ，并且连接到snk参数指定的 PipedReader 流
此类新增方法：
返回 方法 说明
void connect(PipedReader snk) 连接snk参数指定的PipedReader 流。
throws IOException 但欲连接的流若已经和其他流连接，会抛出 IOException
*****各种I/O类处理方式：
特殊处理方式 流类
转换byte流为char流 InputStreamReader
OutputStreamWriter
输出数据 PrintWriter
PrintStream
连接多各流 SequenceInputStream
过滤数据 FilterReader
FilterWriter
FilterInputStream
FilterOutputStream
(以上4者的各个类)
预视数据（Peeking Ahead） PushbackReader
PushbackInputStream
数据转换 DataInputStream
DataOutputStream
计算行数 LineNumberReader
LineNumberInputStream
对象序列化（Object Serialization） ObjectInputStream
ObjectOutputStream
转换byte流为char流：例子 j02130601
InputStreamReader 类：
构造函数：
InputStreamReader(InputStream in)
建立一个InputStreamReader 流，以缺省的字符集（charset），转换in参数指定的InputStream流
InputStreamReader(InputStream in,Charset cs)
建立一个InputStreamReader 流，以cs参数指定的字符集（charset），转换in参数指定的InputStream流
InputStreamReader(InputStream in,CharsetDecoder dec)
建立一个InputStreamReader 流，以dec参数指定的CharsetDecoder对象，转换in参数指定的InputStream 流
InputStreamReader(InputStream in,String charsetName)throws UnsupportedEncodingException
建立一个InputStreamReader 流，以charsetName字符串指定的字符集，转换in参数指定的InputStream 流
此类新增的方法：
返回 方法 说明
String getEncoding() 以 String 类型返回此InputStreamReader流使用的 字符编码（character encoding）
OutputStreamWriter 类：
构造函数：
OutputStreamWriter(OutputStream out)
建立一个OutputStreamWriter 流，以缺省的字符集（charset），转换out参数指定的OutputStream流
OutputStreamWriter(OutputStream out,Charset cs)
建立一个OutputStreamWriter 流，以cs参数指定的字符集（charset），转换out参数指定的OutputStream流
OutputStreamWriter(OutputStream out,CharsetEncoder enc)
建立一个OutputStreamWriter 流，以dec参数指定的CharsetDecoder对象，转换out参数指定的OutputStream 流
OutputStreamWriter(OutputStream out,String charsetName)throws UnsupportedEncodingException
建立一个InputStreamReader 流，以charsetName字符串指定的字符集，转换out参数指定的OutputStream 流
此类新增的方法：
返回 方法 说明
String getEncoding() 以 String 类型返回此OutputStreamWriter流使用的 字符编码（character encoding）
利用 System 类的in字段，取得用户在console模式中输入的文字 例子 j02130602
***** 打印数据 例子 j02130603
主要有 PrintStream 和 PrintWriter 两个类，分别负责处理byte和char流
PrintStream 类：
此类的构造函数：
PrintStream(OutputStream out)
以一个现存的OutputStream 流建立一个PrintStream 流，但此流不具有自动flush的能力
PrintStream(OutputStream out,boolean autoFlush)
以一个现存的OutputStream 流建立一个PrintStream 流，而autoFlush参数决定是否要有自动flush的能力
PrintStream(OutputStream out,boolean autoFlush,String encoding)throws
UnsupportedEncodingException
以一个现存的OutputStream 流建立一个PrintStream 流，与前者相似，并且以encoding参数指定此流支持的字符编码（character encodidng）
若一个PrintStream类构在时导入的autoFlush参数为true,则当一个byte数组的数据被写出（writer()）、或使用任一种print()方法（因为它会调用write()）、或使用了任一种println()方法、或者一个“一行的结尾”（如：“/n”）被写出时，都会自动调用此流的flush()。
PrintWriter 类：
此类的构造函数：
PrintWriter(Writer out)
以一个现存的Writer流建立一个PrintWriter流，但此流不具有自动flush的能力
PrintWriter(Writer out,boolean autoFlush)
以一个现存的Writer流建立一个PrintWriter流，而autoFlush参数决定是否要有自动flush的能力
PrintWriter(OutputStream out)
以一个现存的OutputStream流建立一个PrintWriter流，但此流不具有自动flush的能力
PrintWriter(OutputStream out,boolean autoFlus)
以一个现存的OutputStream流建立一个PrintWriter流，而autoFlush参数决定是否要有自动flush的能力
此类，若autoFlush参数为true，则唯有使用println()方法才会自动调用flush()。
PrintStream 类和 PrintWriter 类，不像其他的 OutputStream 会抛出 IOException ，若想知道此流在处理过程中是否产生例外，可使用checkError()方法，清空（flush）缓冲区并检查是否有例外。
※※※※※连接多个流（Concatenation） 例子j02130604
一个 SequenceInputStream 流，实际上是代表其他多个 InputStream 流的逻辑连续。它提供的处理，是由组成此连续流的第一个 InputStream 流开始读入数据，待第一个流读完后，接着就读第二个流的数据，如此直到读完此 SequenceInputStream 所连接最后一个 InputStream 流为止。
SequenceInputStream 类的构造函数：
SequenceInputStream(Enumeration e)
建立一个SequenceInputStream 流，以e参数指定的Enumeration（枚举）对象提供诸多InputStream 流，作为数据来源。所读取的数据为e枚举内所有 InputStream 流的连接。
SequenceInputStream(InputStream s1,InputStream s2)
建立一个SequenceInputStream 流，以s1和s2参数所指定的InputStream 流，作为数据来源。所能读取的数据为s1与s2流的连接。
此种流除了 InputStream 定义的那些方法外，没由新增方法。但使用available()时要特别注意，它在读取数据的过程种，当其内第一个流读完时，availabel()方法返回的值会是0，但等到自动读完第二个流时，available()返回的值就不再是0，而是第二个流当时能被读取的数据量。
※※※※※ 预视数据（Pushback） j02130605
PushbackInputStream 和 PushbackReader 分别适用于 byte 流和char流
PushbackInputStream 构造函数：
PushbackInputStream(InputStream in)
建立一个PushbackInputStream 流，以in参数指定的 InputStream 流为处理对象，并以 1 byte作为回推缓冲区的大小。
PushbackInputStream(InputStream in,int size)
与前者相似，另外以size参数指定回推缓冲区的大小
此类新增的方法：
返回 方法 说明
void unread(byte[] b) 将b数组所含的byte值回推至流，也就是将b
throws IOException 数组所含的值复制到回推缓冲区的最前面
void unread(byte[] b,int off,int len) 将b数组所含的byte值的一部分回推至流，也
throws IOException 就是将b数组所含的值复制到回推缓冲区的最 前面
void unread(int b)throws 将参数b指定的byte值回推至流，也就是将b
IOException 的值复制到回推缓冲区的最前面
PushbackReader 的构造函数：
PushbackReader(Reader in)
建立一个 PushbackReader流，以in参数指定的 Reader 流为处理对象，并以 1 byte作为回推缓冲区的大小(pushback buffer)
PushbackReader(Reader in,int size)
与前者相似，另外以size参数指定回推缓冲区的大小
此类新增的方法:
返回 方法 说明
void unread(char[] cbuf) 将cbuf数组所含的char值回推至流，也就是
throws IOException 将cbuf数组所含的值复制到回推缓冲区的最 前面
void unread(char[] cbuf,int off,int len) 将cbuf数组所含的char值的一部分回推至流
throws IOException 就是将cbuf数组所含的值复制到回推缓冲区 的最前面
void unread(int c)throws 将参数c指定的char值回推至流，也就是将c
IOException 的值复制到回推缓冲区的最前面
※※※※※数据转换 例子 j02130606
DataInputStream 类构造函数：
DataInputStream(InputStream in)
建立一个DataInputStream流，以in参数指定的 InputStream 为处理的对象
此类实现了 DataInput 接口。拥有将各类数据依不同类型格式读入的方法。
此类常用方法:
返回 方法 说明
int skipBytes(int n)throws IOException 尝试跳过n各byte的数据，返回的值为真正
跳过的byte数量
boolean readBoolean()throws IOException 由所配合的流读取 1 个byte，返回为java 基本数据类型的boolean值。当来源的byte
值不为0时，读取的值为true，反之当来源
的byte值为0，则读取的值为false
byte readByte()throws IOException 由所配合的流读取 1 个byte，返回为java
基本数据类型的byte值
char readChar()throws IOException 由所配合的流读取 1 个byte，返回为java
基本数据类型的char值
short readShort()throws IOException 由所配合的流读取 2 个byte，返回为java
基本数据类型的short值
int readInt()throws IOException 由所配合的流读取 4 个byte，返回为java
基本数据类型的int值
long readLong()throws IOException 由所配合的流读取 8 个byte，返回为java
基本数据类型的long值
float readFloat()throws IOException 由所配合的流读取 4 个byte，返回为java
基本数据类型的float值
double readDouble()throws IOException 由所配合的流读取 8 个byte，返回为java
基本数据类型的double值
void readFully(byte[] b) 由所配合的流读取若干byte的数据，并将数
据存入参数指定的b数组
void readFully(byte[] b,int off,int len) 由所配合的流读取若干byte的数据，并将数
throws IOException 据存入参数指定的b数组某一部分
int readUnsignedByte()throws 由所配合的流读取 1 个byte，返回为无负
IOException 号的整数值，即其值范围在0－255
int readUnsignedShort()throws 由所配合的流读取 2 个byte，返回为无负
IOException 号的整数值，即其值范围在0－65535
String readUTF()throws IOException 读取所配合的流内的数据，返回一个使用可
修改的UTF-8 编码格式的字符串
DataOutputStream 构造函数：
DataOutputStream(OutputStream out)
建立一个DataOutputStream流，以out参数指定的OutputStream为处理的对象
此类实现了 DataOutput 接口。 拥有将各种不同类型的数据写出的方法。
此类常用方法：
返回 方法 说明
int size() 返回到目前为止些到此DataOutputStream流
的byte数量
void writeBoolean(boolean v) 将一个java的boolean值写出为所配合的输出
throws IOException 流的 1 个byte
void writeByte(int v) 将一个java的byte值写出为所配合的输出
throws IOException 流的 1 个byte
void writeBytes(String s) 将一个java的String值写出为所配合的输出
throws IOException 流的一连串byte
void writeChars(String s) 将一个java的String值写出为所配合的输出
throws IOException 流的一连串char
void writeShort(int v) 将一个java的short值写出为所配合的输出
throws IOException 流的 2 个byte,由高位开始
void writeInt(int v) 将一个java的int值写出为所配合的输出
throws IOException 流的 4 个byte,由高位开始
void writeLong(long v) 将一个java的long值写出为所配合的输出
throws IOException 流的 8 个byte,由高位开始
void writeFloat(float v) 以Float类的floatToIntBits()将v参数的值
throws IOException 转为int类型，再将此int值写出为所配合的
输出流的 1 个 4 byte的量，由高位开始
void writeDouble(double v) 以Double类的DoubleToLongBits()将v参数值
转为long类型，再将此long值写出为所配合的
输出流的 1 个 8 byte的量，由高位开始
void writeUTF(String str) 依机器平台独立的模式，将java的string以
throws IOException UTF-8 编码写出为所配合的输出流的字符串
※※※※※计算行数 例子 j02130607
LineNumberReader 类：
由于LineNumberReader 类继承自 BufferedReader，故此流是一种由缓冲的char输入流，其主要功能是能记录所读入的数据的行数。缺省行数是由0开始，每当读入一行文字时，行数就会加 1 。而所谓的一行是再碰到“结尾字符”（'/n'）或“回返字符”（'/r'）之前那一连串的字符
LineNumberReader 类构造函数：
LineNumberReader(Reader in)
建立一个LineNumberReader 流，而拥有缺省大小的输入缓冲区
LineNumberReader(Reader in,int sz)
建立一个LineNumberReader 流，并以sz参数指定缓冲区的大小
LineNumberReader 新增常用方法：
返回 方法 说明
String readLine()throws IOException 读一行的文字
int getLineNumber() 取得现在已读入的行数
void setLineNumber(int lineNumber) 设定现在已读入的行数
※※※※※对象序列化（Object Serialization）
这方面的功能处理，主要是将对象写到输出流，或者由输入流将对象读入，这个处理就称为“对象序列化”。一个对象若要写出到流，就必须经过序列化（serialize），相对的，若从流读入对象，必须将它反序列化（deserialize），这些功能就分别由 ObjectInputStream 和 ObjectOutputStream 提供处理
对象的序列化的用途：
1.RMI（Remote Method Invocation）机制，通过各个Socket，作对象之间的通讯。
2.将对象存成文件，以备将来让同一个程序连续着使用。
只有实现 java.io.Serializable 接口的类，其所产生的对象才能被序列化。 Serializable 接口并不含任何方法定义，因此不必实现任何特定的方法。像 String,Integer,Double 等，这些内置类就都有实现 Serializable 接口，所以它们的对象都可被序列化。
对象实例的序列化是由 ObjectOutputStream 类的defaultWriteObject() 方法控制，自动帮我们将重建此对象时所需的内容都写出到流包括：
1.此对象的类类型。
2.类的签名
3.此对象内所有“非static”和“非transient”成员的值，包括参考到其他对象的成员在内。
倘若该对象某些字段的状态并不需要保存到以后使用，例如一个记录现在时间的字段，则可将它定义为transient成员
对象实例的反序列化则是由 ObjectInputStream 类的defaultWriteObject()方法负责处理。而defaultWriteObject() 是要由writeObject()调用，defaultReadObject()则要由readObject()调用，否则将产生NotActiveException例外。
例子 j02130608
ObjectOutputStream 和 ObjectInputStream 类： j02130609
ObjectOutputStream 的构造函数：
ObjectOutputStream (OutputStream out)
建立一个ObjectOutputStream ，而数据要写出到out指定的OutputStream
ObjectOutputStream 主要常用方法;
返回 方法 说明
void writeObject(Object obj) 将obj参数指定的对象（可被序列化者）写至
throws IOException 此ObjectOutputStream
void writeUnshared(Object obj) 写出一个“unshared”的对象（可被序列化者
throws IOException ）到此ObjectOutputStream。此方法与
writeObject()大致相似，其差异是此方法总
是给予此流一个最新而唯一的对象。
void reset()throws IOException 此方法将忽视之前已写入此流的任何对象的 状态，也就是它将令此流成为全新的 ObjectOutputStream
ObjectInputStream 的构造函数如下：
ObjectInputStream (InputStream in)
建立一个 ObjectInputStream ，而数据要从in指定的InputStream 读取
ObjectInputStream 主要常用方法：
返回 方法 说明
Object readObject()throws IOException , 由此ObjectInputStream读入一个对象
ClassNotFoundException
Object readUnshared()throws IOException, 由此ObjectInputStream读入一个“
ClassNotFoundException unshared”的对象。此方法与 readObject() 和 readUnshared()
调用，在返回时获得对反序列化后对象
实例额外的参考。
第十五章
ServerSocket 类介绍
此类实现了“Server端Socket”，它的主要功用是等候来自网络上的“请求”，而它所展现的一些动作，正是以那些“请求” 为基础，并且也可能返回一个结果给“请求者”。
关于ServerSocket 的实际运作，其实是由一个 SocketImpl 实例来展现，当应用程序建立一个新的 ServerSocket 对象时，“Socket生产处”的createSocketImp()方法会被调用，以产生实际的 Socket 实现。应用程序能通过变更来产生 Socket 实现的“Socket生产处”，使它本身产生适用于本地端防火墙的 Socket
ServerSocket 类的构造函数：
ServerSocket()throws IOException
建立一个尚未绑定到本地端的ServerSocket
ServerSocket(int port)throws IOException
建立一个由port指定本机端口的ServerSocket。若port指定为0，则会在任一可自由使用的端口上建立ServerSocket
ServerSocket(int port，int backlog)throws IOException
建立一个ServerSocket，使它绑定到port所指的本机端口，并以backlog参数指定进入的“连接指示”的最大队列长度，默认值为50。当队列已满时，若有“连接指示”（连接的请求），则会拒绝该项连接
ServerSocket(int port，int backlog,InetAddress bindAddr)throws IOException
与前一个构造函数相似，另外多一个bindAddr参数，用来指定此 ServerSocket要绑定的本机IP地址
ServerSocket 类常用的方法：
返回 方法 说明
Socket accept()throws IOException 监听一个到此ServerSocket的连
连线要求，并接受、取得该 Socket。使用此方法的线程会维
持封锁状态，直到确实建立一个
连接为止。
void bind(SocketAddress endpoint) 令此ServerSocket绑定到
throws IOException endpoint指定的SocketAddress
代表的本机IP地址和连接端口
void bind(SocketAddress endpoint, 与前一个方法类似，另外多一个
int backlog) throws IOException backlog参数用来指定进入的“连 接指示”的最大队列长度
void close()throws IOException 关闭此ServerSocket。若现在有 任何线程尚未封锁在此
ServerSocket 的accept()方法
，将会引发 SocketException
ServerSocketChannel getChannel() 返回此ServerSocket所关联而唯
一的ServerSocketChannel对象
，若无则返回null
InetAddress getInetAddress () 返回一个代表此ServerSocket
连接的本机IP的InetAddress
int getLocalPort() 返回此ServerSocket现在监听的
端口编号
SocketAddress getLocalSocketAddress() 返回一个代表此ServerSocket所
绑定的本地端的SocketAddress
物件，若无则返回null
static void setSocketFactory(SocketImplFactory fac) 设定应用程序的ServerSocket
实现生产处
boolean isBound() 判断此ServerSocket是否已绑定
到本地端
boolean isClosed() 判断此ServerSocket是否已关闭
String toString() 返回一个代表此ServerSocket
的字符串，内容包含IP地址与连 接端口
TCP程序范例－－－网络点对点的文件传输 j02150401
TCP的Server端程序的实现步骤：
1.建立serverSocket对象，如：
ServerSocket severTcp=new ServerSocket(2222);
2.监听并接受Client端Socket对它的连接，然后取得Socket，如：
Socket connSocket= severTcp.accept()
3.由 Socket取得从Client端读入数据的 InputStream ，如：
InputStream serveInput=connSocket.getInputStream()
4.利用取得的InputStream 从Client端读入数据，如：
serveInput.read(theData)
5.关闭 InputStream ，如：
serveInput.close()
6.关闭 Socket，如：
connSocket.close()
7.关闭ServerSocket（注：当Server端程序完全不需要再用它接收数据时才关闭），如：
severTcp.close()
TCP的Client端程序的实现步骤：
1.建立Socket对象，并连接到Server主机（Server端必须作了accept()，连接才会成功），如：
Socket tcpSocket=new Socket("192.168.0.22",2222)
或
Socket tcpSocket=new Socket();
...
tcpSocket.connect(new InetSocketAddress("192.168.0.22",2222));
2.取得对Server端作数据输出的 OutputStream ，如：
OutputStream opStream=tcpSocket.getOutStream();
3.利用取得的 OutputStream 送数据到Server端，如：
opStream.write(欲送出的数据)
4.关闭 OutputStream ，如：
opStream.close();
5.关闭Sockeet，如;
tcpSocket.close();
TCP程序范例二－－－扫描特定IP地址可用的连接端口 －－－j02150402
与WEB服务器互动的程序－－－运用URL及URLConnection
URL 类的构造函数：
URL(String spec)throws MalformedURLException
建立一个URL对象，依spec指定代表的URL（统一资源定位器）
URL(String protocol,String host,String File)throws MalformedURLException
建立一个URL对象，以protocol参数指定“协议”部分，以host指定“主机”，file指定目标主机上的文件
URL(String protocol,String host,int port,String File)throws MalformedURLException
建立一个URL对象，以protocol参数指定“协议”部分，以host指定“主机”，port指定连接端口，file指定目标主机上的文件
URL(String protocol,String host,int port,String File,URLStreamHandler handler)throws MalformedURLException
与前一个构造函数相似，多一个handler参数指定此URL使用的URLStreamHandler
URL(URL context,String spec)throws MalformedURLException
依据context参数指定的URL对象，以及spec代表的URI语法：<scheme>://<authority><path>?<query>#<fragment>,建立一个URL对象
URL(URL context,String spec,URLStreamHandler handler )throws MalformedURLException
与前一个构造函数相似，多一个handler参数指定此URL使用的 URLStreamHandler
URL 类常用方法：
返回 方法 说明
URLConnection openConnection()throws IOException 返回一个对此URL所指的远程资源连接
的URLConnection对象
Object getContent()throws IOException 返回此URL的内容，它是一个满足 URLConnection的实例。相当于使用 openConnection().getConnection()
Object setContent(Class[] classes) 返回此URL的内容，并以classes指定
throws IOException 检查返回的对象是否拥有指定的类（ 其中一个Class）的实例，若类型态
与预期都不符，则返回null。相当于
openConnection().getConnection(Class[])
InputStream openSteam()throws IOException 打开一个对此URL的连接，并且返回
一个用来从连接读取数据的
InputStream 对象。相当于
openConnection().getInputStream()
int getDefaultPort() 返回此URL所关联的“协议”的预设“
端口编号”
String getProtocol() 取得此URL的协议名称
String getHost() 取得此URL的主机名称
int getPort() 取得此URL的端口编号，若未设定则
返回-1
String getFile() 取得此URL的文件名称
String getAuthority() 取得此URL中“authority”这部分
String getPath() 取得此URL中“path”这部分
String getQuery() 取得此URL中“query”这部分
String getUserInfo() 取得此URL中“userinfo”这部分
String getRef() 取得此URL中“anchor”这部分
int hashCode() 产生一个适当的int值作为哈希表
索引
boolean equals(Object obj) 比较此URL与obj参数指定的对象，
唯有当obj对象也是一个URL对象，
且两者代表的URL相同时，才会
返回true
boolean sameFile(URL other) 比较两个URL，但“fragment”这部 分不列入考虑
String toExternlForm() 返回一个代表此URL的字符串
URLConnection 类介绍： abstract 类
可利用URL类 openConnection()来产生一个URLConnection对象实例，通过此对象，能够对URL所指的资源作数据的“读”或“写”
URLConnection 类常用方法：
返回 方法 说明
Object getContent()throws IOException 重新取得此URLConnection
Object getContent(Class[] classes) 重新取得此URLConnection，但以
throws IOException classes指定检查返回的对象是否拥有
指定的类（其中一个Class）的实例
InputStream getInputStream()throws IOException 返回一个能由此URLConnection读取数
据的InputStream
OutputStream getOutputStream()throws IOException 返回一个能将数据写到此 URLConnection的OutputStream
abstract void connect()throws IOException 若之前尚未建立连接，就建立一个到此
URL所指的资源的连接
String toString() 返回一个代表此URLConnection的字符 串
URL getURL() 返回此URLConnection的URL字段值
boolean getAllowUserInteraction() 返回此URLConnection对象的
allowUserInteraction字段值，其值若
为true，则表示该URL现在被设定成允
许用户的互动，例如弹出一个确认的
对话框
String getContentEncoding() 返回一个代表“内容编码”的header
filed的字符串
int getContentLength() 返回一个代表“内容长度”的header
filed的int值
String getContentType() 返回一个代表“内容类型”的header
filed的字符串
long getDate() 返回一个代表“日期”的header filed
的long值。
建立URL对象 j02150501 ；利用URL对象直接读取远程数据 j02150502；利用URLConnection对象读取远程资源 j02150503
取得Web服务器的信息：
建立并使用URLConnection的主要步骤：
1.使用URL对象的openConnection()方法，取得代表连接的URLConnection对象。而且根据此URL的protocol的不同，所取得URLConnection实例的类也不同。例如：从一个protocol为http的URL，取得的 URLConnection，是HttpURLConnection类的实例。
2.取得URLConnection的对象后，可操作、或设定此URLConnection的一些“参数”和一般“request 属性”（注：这些参数或属性一般只对HTTP协议有效），借此能影响此 URLConnection对远程资源的连接。参考它的setAllowUserInteraction(),setDoInput(),setDoOutput(),setIfModifiedSince(),
setUserCaches(),setRequestProperty()等方法
3.利用URLConnection对象的connect()方法，对目标的远程资源作实际的连接。连接成功后不可作上一步的那些设定，否则异常。
4.此后，该远程资源就为我们所用
读取Web服务器信息的范例
读取MIME标头信息 j02150504 ；利用 URLConnection下载二进制文件 j02150505；设计与Web服务器互动的程序 j02150506
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/edg_edu/archive/2009/04/07/4051291.aspx