JavaSE基础知识笔记

1 java语言的概述

Ø        Java是一种纯面向对象的语言，与平台无关

1.1 java的两种核心机制

Ø        Java 虚拟机（java virtual Machine）

ü        对于不同的平台有不同的java 虚拟机

ü        Java虚拟机屏蔽了底层运行平台差异，实现了一次编译，随处运       行

Ø       垃圾收集机制（Garbage Collection）有人简称为：GC

Ø        不再使用的内存空间有垃圾收集器收集（但是不一定是实时的）

 

 

2 java语法

2.1变量标示符命名规则

Ø        标识符由字母、下划线“_” 、美元符“$”或数字组成。

Ø         标识符应以字母、下划线 、美元符开头。

Ø         Java 标识符大小写敏感，长度无限制

Ø         不能是 java 关键字

2.2 java数据类型

Ø        基本数据类型

类型	占存储空间	包装类	标示范围	类
byte	1个字节	Byte	-128 ～ 127	整数类
short	2个字节	Short
int	4个字节	Integer
long	8个字节	Long
float	4个字节	Float	-3.403E38～3.403E38	浮点数型
double	8个字节	Double	-1.798E308～1.798E308
boolean	1位	Boolean		逻辑型
char	2个字节	Character		字符型

 

2.3 基本数据类型转换

Ø         自动装换：

ü         byte,char,short->int->long->float->double;

ü         char->int;

ü         byte,char,short 之间不会互相装换

Ø         强制类型转换（需要加强制类型装换符，有数据溢出的危险）

Ø         混合数据计算时数据的转换

ü         系统将所有数据类型都转换成最大数据类型(占字节最多)

ü         所有的整数类型将自动转换成 int 类型再计算

ü         所有的实数类型将自动转换成 double 类型，再计算。

ü         实数类型的常量默认时double类型

2.4 swithc 语句

Ø         swithc 的值只能是int、char、枚举等类型

Ø        小心case穿透，推荐使用break语句

Ø        多个case可以合并到一起

Ø         default可以省略，但不推荐省略

2.5 类

2.5.1 类的定义

Ø         类是具有某种特定特征，行为的集合体

2.5.2 类的组成

Ø         类由方法和属性（成员变量）组成

ü         方法

[修饰符1  修饰符2  …] 返回值类型 方法名(形式参数列表){

Java语句；… … …

}    

ü         属性

²        未初始化时，系统自动初始化

v        byte,short,int型为：0 ；long:     0l

v        char :     \U0000

v        float:       0.0f

v        Double:   0.0d

v        引用类型：null    

2.6内存分析

Ø        heap(堆)       存储 new 出来的对象

Ø         Stack（栈）   存储局部变量

Ø         data segment   存储静态变量、字符串常量

Ø         code segment  存储程序代码

 

2.7方法递归调用（方法调用自身，也可由循环实现）

3 面向对象

3.1面向对象编程语言三大特征

Ø         封装/隐藏

Ø         继承

Ø         多肽

3.2 Java中进行函数调用中传递参数时

Ø         基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。

3.3 构造函数

Ø         构造方法是定义在 Java 类中的一个用来初始化对象的方法

Ø         构造方法与类同名

Ø         可以使用 new + 构造方法 创建一个新的对象。

Ø         构造方法没有返回值

Ø         当没有指定构造方法时，编译器为类自动添加无参的构造方法。（如果有就不添加）

Ø         构造方法可以互相调用：this(参数列表)

Ø         构造方法还可调用父类构造方法：super(参数列表)

3.4 方法的重载，构造方法的重载

Ø         方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。 调用时，会根据不同的参数表选择对应的方法。

Ø         方法调用时，匹配离得最近的类型

Ø         不同的含义：类型，个数，顺序不同

Ø         只有返回值不同不构成方法的重载

Ø         只有形参的名称不同，不构成方法的重载

Ø         与普通方法一样，构造方法也可以重载（有参构造函数、无参构造函数）

 

3.5 this 关键字

Ø         this 关键字相当于类中定义的一个私有属性，他指向类自身

Ø         当必须指出当前使用方法的对象是谁时要使用this。

Ø         有时使用this可以处理方法中成员变量和参数重名的情况。

3.6 static 关键字

Ø         在类中，用static声明的成员变量为静态成员变量

ü         它为该类的公用变量，在类被载入时时被显示初始化

ü         对于该类的所有对象来说，static成员变量只有一份。

Ø         用static声明的方法为静态方法

ü         不需要对象，就可以调用（类名.方法名（静态））

ü         在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。

ü         因此把所有方法都设置成为静态方法，就破坏了面向对象的原则！

Ø         可以通过对象引用或类名（不需要实例化）访问静态成员。

Ø         静态块

ü         静态代码块最先执行，在程序加载到内存中时就执行

3.7 Singleton 设计模式（单例模式）

 

3.8 package 和 import 语句

Ø         解决类的命名冲突问题，Java引入包（package）机制，提供类的多重类命名空间。

Ø         package 语句作为 Java 源文件的第一条语句，指明该文件中定义的类所在的包。（若缺省该语句，则指定为无名包）。

Ø         Java编译器把包对应于文件系统的目录管理，package语句中，用‘ .’ 来指明包(目录)的层次，

Ø         如果将一个类打包，则使用该类时，必须使用该类的全名（例如：com.sxt.MyClass），Java编译器才会在找到该类。

Ø         也可以使用 import 在文件的开头引入要使用到的类；

Ø         可以不需要用import语句直接使用 java.lang 包中的类

3.9 类的继承

Ø         Java 中使用 extends 关键字实现类的继承机制

Ø         通过继承，子类自动拥有了基类（superclass）的所有成员（成员变量和方法）。

Ø         Java只支持单继承，不允许多继承：

Ø         一个子类只能有一个基类   一个基类可以派生出多个子类

 

3.10 访问控制

Ø         Java权限修饰符 public protected private 置于类的成员定义前，用来限定其他对象对该类对象成员的访问权限。

	private	缺省	protected	public
同一类中成员	√	√	√	√
同一包中的子类	×	√	√	√
同一包中非子类	×	√	√	√
不同包中子类	×	×	√	√
不同包中非子类	×	×	×	√
不同包中的外部对象	×	×	×	√
不同包的子类外部对象	×	×	√	√

 

Ø         对于class的权限修饰只可以用 public 和 default。（inner class除外）

Ø         public类可以在任意地方被访问

Ø         default类只可以被同一个包内部的类访问

3.11 方法的重写(OverWrite OverRide)

Ø         在子类中可以根据需要对从基类中继承来的方法进行重写。

Ø         重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。

Ø         重写方法不能使用比被重写方法更严格的访问权限。（由于多态）

Ø         有重写，一定有继承。

3.12 super 关键字

3.13 继承中的构造方法

Ø         子类的构造的过程中必须调用其基类的构造方法。

Ø         子类可以在自己的构造方法中使用super(argument_list)调用基类的构造方法。

ü         使用this(agument list)调用本类另外的构造方法

ü         如果用super,必须写在方法的第一句

Ø         如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。

ü         如果子类构造方法中既没有显式调用基类构造方法，而基类中又没有无参的构造方法，则编译出错。

 

 

3.14 Object类

Ø         Object类是所有Java类的根基类

Ø         如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

Ø         Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。

ü         在进行String与其它类型数据的连接操作时（如：System.out.println(“info”+person）），将自动调用该对象类的 toString()方法

ü         可以根据需要在用户自定义类型中重写toString()方法。

Ø         public boolean equals(Object obj)方法

ü         提供定义对象是否“相等”的逻辑。

ü         Object 的 equals 方法 定义为：x.equals ( y ) 当 x 和 y是同一个对象的应用时返回 true 否则返回 false（相当于 == 操作）

ü         J2SDK提供的一些类，如String，Date等，重写了Object的equals方法，调用这些类的equals方法， x.equals (y) ,当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回 true 否则返回 false。

ü         可以根据需要在用户自定义类型中重写equals方法。

3.15 对象转型（casting）

Ø         一个基类的引用类型变量可以“指向”其子类的对象。

Ø         一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）。

Ø         可以使用 引用 变量 instanceof 类名 来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

Ø         子类的对象可以当作基类的对象来使用称作向上转型（upcasting），反之称为向下转型（downcasting）

3.16 多态

Ø         有多态一定有继承，有重写，有父类引用指向子类对象

Ø         动态绑定是指“在执行期间（而非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

3.17 抽象类

Ø         用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。

Ø         含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。如果重写不了，应该声明自己为抽象。

Ø         抽象类不能被实例化。

Ø         抽象方法只需声明，而不需实现。

3.18 Final关键字

Ø         final的成员变量的值不能够被改变

Ø         final的方法不能够被重写

Ø         final的类不能够被继承

Ø         final, finally, finalize 的区别

ü         final 一般和 static 一起使用（可以用来修饰属性，方法，类）

ü         引用变量加 final ，是指该对象/引用变量的指向关系不能改，但值可以改变

ü         finally 异常处理（一般做一些清楚操作（关闭文件读写，jdbc 连接，sockey 编程））

ü         finalize 来自 Object 类，在垃圾回收时，可能会被调用。

3.19 abstract 关键字

Ø         abstract 修饰方法，表示抽象方法。

Ø         abstract 修饰类，该类为抽象类。

Ø         有抽象方法的类必须声明为抽象类。

Ø         继承抽象类的类，必须实现其父类的抽象方法。

3.20 接口

Ø         接口存在的意义：java中一个类只能有一个父类，所以用接口可以实现多继承的逻辑

Ø         从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

ü         接口中声明的属性默认为 public  static  final 的；也只能是 public static final 的；      static 与 final 位置可以互换

ü         接口中只能定义抽象方法，而且这些方法默认为public的、也只能是public的

Ø         接口（interface）是抽象方法和常量值的定义的集合。

Ø         多个无关的类可以实现同一个接口

Ø         一个类可以实现多个无关的接口

Ø         与继承关系类似，接口与实现类之间存在多态性

Ø         接口可以继承其它的接口，并添加新的属性和抽象方法

Ø         通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。(就像人拥有一项本领)

Ø         一个接口可以继承多个接口，接口可以多继承。而类只能是单继承

Ø         通过接口可以指明多个类需要实现的方法。（描述这项本领的共同接口）

Ø         通过接口可以了解对象的交互界面，而不需了解对象所对应的类。

Ø         使用接口？还是抽象类？

ü         interface同时赋予了接口和抽象类的好处

ü         如果父类可以不带任何函数定义，或任何成员变量，那么优先使用接口。

3.21 内部类

Ø         在类中定义的类，称为内部类。

Ø         内部类可以访问他所在的外部类的所有变量和方法（包括私有的），并能够直接引用他们。

4 异常

4.1Java 异常概念

Ø         Java 异常是Java提供的用于处理程序中错误的一种机制。

Ø         所谓错误是指在程序运行的过程中发生的一些异常事件（如：除0溢出，数组下标越界，所要读取的文件不存在）。

Ø         设计良好的程序应该在异常发生时提供处理这些错误的方法，使得程序不会因为异常的发生而阻断或产生不可预见的结果。

Ø         Java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并将被提交给Java运行时系统，这个过程称为抛出（throw）异常。

Ø         当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获（catch）异常。

 

4.2Java 异常的分类

Ø         所有异常的根为：Throwable

ü         Error:     称为错误，由 Java 虚拟机生成并抛出，包括动态链接失败、虚拟机错误等，程序对其不做处理。

ü         Exception:      所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显式的声明或捕获。

²        Runtime Exception：一类特殊的异常，如被 0 除、数组下标超范围等，其产生比较频繁，处理麻烦，如果显式的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不必对其处理）。

²        其他 Exception 子类

4.3异常的捕获和处理

Ø         try代码段包含可能产生例外的代码。

Ø         try 代码段后跟有一个或多个 catch 代码段。

Ø         每个catch代码段声明其能处理的一种特定类型的异常并提供处理的方法。

Ø         当异常发生时，程序会中止当前的流程，根据获取异常的类型去执行相应的catch代码段。

Ø         finally段的代码无论是否 发生异常都有执行。

4.5关键字

Ø         try   关键字：

ü         try {…}语句指定了一段代码，该段代码就是一次捕获并处理例外的范围。

ü         在执行过程中，该段代码可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对 这些异常做相应的处理。

ü         如果没有例外产生，所有的catch代码段都被略过不执行。

Ø        catch      关键字：

ü        在catch语句块中是对异常进行处理的代码，每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

ü        在catch中声明的异常对象（catch（SomeException e））封装了异常事件发生的信息，在catch语句块中可以使用这个对象的一些方法获取这些信息。

ü        在捕获异常时因先catch 晓得异常，再catch大的异常，最后catch Exception

²       getMessage( )  方法，用来得到有关异常事件的信息。

²       printStackTrace( )方法用来跟踪异常事件发生时执行堆栈的内容。

Ø        finally    关键字：

ü        finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其他部分以前，能够对程序 的状态作统一的管理。

ü        无论try所指定的程序块中是否抛出例外，finally所指定的代码都要被执行。

ü        通常在finally语句中可以进行资源的清除工作，如：

²       关闭打开的文件

²       删除临时文件

Ø        throws   关键字：

ü        声明要抛出的异常

ü        方法中 抛出的异常如果是 RuntimeException 可以不不在方法头声明

ü        方法中 抛出的异常如果是非 RuntimeException 就必须在方法头声明

ü        在方法头必须声明方法中抛出的所有的非 RuntimeException

Ø        throw     关键字：

ü        用在方法体内抛出异常 

4.6 用户自定义异常

Ø         通过继承 java.lang.Exception 类声明自己的异常类。

Ø         在方法适当的位置 生成自定义异常的实例，并用throw 语句抛出。

Ø         在方法的声明部分用throws 语句声明该方法可能抛出的异常。

Ø         在实际应用中一般用户自定义异常继承 java.lang.RuntimeException 因此在方法调用是不用catch

4.7 继承中的异常

Ø         重写方法需要抛出与原方法所抛出异常类型一致异常或者子异常或不抛出异常或者同时抛出RuntimeException。

4.8 异常小总结

Ø         如果有异常，程序会非正常退出

Ø         如果希望程序出现异常后继续执行，必须捕获异常并处理

Ø         可以打印错误的堆栈信息。e.printStackTrace();

Ø         如果一段语句有可能抛多种异常，得写多个catch块

Ø         如果语句过多，可写多个try块

Ø         异常产生后可不做处理，只是简单的抛出

Ø         如果方法内的代码抛出了非RuntimeException的异常，那么方法也得声明抛出异常

Ø         甚至main方法也可以抛出异常

Ø         方法可声明抛出多个异常

Ø         捕获多个异常应该先逮小的再逮大的。否则编译不通过

Ø         自定义异常

Ø         当抛出自定义的异常，那么方法的声明最好不要抛出父类的异常

Ø         finally永远会被执行到. 特殊情况：1,System.exit(0);2,return

Ø         重写方法需要抛出与原方法所抛出异常类型一致异常或者子异常或不抛出异常或者同时抛出RuntimeException。

Ø         可以利用异常处理一些问题。

5 数组

5.1 数组概述

Ø         数组可以看成是多个相同类型数据组合，对这些数据的统一管理。

Ø         数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

Ø         数组中的元素可以是任何数据类型，包括基本类型和引用类型。

5.2一维数组的声明和初始化

Ø         int a1[];  int[] a2;  double b[];     Person[] p1;    String s1[];

Ø         Java语言中声明数组时不能指定其长度(数组中元素的个数)

ü         例如：int a[5]; //非法

Ø         数组初始化时将在（heap）堆内存中开辟一段连续的内存空间

5.3 数组元素的引用

Ø         arrayName[index]

ü         index为数组元素下标，可以是整型常量或整型表达式。如：a[3], b[i], c[6*i]

ü         数组元素下标从0开始；长度为n的数组的合法下标取值范围为（0 ～ n-1 ）

Ø         每个数组都有一个属性length指明它的长度

ü         a.length的值为数组a的长度(元素个数)

5.4 二维数组的声明和使用

5.5 数组常用方

Ø         使用java.lang.System类的静态方法拷贝数组

ü         public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

ü         可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置。如果源数据数目超过目标数组边界会抛出 IndexOutOfBoundsException 异常。

Ø        java.util.Arrays.sort(Object obj) 对数组排序（默认升序）

Ø        java.util.Arrays.toString(Object obj ) 输出数组元素

Ø        java.util.binarySearch(数组, 元素) 搜索指定元素，并返回该元素的位置（要求数组必须是排好序的）

6 常用类

6.1 String 类

Ø         java.lang.String 类代表不可变的字符序列

Ø         "abcd" 为该类的一个对象。

6.1.1     String类的常见构造方法：

Ø         String(String original)   创建一个String对象为original的拷贝。

Ø         String(char[] value)       用一个字符数组创建一个String对象

Ø         String(char[] value,int offset,int count) 用一个字符数组从offset项开始的count个字符序列创建一个String对象

6.1.2     常用方法

Ø        char charAt(int index)       返回索引 index 位置的字符

Ø        equals() 比较两个字符串是否相同 （一般使用 "abc".equals(s) 而不适用 s.equals("abc")）避免报空指针异常

Ø        与 null 比较 用 “==”

Ø        length() 返回字符创的长度

Ø        int indexOf(String str)  返回字符串第一个 str 的索引位置(从前往后检索)

Ø        int lastIndexOf(String str ) 返回从后往前检索第一个 str 出现的位置

Ø        boolean startsWith(String str ) 判断是否是以字符串 str 开始

Ø        boolean endsWith(String str) 判断是否是以字符串 str 结束

Ø        String[] split(String flag) 根据 flag 分割成数组

Ø        String replase(String str,String str2) 替换字符串

Ø        String replaseAll(String str,String str2) 替换所有字符串

Ø        String substring(int i,int j) 截取字符串(从 i 到 j ，但不包括 j)

Ø        String substring(int i) 截取字符串(从 i 到最后 ，但不包括 i)

Ø        trim() 去除前后空格

Ø        public String toUpperCase()    返回一个字符串为该字符串的大写形式

Ø        public String toLowerCase()    返回一个字符串为该字符串的小写形式

Ø        public static String valueOf(…)可以将基本类型数据转换为字符串；

6.2 StringBuffer 类（带缓冲的字符串）

Ø         java.lang.StringBuffer 代表可变的字符序列

Ø         StringBuffer和String类似，但StringBuffer可以对其字符串进行改变

6.2.1 StringBuffer类的常见构造方法

Ø         StringBuffer() 创建一个不包含字符序列的“空”的StringBuffer对象。

Ø         StringBuffer(String str) 创建一个StringBuffer对象，包含与String对象str相同的字符序列。

6.2.2 StringBuffer常用方法

Ø        重载方法 public StringBuffer append(…) 可以为该StringBuffer 对象添加字符序列，返回添加后的该StringBuffer对象引用

ü        public StringBuffer append(String str)

ü        public StringBuffer append(StringBuffer sbuf)

ü        public StringBuffer append(char[] str)

ü        public StringBuffer append(char[] str,int offset,int len)

ü        public StringBuffer append(double d)

ü        public StringBuffer append(Object obj)

Ø        重载方法 public StringBuffer insert(…)可以为该StringBuffer 对象在指定位置插入字符序列，返回修改后的该StringBuffer对象引用，例如：

ü        public StringBuffer insert(int offset,String str)

ü        public StringBuffer insert(int offset,double d)

Ø        方法 public StringBuffer delete(int start,int end) 可以删除从start开始到end-1为止的一段字符序列，返回修改后的该StringBuffer对象引用。

Ø        和 String 类含义类似的方法：

ü        public int indexOf(String str)

ü        public int indexOf(String str,int fromIndex)

ü        public String substring(int start)

ü        public String substring(int start,int end)

ü        public int length()

Ø        方法 public StringBuffer reverse()用于将字符序列逆序，返回修改后的该StringBuffer对象引用。

6.3 StringBuilder

Ø         与StringBuffer 用法一样

Ø         区别：StringBuilder 是线程安全的

6.3 Math类

6.3.1 java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

Ø        abs 绝对值

Ø        acos,asin,atan,cos,sin,tan

Ø        sqrt 平方根

Ø        pow(double a, double b) a的b次幂

Ø        log 自然对数

Ø        exp e为底指数

Ø        max(double a, double b)

Ø        min(double a, double b)

Ø        random() 返回 0.0 到 1.0 的随机数

Ø        long round(double a) double型的数据a转换为long型（四舍五入）

Ø        toDegrees(double angrad) 弧度->角度

Ø         toRadians(double angdeg) 角度->弧度

6.4 File 类

Ø         java.io.File类代表系统文件名（路径或文件名）。

Ø         File类的常见构造方法：

Ø         public File(String pathname) 以pathname为路径创建File对象，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。

Ø         File的静态属性String separator存储了当前系统的路径分隔符。

6.4.1 常用方法

Ø         通过File对象可以访问文件的属性。

ü         public boolean canRead()      //是否可读

ü         public boolean canWrite()     //是否可写

ü         public boolean exists()         //是否存在

ü         public boolean isDirectory()  //测试此抽象路径名表示的文件或目录是否存在。

ü         public boolean isFile()          //是否是文件

ü         public boolean isHidden()     //是否是影藏属性

ü         public long lastModified()     //最后修改时间

ü         public long length()                     //文件大小

ü         public String getName()       //文件或目录名

ü         public String getPath()          //文件路径

Ø         通过File对象创建空文件或目录（在该对象所指的文件或目录不存在的情况下）。

ü         public boolean createNewFile()throws IOException

ü         public boolean delete()   //删除此抽象路径名表示的文件或目录

    public boolean mkdir()  //创建此抽象路径名指定的目录

7 java.lang.Enum枚举类型

Ø         只能够取特定值中的一个

Ø         使用enum关键字

Ø         是java.lang.Enum类型

8 容器/集合

8.1 Collection接口

Ø        Collection 接口中所定义的方法

ü        int size();             //集合的大小

ü        boolean isEmpty();            //判断集合是否为空

ü        void clear();         //清空集合

ü        boolean contains(Object element);  //是否包含该元素

ü        boolean add(Object element);         //添加元素

ü        boolean add(Collection c);       //将集合C作为一个元素添加到此集合中

ü        boolean remove(Object element);          //删除元素

ü        Iterator iterator();              //迭代

ü        boolean containsAll(Collection c);         //如果此 collection 包含指定 collection 中的所有元素，则返回 true。

ü        boolean addAll(Collection c);         //将指定 collection 中的所有元素都添加到此 collection 中

ü        boolean removeAll(Collection c);

ü        boolean retainAll(Collection c);   //求交集

ü         Object[] toArray();        //将集合转换成数组

8.1.1List接口

Ø         List接口是Collection的子接口，实现List接口的容器类中的元素是有顺序的，而且可以重复。

Ø         List 容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

Ø         J2SDK 所提供的 List 容器类有 ArrayList，LinkedList 等。

8.1.2     Set接口

Ø         Set 接口是Collection的子接口，Set接口没有提供额外的方法，但实现 Set 接口的容器类中的元素是没有有顺序的，而且不可以重复。

Ø          

Ø         Set 容器可以与数学中“集合”的概念相对应。

Ø         J2SDK API中 所提供的 Set 容器类有 HashSet，TreeSet 等

8.3 Map接口

Ø         Map 接口定义了存储“键（key）－ 值（value）映射对”的方法

Ø         实现Map接口的类用来存储键－值 对。

Ø         Map 接口的实现类有HashMap和TreeMap等。

Ø         Map类中存储的键－值对通过键来标识，所以键值不能重复。

8.3.1常用方法

Ø        Object put(Object key, Object value);   //添加

Ø        Object get(Object key);           //去元素

Ø        Object remove(Object key);     //删除元素

Ø        boolean containsKey(Object key);         //是否包含“键”

Ø        boolean containsValue(Object value);           //是否包含“value”

Ø        int size();             //求元素的个数

Ø        boolean isEmpty();            //判断是否为空

Ø        void putAll(Map t);   //从指定映射中将所有映射关系复制到此映射中（可选操作）。

Ø         void clear();         //清空

Ø         Set<Object> keySet();      //取出所有的键

Ø         Collection<V>    values(); //返回此映射中包含的值的 Collection 视图。

Ø         int hashCode();   返回此映射的哈希码值。

ü         一个对象被当作Map里面的key的时候,hashCode用来比较两个对象是不是相等

ü         hashCode非常适合用来做索引

ü         hashCode 的常规协定

ü         重写equals方法,通常需要重写hashCode方法.因为你的本意是想让他相等的.但hashCode如果不重写,不同的对象就不会相等

ü         Hashcode被谁调用了?什么时候调用的？

8.3.2 HashMap

8.3.3 HashTable

8.4 Iterator 接口

Ø         所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。

Ø         Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。

Ø         Iterator接口定义了如下方法：

Ø         Enumeration ArrayList - Vector

8.4.1 方法

Ø         boolean hasNext();  //如果仍有元素可以迭代，则返回 true

Ø         Object next();      //返回游标右边的元素并将游标移动到下一个位置

Ø         void remove();      //从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

8.5 java.util.Collections

8.5.1 常用的静态方法

Ø         void sort(List)  对List容器内的元素排序

Ø         void shuffle(List) 对List容器内的对象进行随机排列

Ø         void reverse(List) 对List容器内的对象进行逆续排列

Ø         void fill(List, Object)  用一个特定的对象重写整个List容器

Ø         void copy(List dest,List src) 将src List容器内容拷贝到dest List容器

Ø         int binarySearch(List, Object)       对于顺序的List容器，采用折半查找的方法查找特定对象

8.6 jdk1.5性特性

8.6.1 for in 循环（foreach循环）

Ø         补充：JDK1.5增强的for循环（foreach循环）

增强的for循环对于遍历array 或 Collection的时候相当简便

Ø         缺陷：

ü         数组：不能方便的访问下标值

ü         集合：与使用Iterator相比，不能方便的删除集合中的内容

Ø         总结：

ü         除了简单遍历并读出其中的内容外，不建议使用增强for

8.6.2 泛型

Ø         起因：JDK1.4以前类型不明确：

ü         装入集合的类型都被当作Object对待，从而失去自己的实际类型。

ü         从集合中取出时往往需要转型，效率低，容易产生错误。

Ø         解决办法：

Ø         在定义集合的时候同时定义集合中对象的类型

ü         示例：BasicGeneric.java

²        可以在定义Collection的时候指定

²        也可以在循环时用Iterator指定

Ø         好处：增强程序的可读性和稳定性

8.7 Comparable

Ø         所有可以“排序”的类都实现了java.lang.Comparable 接口，Comparable接口中只有一个方法 public int compareTo(Object obj)；该方法:

Ø         返回值：

ü         大于0表示该对象大于要比较的对象

ü         等于0表示该对象等于要比较的对象

ü         小于0标示该对象小于要比较的对象

9 IO流

Ø          java.io 包中定义了多个流类型(类或抽象类)来实

Ø          现输入/输出功能；可以从不同的角度对其进行分类：

ü          按数据流的方向不同可以分为输入流和输出流。(以程序的角度来考虑)

ü          按处理数据单位不同可以分为字节流和字符流。

ü          按照功能不同可以分为节点流和处理流。

9.1  输入输出流的分类

类型	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

9.1.1 InputStream

9.1.1.1 InputStream的基本方法

Ø        int read() throws IOException        读取一个字节并以整数的形式返回(0~255),如果返回-1已到输入流的末尾。

Ø        int read(byte[] buffer) throws IOException读取一系列字节并存储到一个数组buffer，返回实际读取的字节数，如果读取前已到输入流的末尾返回-1

Ø        int read(byte[] buffer, int off, int len)throws IOException读取length个字节并存储到一个字节数组buffer，从off位置开始存,最多len返回实际读取的字节数，如果读取前以到输入流的末尾返回-1

Ø         void close() throws IOException关闭流释放内存资源

9.1.2 OutputStream

9.1.2.1 OutputStream的基本方法

Ø        void write(int b) throws IOException 向输出流中写入一个字节数据,该字节数据为参数b的低8位

Ø        void write(byte[] b) throws IOException     将一个字节类型的数组中的数据写入输出流

Ø        void write(byte[] b, int off, int len) throws IOException  将一个字节类型的数组中的从指定位置（off）开始的len个字节写入到输出流

Ø        void close() throws IOException   关闭流释放内存资源

Ø         void flush() throws IOException    将输出流中缓冲的数据全部写出到目的地

9.1.3 Reader

9.1.3.1 Reader 的基本方法

Ø        int read() throws IOException        读取一个字符并以整数的形式返回(0~255),如果返回-1已到输入流的末尾。

Ø        int read(char[] cbuf) throws IOException读取一系列字符并存储到一个数组buffer，返回实际读取的字符数，如果读取前已到输入流的末尾返回-1

Ø        int read(char[] cbuf, int off, int len)throws IOException  读取length个字符并存储到一个数组buffer，从off位置开始存,最多读取len返回实际读取的字符数，如果读取前以到输入流的末尾返回-1

Ø         void close() throws IOException关闭流释放内存资源

9.1.4 Writer

9.1.4.1 Writer 的基本方法

Ø        void write(int c) throws IOException 向输出流中写入一个字符数据,该字节数据为参数b的低16位

Ø        void write(char[] cbuf) throws IOException 将一个字符类型的数组中的数据写入输出流，

Ø        void write(char[] cbuf, int offset, int length) throws IOException将一个字符类型的数组中的从指定位置（offset）开始的length个字符写入到输出流

Ø        void write(String string) throws IOException将一个字符串中的字符写入到输出流

Ø        void write(String string, int offset, int length) throws IOException 将一个字符串从offset开始的length个字符写入到输出流

Ø        void close() throws IOException 关闭流释放内存资源

Ø         void flush() throws IOException 将输出流中缓冲的数据全部写出到目的地

9.2 节点流的分类

9.2.1 FileInputStream

Ø        继承自InputStream 用于向文件中输入字节。

Ø         FileInputSteam 支持其父类InputStream所提供的数据读取方法。

9.2.1.1常用构造方法

Ø        FileInputStream(String name) throws FileNotFoundException

Ø        FileInputStream(File file)   throws FileNotFoundException

9.2.2 OutputStream

Ø        继承自OutputStream用于向文件中输入输出字节。

Ø         FileOutputStream 类支持其父类OutputStream 所提供的数据写入方法。

9.2.2.1 常用构造方法

Ø        FileOutputStream(String name)throws FileNotFoundException

Ø        FileOutputStream(File file)  throws FileNotFoundException

Ø         FileOutputStream(File file, boolean append)  throws FileNotFoundException

9.3 访问文件

9.4 处理流类型

9.5 缓冲流

Ø        缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。

Ø        J2SDK提供了四种缓存流，其常用的构造方法为：

ü        BufferedReader(Reader in)

ü        BufferedReader(Reader in,int sz) //sz 为自定义缓存区的大小

ü        BufferedWriter(Writer out)

ü        BufferedWriter(Writer out,int sz)

ü        BufferedInputStream(InputStream in)

ü        BufferedInputStream(InputStream in,int size)

ü        BufferedOutputStream(OutputStream out)

ü        BufferedOutputStream(OutputStream out,int size)

Ø        BufferedReader提供了readLine方法用于读取一行字符串（以\r或\n分隔）。

Ø        BufferedWriter提供了newLine用于写入一个行分隔符。

Ø         对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush方法将会使内存中的数    据立刻写出。

9.6 转换流

Ø        InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换。

Ø        InputStreamReader 需要和 InputStream “套接” 。

Ø        OutpStreamWriter 需要和 OutputStream “套接” 。

Ø        转换流在构造时可以指定其编码集合，例如：

ü         InputStream isr = new InputStreamReader  (System.in, “ISO8859_1”)

9.7 数据流

ü        DataInputStream 和 DataOutputStream 分别继承自InputSteam 和 OutputStream，它属于处理流，需要分别“套接”在InputStream 和OutputStream类型的节点流上。

ü        DataInputStream和DataOutputStream提供了可以存取与机器无关的Java原始类型数据（如：int，double 等）的方法。

ü        DataInputStream和DataOutputStream的构造方法为：

ü        DataInputStream ( InputStream in )

ü         DataOutputStream ( OutputStream out

9.8 Print 流

Ø        PrintWriter和PrintStream 都属于输出流，分别针对与字符和字节。

Ø        PrintWriter和PrintStream提供了重载的print

Ø        Println方法用于多种数据类型的输出。

Ø        PrintWriter和PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息。

Ø        PrintWriter和PrintStream有自动flush功能。

Ø        PrintWriter(Writer out)

Ø        PrintWriter(Writer out,boolean autoFlush)

Ø        PrintWriter(OutputStream out)

Ø        PrintWriter(OutputStream out,boolean autoFlush)

Ø        PrintStream(OutputStream out)

Ø         PrintStream(OutputStream out,booleanautoFlush)

9.9 Object 对象流

Ø        直接将Object写入或读出

Ø         写对象的时候要求背斜对象必须实现 Serializable 接口

Ø        transient关键字

Ø        serializable接口

Ø        Externalizable 接口

ü        void writeExternal(ObjectOutput out) throws IOException

ü         void readExternal(ObjectInput in) throws IOException, ClassNotFoundException

9.10 小结

Ø        InputStream/OutputStream //最基础的抽象类，字节流

Ø        Reader/Writer  //最基础的抽象类 ，字符流

Ø        FileInputStream / FileOutputStream //File打头的用来操作文件，字节流

Ø        FileReader / FileWriter //File打头的用来操作文件，字符流

Ø        BufferedInputStream / BufferedOutputStream //带缓冲的，字节流

Ø        BufferedReader / BufferedWriter //带缓冲的，字符流

Ø        ByteArrayInputStream / ByteArrayOutputStream  //读写内存中的字符数组

Ø        InputStreamReader / OutputStreamWriter //字节转字符，转化流

Ø        DataInputStream / DataOutputStream //读写基本数据类型

Ø        PrintStream / PrintWriter //都是输出流，不抛出异常，自动flush

Ø        ObjectInputStream / ObjectOutputStream //读写Object

ü        Serializable接口标记性接口

ü        Externalizable 自己控制序列化

ü        Transient

10 多线程

10.1 线程的基本概念

Ø        线程是一个程序内部的顺序控制流。

Ø        线程和进程的区别

ü        进程：操作系统分配内存和 CPU 的最小单位。由一个或多个线程组成。

ü        每个进程都有独立的代码和数据空间(进程上下文)，进程间的切换会有           较大的开销。

ü        线程：进程的组成单位。

ü        1.主线程结束，子线程不一定结束，因此进程不一定结束。

ü        2.主线程结束，所有子线程结束，进程就结束了，但守护线程不一定结          束。

ü        3.进程不会等待守护线程结束才结束。守护线程结束，进程不一定结束。

ü        线程可以看成时轻量级的进程，同一类线程共享代码和数据空间，每个         线程有独立的运行栈和程序计数器(PC)，线程切换的开销小。

ü        多进程: 在操作系统中能同时运行多个任务(程序)

ü         多线程: 在同一应用程序中有多个顺序流同时执行

²       1.用于游戏开发。

²        2.用于复杂的计算。

12.1.1 主线程

Ø        在Java程序启动时，一个线程立刻运行，该线程通常称为程序的主线程。

Ø        主线程的重要性体现在两个方面：

Ø        它是产生其他子线程的线程。

Ø         通常它必须最后完成执行，因为它执行各种关闭动作。

10.2 线程的创建和启动

10.2.1实现Runnable接口创建线程

Ø        定义线程类实现Runnable接口

Ø        Thread myThread ＝ new Thead（target）//target为Runnable接口类型。

Ø        Runnable中只有一个方法：

Ø        public void run（）; 用以定义线程运行体。

Ø        使用Runnable接口可以为多个线程提供共享的数据。

Ø        在实现Runnable接口的类的run方法定义中可以使用Thread的静态方法：

Ø        public static Thread currentThread()  获取当前线程的引用。

10.2.2 继承Thread类创建线程

Ø         可以定义一个Thread的子类并重写其run方法如：

                   

10.3 线程的调度和优先级

Ø         Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级决定应调度哪个线程来执行。

Ø         线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级是5。

ü         Thread.MIN_PRIORITY = 1

ü         Thread.MAX_PRIORITY = 10

ü         Thread.NORM_PRIORITY = 5

Ø          使用下述线方法获得或设置线程对象的优先级。

ü         int getPriority();

ü         void setPriority(int newPriority);

Ø         不同平台上的优先级

ü         Solaris：相同优先级的线程不能相互抢占对方的cpu时间。

ü         windows：可以抢占相同甚至更高优先级的线程的cpu时间

 

10.4 线程的状态控制

Ø        新建 (Born) : 新建的线程处于新建状态

Ø        就绪 (Ready) : 在创建线程后，它将处于就绪状态，等待 start() 方法被调用

Ø        运行 (Running) : 线程在开始执行时进入运行状态

Ø         睡眠 (Sleeping) : 线程的执行可通过使用 sleep() 方法来暂时中止。在睡眠后，线程将进入就绪状态

Ø        等待 (Waiting) : 如果调用了 wait() 方法，线程将处于等待状态。用于在两个或多个线程并发运行时。

Ø        挂起 (Suspended) : 在临时停止或中断线程的执行时，线程就处于挂起状态。

Ø         恢复 (Resume) : 在挂起的线程被恢复执行时，可以说它已被恢复。

Ø        阻塞 (Blocked) – 在线程等待一个事件时（例如输入/输出操作），就称其处于阻塞状态。

Ø         死亡 (Dead) – 在 run() 方法已完成执行或其 stop() 方法被调用之后，线程就处于死亡状态。

Ø        sleep方法（县城睡眠）Thread的静态方法：

ü        public static void sleep(long millis) throws InterruptedException  使得当前线程休眠（暂时停止执行millis毫秒）。由于是静态方法，sleep可以由类名直接调用：Thread.sleep(…)

Ø        join方法 合并某个线程

Ø        yield方法 让出CPU，给其他线程执行的机会

10.5 线程同步(synchronized)

Ø        在Java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性。每个对象都对应于一个可称为“互斥锁”的标记，这个标记保证在任一时刻，只能有一个线程访问该对象。

Ø         关键字synchronized 来与对象的互斥锁联系。当某个对象synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。

Ø        synchronized 还可以放在方法声明中，表示整个方法为同步方法，例如：

synchronized public void add(String name){…}

Ø         同步块 ： synchronized(参数){}

10.6 等待唤醒机制

Ø        sleep()在等待是，必须指定等待时间，并且不会释放当前线程的锁。可以再任何方法调用来自 Thread 类

Ø        wait();可以给定时间，可以不指定时间，在等待时，会释放占有当前线程锁。必须在同步方法内调用 来自于 object 类

Ø        notify();唤醒一个线程

Ø        notifyAll();唤醒所有线程

Ø         Wait sleep区别

n        来源不同

ü        Sleep是Thread提供的方法

ü         Wait继承自Object

位置不同：

Wait需要写在Synchronize语句块里面

是否释放锁定对象

调用wait方法，释放锁定该对象

Sleep时别的线程也不可以访问锁定对象

10.7 基于线程的多任务处理的优点

Ø        基于线程所需的开销更少

ü        在多任务中，各个进程需要分配它们自己独立的地址空间

ü        多个线程可共享相同的地址空间并且共同分享同一个进程

Ø        进程间调用涉及的开销比线程间通信多

Ø        线程间的切换成本比进程间切换成本低

Ø        在Java中，一个应用程序可以包含多个线程。每个线程执行特定的任务，并可与其他线程并发执行

Ø        多线程使系统的空转时间最少，提高CPU利用率

Ø         多线程编程环境用方便的模型隐藏CPU在任务间切换的事实

11网络编程(TCP/IP、Socket编程、C/S)（非重点）

Ø        什么是计算机网络:

ü        把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息，共享硬件、软件、数据信息等资源。

Ø        计算机网络的主要功能

ü        资源共享

ü        信息传输与集中处理

ü        均衡负荷与分布处理

ü         综合信息服务 (www/综合业务数字网络 ISDN)

Ø        什么是网络通信协议

ü        计算机网络中实现通信必须有一些约定即通信协议，对速率、传输代码、代码结构、传 输控制步骤、出错控制等制定标准。

 

Ø        网络通信接口

ü        为了使两个结点之间能进行对话，必须在它们之间建立通信工具(即接口)，使彼此之间 能进行信息交换。

接口包括两部分：

²       硬件装置: 实现结点之间的信息传送

²        软件装置: 规定双方进行通信的约定协议

11.1通信协议的分层思想

11.2TCP协议和UDP协议

Ø        TCP协议是一个面向连接的、可靠的协议

ü        TCP(transmission control protocol)

ü        是专门设计用于在不可靠的因特网上提供可靠的、端到端的字节流通信的协议。它是一种面向连接的协议。TCP连接是字节流而非报文流。

ü        点对点协议

ü        服务器/客户端

ü        准确(慢 IP+端口号)

 

Ø        UDP协议是一个不可靠的、无连接协议

ü        UDP(user datagram protocol )

ü        UDP向应用程序提供了一种发送封装的原始IP数据报的方法、并且发送时无需建立连接。是一种不可靠的连接

ü        不一定是点对点，可以广播。

ü        没有服（务器/客户端概念）无需建立连接

ü        不一定准确，甚至连接收数据顺序都不保证，但是速度快。

ü        一般用于音频，视频

11.3socket

Ø        两个Java应用程序可通过一个双向的网络通信连接实现数据交换，这个双向链路的一端称为一个Socket。

Ø        Socket通常用来实现client-server连接。

Ø        java.net包中定义的两个类Socket和ServerSocket，分别用来实现双向连接的client和server端

Ø        建立连接时所需的寻址信息为远程计算机的IP地址和端口号

 

Socket通信模式

12GUI

Ø        AWT    (抽象窗口工具集 ) AbstractWindow Toolkit

ü        为简单的applet程序设计

ü        AWT没有提供足够的桌面端的程序所需的特性

ü        它不适宜用来构建丰富的桌面图形界面

Ø        Swing

ü        Swing是AWT的扩展和功能加强

ü        是构建java图形界面标准的API

Ø        SWT    (Standard Widget Toolkit)

ü        是一个开源的GUI编程框架

ü         SWT是IBM为它的Eclipse集成开发环境而开发的图形用户界面工具

12.1AWT

Ø        AWT(Abstract Window Toolkit)包括了很多类和接口，用于Java Application 的GUI（Graphics User Interface 图形用户界面）编程。

Ø        GUI的各种元素（如：窗口，按钮，文本框等）由Java 类来实现。

Ø        使用AWT所涉及的类一般在java.awt包及其子包中。

Ø         Container和Component是AWT中的两个核心类。Modal Modeless

 

12.2Component & Container

Ø        Java的图形用户界面的最基本组成部分是Component ，Component 类及其子类的对象用来描述以图形化的方式显示在屏幕上并能与用户进行交互的GUI元素，例如，一个按钮，一个标签等。

Ø        一般的Component对象不能独立地显示出来，必须将“放在”某一的Container对象中才可以显示出来。

Ø        Container是Component子类，Container子类对象可以“容纳”别的Component对象。

Ø        Container对象可使用方法add(..)向其中添加其他Component对象。

Ø        Containter是Component的子类，因此Containter对象也可以被当作Component对象添加到其他Container对象中。

Ø        有两种常用的Containter：

ü        Window: 其对象表示自由停泊的顶级窗口

ü         Panel: 其对象可作为容纳其它Component对象，但不能独立存在，必须被添加到其它Containner中(如Window 或 Applet)

12.3Frame

Ø        Frame是Window的子类，由Frame或其子类创建的对象为一个窗体。

Ø        Frame的常用构造方法：

ü        Frame()

ü        Frame(String s) 创建标题栏为字符串s的窗口。

12.4 Panel

Ø        Panel对象可以看成可以容纳Component的空间

Ø        Panel对象可以拥有自己的布局管理器

Ø        Panel类拥有从其父类继承来的 

ü        setBounds(int x,int y,int width,int height)

ü        setSize(int width,int height)

ü        setLocation(int x,int y)

ü        setBackground(Color c)

ü        setLayout(LayoutManager mgr) 等方法。

Ø        Panel的构造方法为：

ü        Panel() 使用默认的 FlowLayout类布局管理器初始化。

ü        Panel(LayoutManager layout)使用指定的布局管理器初始化。

12.5布局管理器

Ø        Awt提供了5种布局管理器类：

ü        FlowLayout（流式布局）默认布局（居中）

ü        BorderLayout（东（EAST）、南（SOUTH）、西（WEST）、北（NORTH）、中（CENTER））Frame类的默认布局管理器

²       如不指定组件的加入部位，则默认加入到CENTER区。

²       每个区域只能加入一个组件，如加入多个，则先前加入的会被覆盖

ü        GridLayou（网格布局）

²       GridLayout型布局管理器将空间划分成规则的矩形网格，每个单元格区域大小相等。 组件被添加到每个单元格中，先从左到右添满一行后换行，再从上到下。

ü        CardLayout

ü         GridBagLayout

12.5.1小结布局管理器

Ø        Frame是一个顶级窗口，Frame的缺省布局管理器为BorderLayout

Ø        Panel无法单独显示，必须添加到某个容器中。

Ø        Panel的缺省布局管理器为FlowLayout。

Ø        当把Panel作为一个组件添加到某个容器中后，该Panel仍然可以有自己的布局管理器。

Ø        使用布局管理器时，布局管理器负责各个组件的大小和位置，因此用户无法在这种情况下设置组件大小和位置属性，如果试图使用Java语言提供的setLocation()，setSize()，setBounds()等方法，则都会被布局管理器覆盖。

Ø        如果用户确实需要亲自设置组件大小或位置，则应取消该容器的布局管理器，方法为：

Ø         setLayout(null)

12.6时间监听

12.6.1TextField 类

常用方法

12.6.2TextField事件监听

Ø        TextField 对象可能发生Action（光标在文本框内敲回车）事件。与该事件对应的事件类是java.awt.event.ActionEvent。

Ø        用来处理 ActionEvent事件是实现了java.awt.event. ActionListener 接口的类的对象。ActionListener接口定义有方法：

Ø        public void actionPerformed(ActionEvent e)

Ø        实现该接口的类要在该方法中添加处理该事件（Action）的语句。

Ø         使用 addActionListener(ActionListener l)方法为TextField 对象注册一个ActionListener对象，当TextField对象发生Action事件时，会生成一个ActionEvent对象，该对象作为参数传递给ActionListener对象的

Ø         actionPerformer方法在方法中可以获取该对象的信息，并做相应的处理。

12.7内部类

Ø        在Java中，允许一个类定义在另一个类的内部，前者称为内部类

Ø        内部类的名字不能与包含它的类名相同；

Ø        内部类可以访问包含它的类的所有成员；

Ø        内部类和外层封装它的类之间存在逻辑上的所属关系

Ø        内部类可以定义在方法内可以定义在任何范畴怎样和外部类对象取得联系

Ø        静态内部类（如果内部类对象不需要和外部类对象产生联系）

ü        非静态内部类中的成员不能声明为静态的，只有在顶层类或静态的内部类中才可声明静态成员；

Ø        嵌套内部类24_nested.java

Ø        内部类可以是抽象类 ，因此可以被其它的内部类继承。也可以是final的。

Ø        和外层类不同，内部类可以声明为private或protected；

12.7.1内部类总结

Ø        好处:

ü        可以方便的访问包装类成员

ü        可以更清楚的组织逻辑，防止不应该被其它类访问的类进行访问

Ø        何时使用

ü        该类不允许或者不需要其它类进行访问时候

12.8 Graphics 类

Ø        每个Component都有一个paint(Graphics g)用于实现绘图目的，每次重画该Component时都自动调用paint方法。

Ø        Graphics类中提供了许多绘图方法，如：

ü        drawRect(int x,int y,int width,int height)

ü        fillRoundRect(int x,int y,int width,int height,int arcWidth,int arcHeight)等

12.9 Window 事件

Ø         Window事件所对应的事件类为WindowEvent ，所对应的事件监听接口为WindowListener 。

Ø         WindowListener定义的方法有：

ü         public void windowOpened(WindowEvent e)

ü         public void windowClosing(WindowEvent e)

ü         public void windowClosed(WindowEvent e)

ü         public void windowIconified(WindowEvent e)

ü         public void windowDeiconified(WindowEvent e)

ü         public void windowActivated(WindowEvent e)

ü         public void windowDeactivated(WindowEvent e)

 

Ø         与WindowListener对应的适配器为

ü         WindowAdapter。