1.  如何设置Java开发环境(Win2000)
答：Start-Control panel-System-Advance-Environment Variables
    设置环境变量：
    PATH = %PATH%;c:\j2sdk1.4.2_05\bin;
    CLASSPATH = .;

    注：javac编辑器总是在当前查找文件，而java解释器只有在类路径中包含“.” 目录的情况下才会查找当前目录。如果类路径没有设置，并不会产生什么问题--黙认类路径中包含“.”目录。但，如果设置了类路径，却没有包含“.”话，就会产生问题--程序编译时不会出错，但却无法运行。

2.  什么是Java?
答：1) 编程语言(先编译再解释)；
    2) 开发环境；
    3) 运行环境；
    4) 部署环境；

3.  Java的特点
答：1) 简单(Java语法是C++语法的一个“纯净”版本)；
    2) 可移植性
    3) 面向对象
    4) 分布式(Java把打开套接字连接等繁琐的网络任务变得非常容易)
    5) 健壮性(Java编译器会检查出很多其他语言在运行时刻才显示出来的错误；Java采用的指针模型可以消除重写内存和数据崩溃的可能)
    7) 多线程(多线程编程的简单性是Java成为流行的服务器端开发语言的主要原因之一)
    8) 安全(用Java可以构建防病毒和防篡改的系统)
    9) 动态(Java可随意增加新的方法以及实例变量，而客户端却不需做任何的更改)
    10)体系结构中立(字节码与计算机体系结构无关，只要存在运行时系统，可在多种处理器上执行)

4. Java中基本概念
答：1) 源文件
       在最顶层只包括一个public类型的类/接口，文件名与类/接口名同并以.java作为文件后缀。
    2) 包(package ,在源文件中this idertify只能放在第一行，且最多只能是一行)
       一个将类和接口组织在一块的实体，在文件系统中以目录/文件夹型式呈现。

事实上今天所学知识远比上面列出的要多，更多的知识点通过练习提前和我们见面了，像如何自行创建类、创建类的属性和方法、控制打印输出的格式(通过消息对话框输出结果)、以及局部变量、实例变量、全局变量(类变量、静态变量)间的区别。以上知识点在以后的学习中会逐渐接触到，是故不详细介绍。另外，今天的学习内容是自己以前花了几倍的时间才摸索清楚的。有人手把手引着，真好！

教Java的老师有二位，一位传授知识、一位辅导练习。授课的薛老师讲课不温不火、胸有成竹。看到他，仿佛看到Java的高度。辅导的薛老师有问必答、拉近了我们与Java的距离。

2004-8-13    星期五   阴

1. 注释的三种形式
答： //  单行注释
     /*  一或多行注释 */
     /** 文档注释     */

2. Java代码中的“；”、“{}”、“ ”
答：Java语句以分号分隔；
    Java代码块包含在大括号内；
    忽略空格。

3. 标识符
答：1) 用以命名类、方法和变量、以及包；
    2) 以字符、“_”或“$”开头；
    3) 无长度限制。

4. 数据类型
答：1) 整型
       byte       8位       -128到127
       short      16位      -2^15到2^15-1
       int        32位      -2^31到2^31-1
       long       64位      -2^63到2^63-1
    2) 浮点类型
       float      32位     
       double     64位
    3) 字符类型
       char       16位
    4) 布尔型
       boolean    false/true

    注：1) char是无符号的16位整数,字面值必须用单引号括起来；
        2) String 是类，非原始数据类型；
        3) 长整型数字有一个后缀为“L”或“l”，八进制前缀为“0”，十六进制前缀为“0x”；
        4) 黙认浮点类型为double；
        5) float数据类型有一个后缀为“f”或“F”,Double数据类型后可跟后缀“D”或“d”;

5. identifiers Naming Rules
答：1) 类/接口名首字母大写；
    2) 方法、变量名第一个字母小写，其余首字母大写；
    3) 常量名称全部大写；
    4) 包名全部小写。

6. 理解对象
答：在OOP中，程序由对象组成，这些对象具有某种属性以及对象可执行的某些操作(方法)。OOP高效的关键在于它让每个对象负责执行一组相关的任务。

2004-8-16    星期一   阴

表达式和控制流程

1. 变量和作用域

答：1) 局部变量
       定义在方法内部，其作用域为该方法，也称为临时变量、栈变量。
    2) 实例变量
       定义在类内部，其作用域为整个类。如未定义初值，系统会自动为其赋黙认值。

       类型                     黙认值
       byte                     0
       short                    0
       int                      0
       long                     0L
       float                    0.0f
       double                   0.0d
       char                     '\u0000'
       boolean                  false
       All reference types      null
 
2. 操作符
答：1) >>   前面是零补零，前面是一补一;
    2) >>>  无符号右移;
    3) &&   短路与，前面为假，表达式为假，后面不须计算；
    4) ||   短路或，前面为真，表达式为真，后面不计算；

3. 数字类型之间的转换
答：1) byte ——→ short ——→ int ——→ long
    2) char ——→ int - - - → float
    3) float ——→ double
    4) long - - - → float+++++++++++++++
    5) long - - - → double
    6) int ——→ double

    注：1)实箭头表示无信息损失的转换，虚箭头表示转换可能引起损失；
        2)int和float同为32位，但float要有几位表示幂的位数，在精度位数上要比int要小，所以有可能会有损失。long转为double同理；
        3)char和short同为16位，但char属无符号数，其范围为0~2^16, short的范围为-2^15~2^15-1 , 所以char和short不能相互转换；
        4)byte、short、char属child型，在计算时会自动转为int型，然后转为更大范围类型(long、short、double)。

4. 强制类型转换
答：1) 语法：圆括号中给出要转换的目标类型，随后是待转换的变量名。例：doublc x=9.997;int nx = (int)x;
    2) 如果试图强制转换的类型超出了目标类型的范围，结果是一个被截取的不同的数值;
    3) 不能在布尔值和任何数字类型间强制类型转换，如确要转换，可使用条件表达式，例：b?1:0。

5. 自动转换的三种类型
答：1) 赋值         double d=1.23f;
    2) 方法调用     Math.sqrt(2);
    3) 数值计算转换 -9.232e20+1;

6. 强制转换(cast)的二种类型
答：1) 赋值
    2) 方法调用

7. switch与case
答：1) switch变量可以是byte、short、char、int;
    2) default值可以位于switch代码顶部、中部或底部;
    3) break不是必须的。例如：case 1:case 2:case 3:

2004-8-17    星期二       阴

数组

1. 声明数组
答：1) 一组相同类型(可以是类)数据的集合;
    2) 一个数组是一个对象;
    3) 声明一个数组没有创建一个对象;
    4) 数组能以下列形式声明：
       int[] i 或 int i[]
       Car[] c 或 Car c[]

2. 创建数组
答：1) 创建原始数组    int[] i = new int[2];
    2) 创建类类型数组  Car[] c = new Car[100];
    3) 数组创建后有初始值。

3. 初始化数组
答：1) 初始化、创建、和声明分开
       int[] i;
       i = new int[2];
       i[0] = 0;
       i[1] = 1;
    2) 初始化、创建、和声明在同一时间
       int[] i = {0,1};
       Car[] c = {new Car(),new Car()};

4. 多维数组
答：1) 有效
       int[][] i1 = new int[2][3];
       int[][] i2 = new int[2][];
       i2[0] = new int[2],i2[1] = new int[3];
    2) 无效
       int[][] i1 = new int[][3];
    3) 数组长度
       int[] i = new int[5];
       int len = i.length;//len = 5;
       Student[][] st = new Student[4][6];
       len = st.length;//len = 4;
       len = st[0].length;//len = 6;

请问以下哪段代码哪个可正确执行？(a,c)
1. a  char[] i = {'a','b'}; i = new char[]{'b','c'};
   b  char[] i = {'a','b'}; i = {'b','c'};
   c  char[] i = new char[2]; i = new char[]{'b','c'};
   d  char[] i = new char[2]; i = {'b','c'};

2004-8-18    星期三       晴

今天讲完数组，类的概念开了一个头。封装、继承、多态，由这三个概念展开、举例、举猫、狗、哺乳动特的例子。举给猫、狗增加一只眼睛只要改变一下父类例子。三只眼睛的狗？我们哈哈大笑，只是，今天的日记怎么写？都是一些概念性的东西。

接口(interface)是为了解决多重继承，继承产生多态(类、方法)。封装可以最大限度地代码重用。类是一种抽象、包含有属性以及改变属性的方法。对象是类的实例，除了这些还有什么？数组是对象吗？

不能确定，那查API、问同学、请教老师。还不行？那老师给你开小灶吧！教室后头架着DV，用影像真实地记录着我们的学习生活，谁也不许掉队。

大多数知识在课堂上解决了，晚上的时间，看书、预习，能看多远看多远。自已看，雾里看花；而老师教，一片瞪明。一路通透下去，只是依然担心：十八天能否将Core Java讲完。

2004-8-19    星期四       晴

对象和类(上)

1. 封装、多态、和继承
答：1) 封装
       a. 把数据和行为结合在一个包中，并对对象的使用者隐藏数据的实现过程。对象中的数据称为对象的实例字段(instance field), 操作数据的函数和过程称为对象的方法(method)。一个特定对象就是类在实例字段上有着特定值的某个实例。
       b. 实现封装的关键在于绝不让方法直接访问其他类的实例字段。

    2) 继承
       a. 在现有类的基础上构建新的类。当继承一个现有类时，就重用(继承)了那个类的方法和字段，同时，还可以向新类中增添新的方法和字段。
       b. 在通过扩展超类来定义子类时，只需要说明子类和超类的区别就行。所以在设计类时，把最通用的方法放在超类中，把更专门的方法放在子类中。

    3) 多态(polymorphism)
       一个对象变量可以指向多种实际类型的现象。

2. 类和对象
答：1) 类：数据类型/元数据的抽象;
    2) 对象：类的实例(instance of)。

3. 方法定义
答：1) 格式 <modifiers><return_type><name>([argument_list>])[throws <exception>]{<block>}
            例如：public String getName(){ return name; }
    2) 当没有返回值时，返回类型必须被定义为void；
    3) 构造方法没有返回类型。

4. 参数传递
答：Java语言总是使用传值调用。这意味着方法得到的只是所有参数值的拷贝。因此，方法不能修改传递给它的任何参数变量的内容。

5. this
答：1) this是个隐式参数，代表被构造的对象;
    2) 如果构造器的第一个语句具有形式this(...)，那么这个构造器将调用同一类中的其他构造器。

6. 封装的特点
答：1) 使具体实现不可视;
    2) 对所有的用户统一接口;
    3) 增强可维护性。

7. 方法重载
答：1) 方法名相同;
    2) 参数必须不同;
    3) 返回类型可以不同;

2004-8-20    星期五       晴

对象和类(下)

8. 创建和初始化对象
答：1) 为一个对象分配内存空间，并初始化这个对象的值为：0/null/false。
    2) 调用构造方法。

9. 构造器
答：1) 构造器和类具有相同的名字;
    2) 一个类可以有多个构造器;
    3) 构造器可以有0个、1个或者多个参数;
    4) 构造器没有返回值;
    5) 构造器只能和new运算符一起被调用。

10. 构造器重载
答：1) 黙认构造器指没有参数构造器，它把所有实例字段设为默认值;
    2) 如果编写的类没有构造器，系统会自动提供黙认构造器，那么构造没有构造参数的对象是非法的。

11. 子类
答：1) 是一种关系(现有类称为超类(super class)、基类(base class)、或是父类(parent class); 而新类称为子类(subclass child class)或者是派生类(derived class));
    2) 一种声明类型，public class Student extends Person{...};
    3) 单继承。

12. 继承
答：1) 构造器不能被初始化;
    2) 方法和字段可以被初始化;
    3) 子类构造器自动调用父类的黙认构造器；
    4) 当父类黙认构造器不存在时，子类构造器要显式调用超类的其它构造器。

13. Super
答：1) 调用超类方法;
    2) 调用超类构造器。

14. 继承(Polymorphism)
答：1) 一个对象变量可以指向多种实际类型的现象;
    2) 它是一个运行时申明。

15. instanceof操作符
答：1) Boolean类型;
    2) 判断某个实例是否属于指定类/接口

16. casting
答：1) 把一种类型强制转换成另一种类型的过程被称为类型转换(casting);
    2) 进行转换的惟一原因在于有时在暂时忽视对象实际类型之后，需要使用实际对象的全部功能;
    3) 要养成在类型转换之前先判断它是否能成功的编程习惯(使用instanceof);
    4) 应尽量少用类型转换和instanceof操作符。

17. 方法重写(overridden)
答：1) 名称、参数列表和返回类型相同;
    2) modifier不能越来越窄;
    3) 异常抛出不能越变越宽;
  

2004-8-23    星期一       晴

高级语言特性(上)

1. 静态字段和方法
答：1) 静态字段：每个类中只存在一个这样的字段，反之，类的每一对象都有自己一份对这个实例字段的拷贝;
    2) 静态方法：能不通过对象直接访问; 不能访问非静态变量; 不能被非静态方法重写;

2. 初始化块
答：1) 只被执行一次;
    2) 初始化块首先被运行，然后才是构造器的主体部分被执行。

3. 调用构造器后详细的执行过程
答：1) 初始化所有数据字段为默认值(0、0.0、false或null);
    2) 按照在类声明中出现的次序依次执行所有字段初始化语句和初始化块;
    3) 如果构造器的第一行代码调用了另一个构造器，则执行被调用的构造器主体;
    4) 执行构造器主体。

4. final关键字
答：1) final类不能被继承;
    2) final方法不能被改写;
    3) final变量不能被改变;

5. 抽象类
答：1) 方法没有方法体，必须被声明为抽象方法; 例：abstract int getAge();
    2) 一个类中包含有抽象方法必须声明为抽象类;
    3) 抽象类不能实例化，但仍可以创建类的对象变量;
    4) 能声明方法或类类型为抽象;
 
    注：1) 抽象方法如同方法占位符，这些方法一定要在子类中实现;
        2) 即使不含抽象方法，类也可被声明为抽象类。

6. 接口
答：1) 接口是抽象类的另外一种形式(没有实例变量的抽象类);
    2) 在一个接口中所有方法都是抽象方法;
    3) 接口中所有变量都必须被定义为final static；
    4) 接口可以继承多个接口。

    注：1) 接口中的方法自动被置为public, 因此，在接口中声明方法并不需要提供public关键字。但在实现接口时，必须把方法声明为public。
       

2004-8-24    星期二       晴

高级语言特性(中)

7. 访问控制
答：修饰符     内部类   相同包    子类     其它
    public       √       √       √       √
    protected    √       √       √      
    default      √       √
    private      √      

8. “==”操作符和equals()方法
答：1) “==”操作符确定两个引用是否指向相同对象;
    2) equals()方法判断两个对象是否指向同一块内存区域(这种测试并没有太大用处，如果想测试对象是否相等，就需要覆盖equals方法，进行更有意义的比较);

9.  toString()方法
答：1) 和equals()方法一样，toString()是Object类另外一个重要的方法;
    2) 它返回一个代表该对象值的字符串。几乎每个类都会覆盖该方法，以便打印该对象当前状态的表示。
    3) 无论何时对象同字符串相连接，那么就可以使用"+"操作符，这时Java编译器会自动调用toString方法获得对象的字符串表示。例：
       Point p = new Point(10,20);
       String message = "The current position is " + p;//自动调用p.toString()

10. 内部类
答：内部类是定义在其他类内部的类：
    1) 内部类对象能够访问创建它的对象的实现-包括那些私有数据;
    2) 内部类能够隐藏起来，不为同一包中的其他类所见;
    3) 匿名内部类可以方便地定义运行时回调;
    4) 所有内部类在编写事件程序时用起来很方便。

11. 静态内部类
答：1) 内部类的最简单形式;
    2) 不能和外部类同名;
    3) 被编译成一个独立的类文件;
    4) 只能访问外部类的静态方法、静态实例变量(包括私有类型);

12. 实例内部类
答：1) 定义在类内部，没有使用static修饰符;
    2) 像实例变量;
    3) 能访问外部类的所有实例变量;
    4) 在一个外部类里创建一个实例内部类实例：this.new Innerclass();
    5) 在一个外部类外创建一个实例内部类实例：(new OuterClass()).new Innerclass();
    6) 在一个内部类里访问一个实例内部类：Outerclass.this.member;

13. 局部内部类
答：1) 定义在方法里;
    2) 最少的一种内部类;
    3) 和局部变量类似, 不能被定义为public，protected，private和static;
    4) 只能访问final型局部变量。

2004-8-25    星期三       晴

高级语言特性(下)

14. 匿名内部类
答：1) 没有类名;
    2) 没有class关键字;
    3) 没有继承和声明;
    4) 没有构造函数; 

15. 封装类
答：原始基本类型     包装类
       boolean       Boolean
       byte          Byte
       short         Short
       char          Character
       int           Integer
       long          Long
       float         Float
       double        Double

16. 集合接口类层次
答：
               Collection
                    ↑
              |ˉˉˉˉˉˉ|   
             Set          List        Map
              ↑                      ↑
              |                       |
           SortedSet              SortedMap

   1) Set: 集合类中不允许有重复对象;
   2) SortedSet: 和Set接口同，但元素按升序排列;
   3) List: 元素加载和移出时按照有顺序，可以保存重复对象。
   4) Map: 存储了唯一关键字辨识的对象，不允许有重复关键字。
   5) SortedMap: 和Map类同，但对象按他们关键字的升序排列。

17. 包括具体类在内的集合类层次
答：
               Collection
                    ↑
              |ˉˉˉˉˉˉ|   
           HashSet     LinkedList       Hashtable
            (Set)    Vector, ArrayList   Hashmap
                         (List)           (Map)
              ↑                           ↑
              |                            |
            TreeSet                     TreeMap
          (SortedSet)                 (SortedMap)

18. 五个最常用的集合类之间的区别和联系
答：1) ArrayList: 元素单个，非同步，效率高，多用于查询
    2) Vector:    元素单个，同步，线程安全，多用于查询
    3) LinkedList:元素单个，多用于插入和删除
    4) HashMap:   元素成对，非同步，元素可为空
    5) HashTable: 元素成对，同步，元素不可为空

19. 反射
答：1) 确定一个对象的类;
    2) 获得一个类的修改符、变量、方法、构器函数、和父类的相类信息;
    3) 找出哪些常量和方法是从一个接口声明的;
    4) 创建一个在运行时才知道名称的类;
    5) 调用对象的方法;

2004-8-26    星期四       晴

异常

1. 异常的基本概念
答：1) 异常事件改变程序流程;
    2) 当一个异常事件发生时，一个异常被抛出;
    3) 响应处理异常的代码被称为exception handler;
    4) exception handler捕获异常;
    5) 异常处理能让你集中精力在一个地方解决问题，然后将处理错误的代码分开来放在另一个地方。

2. 捕获异常
答：1) 设置一个try/catch的代码块;
    2) 如果try块内的任何代码抛出了由catch子句指定的异常，则
       a. 程序跳过try块中的其他代码;
       b. 程序执行catch从句中的处理器代码。
    3) 如try块内没有抛出异常，直接跳过catch从句内容。
    4) 如try块内抛出的异常没有在catch从句中指定, 则该方法会立即退出。

3. 处理异常
答：1) 应捕捉并处理那些已知如何处理的异常，而传递那些不知如何处理的异常;
    2) 如想传递异常，必须在方法的定义中增加一个throws修饰符，以通知调用者可能会抛出一个异常;
    3) 对子类方法抛出的异常不能超出超类方法throws指令的范围。如父类不抛出任何异常，在子类方法中必须捕捉每一个“已检查异常”。

4. 捕捉多个异常
答：1) 每个异常类型使用一个catch从句;
    2) 如前面catch从句捕获异常，将直接跳过后面catch从句内容;
    3) 建议按异常类型的子类->超类的顺序排列catch从句的先后顺序。

5. finally 声明
答：无论是否捕获异常，都会执行finally从句中的代码;

6. 异常调用栈
答：1. 哪个方法调用的代码发生异常，返回到哪个方法;
    2. main方法调用的代码发生异常，返回到虚拟机。

7. 异常层次
答：1) 起源于Error的类代表不常用的环境(通常是硬件层面);
    2) 应用程序不能够从Error中恢复正常;
    3) 所有的Java异常都起源于Exception;
    4) RuntimeExcepiton也称为未检查异常;
    5) 未检查异常无须捕获;
    6) 其它异常，也称为检查异常，必须处理

                  Object
                    ↑
                Throwable
                    ↑
            |ˉˉˉˉˉˉˉˉ|
          Error      Exception
            |            ↑
            |     |ˉˉˉˉˉˉˉ|
               RuntimeException

8. 一些未检查的异常
答：1) java.lang.ArithmeticException  如：除0;
    2) java.lang.NullPointerException 如：没初始化一个References便使用;
    3) java.lang.ArrayIndexoutofBoundsException 如：调用一个有十个元素的Array的第十一个元素的内容;
    4) java.lang.NumberFormatException 如：Integer.parseInt("a");

9. 写你自己的异常
答：1) 要做的仅仅是从Exception继承或者是从Exception的一个子类衍生出自己需要的类就可;
    2) 习惯为每一个异常类提供一个默认的构造器以及一个包含详细信息的构造器。

10. 抛出你自己的异常
答：1) 在方法的定义中增加一个throws修饰符，以通知调用者可能会抛出一个异常;
    2) 在方法中构造一个该类的实例，然后抛出该实例。

三个Java小笑话

1. 作为父亲的儿子，我是他的子类，我继承他的全部属性和方法，但为什么父亲会开车，我不会？开车这个方法也许是final类型。

2. 你们去二十家公司面试，也许没有一家会问你内部类(累不累)。虽然内部类很少用，但没人性的公司即使应聘成功，建议也别去。

3. 你今天早上出门的时候看了不该看的一幕，以致于一天没有干活。看到这种异常，你们的项目经理过来问你是否技术上碰到了问题(试图捕获异常)？你摇摇头(异常类型不对)，然后你们的事务经理过来，你告诉他你在早上看到了自己最喜欢的Polo车竟然有最不喜欢的绿色。事务经理安慰你可将目标转为宝马，并允诺周末一起开他的宝马去海上田园兜风(捕获异常)，你情绪大为好转并提出自动加班(异常得到处理，程序正常运转)。不幸的是，你们的事务经理刚好情绪也不好，他直接将你的情况反映给总经理(捕获异常，没处理直接抛出)。更不幸的是，也许你们公司的人事经理和项目经理刚好不在，这种情况被你们的头看到，他将你开除(首先被Exception捕获，粗略处理)。你被开除后，整个项目无法进行下去，最后公司被宣布解散。因为整个公司就你一个人。

2004-8-27   星期五      晴

创建图形用户界面

1. AWT
答：1) Abstract Window Toolkit(抽象图形工具);
    2) 提供一系列的对象去创建图形用户界面;
    3) 在java.awt包里包括三种类型的类：
       a 组件: 可视化图形工具的基本类，包括容器;
       b 容器: 一种可以装载其他组件的特殊组件;
       c 布局管理器: 容器里用来定位(布置)用户界面组件的一种接口。

2. 创建图形用户界面步骤一：选择容器
答：1) 组件可被加入到容器;
    2) 通常使用以下容器: Frame, Dialog, Applet, Panel;
   
                 Component
                    ↑
                 Container
                    ↑
       |ˉˉˉˉˉˉ|ˉˉˉˉˉˉ|
   ScrollPane    Window        Panel
                    ↑   ↑
               |ˉˉˉˉˉ|      |
             Frame     Dialog  Applet
                          ↑
                     FileDialog

3. 容器方法
答：1) add(Component com) : 将组件加入容器;
    2) setLayout(): 设置布局管理器;   
    3) pack(): 按照首选的尺寸和组件的布局构建窗体;
    4) setTitle(): 设置窗体标题;

4. 创建图形用户界面步骤二：选择布局管理器
答：1) 使用容器的setLayout()方法设置容器管理器；
    2) 组件方法setLocation()、setSize()、setBounds()定义了组件的尺寸和位置;
    3) Window类容器黙认布局管理器是BorderLayout；
    4) Panel类容器黙认布局管理器是BorderLayout；

5. 创建图形用户界面步骤三：增加组件进容器
答：1) 创建组件
       TextField tf = new TextField();
       ...
    2) 使用容器方法add()将组件增加进容器
       add(tf);

6. 创建图形用户界面步骤四：创建事务处理
答：使用组件方法：addXXXListener()

7. Frames
答：1) 起源自Window类;
    2) 不能作为一个部件放到其他部件里;
    3) 有标题、连框和菜单工具条;
    4) 默认的布局管理器是BorderLayout;
    5) 使用setLayout()改变布局管理器;
    6) 创建一个frame标例: Frame frame = new Frame("The First GUI")。

8. Panels
答：1) 通常被加入其它容器;
    2) 把一组相关的组件放到容器里;
    3) 默认的布局管理器是FlowLayout;

9. FlowLayout布局管理器
答：1) 尊重每个组件自身的大小;
    2) 构造方法：
       FlowLayout()
       FlowLayout(int align)
       FlowLayout(int align, int hgap, int vgap)
  
       int align: FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER, FlowLayout.LEADING, FlowLayout.TRAILING

10. BorderLayout布局管理器
答：1) 分为五个区域：
       BorderLayout.CENTER, BorderLayout.EAST,
       BorderLayout.WEST, BorderLayout.SOUTH,
       BorderLayout.NORTH
    2) 南北区域保持组件高度， 但宽度因容器宽度改变;
    3) 东西区域保持组件宽度， 但高度因容器宽度改变;
    4) 中部区域，高宽均改变;
    5) 构造方法
       BorderLayout(), BorderLayout(int hgap, int vgap)

11. GridLayout布局管理器
答：1) 在容器里以网格形状排列组件;
    2) 每个网格均是相等尺寸;
    3) 忽略每个组件的原始尺寸;
    4) 构造方法:
       GridLayout()
       GridLayout(int rows, int cols)
       GridLayout(int rows, int cols, int hgap, int vgap)

12. CardLayout布局管理器
答：1) 将每一个组件处理成一张牌，在任何时候只有一张牌可视;
    2) 不尊重组件的原始尺寸;
    3) 构造方法：
       CardLayout()
       CardLayout(int hgap, int vgap)
    4) CardLayout中方法
       void first(Container c)
       void last(Container c)
       void next(Container c)
       void show(Container c, String name)
 
13. GridBagLayout 布局
答：1) 在网格里放置组件;
    2) 一个组件可占多行或列;
    3) 当组件被加入容器时通过GridBagConstraints对象确定组件将占多少个表元;
    4) 构造方法：GridBagLayout();
    5) 重要方法：setConstraints(Component c, GridBagConstraints gcs)

14. GridBagConstraints类
答：构造方法
    GridBagConstraints()
    GridBagConstraints(int gridx, int gridy, int gridwidth, int gridheight, double weightx, double weighty, int anchor, int fill, Insets insets, int ipadx, int ipady)

2004-8-30   星期一      晴

AWT组件库

1. 组件公有方法
答：1) setForeground(): 设置前景颜色;      setBackground(): 设置背景颜色;
    2) getForeground(): 取得前景颜色;      setBackground(): 取得背景颜色;
    3) setEnabled(): 使组件有效;           getEnabled(): 取得组件有效的状态;
    4) setVisible(): 使组件可视;           getVisible(): 取得组件可视状态;
    5) setFont(): 设置组件字体;            getFont(): 取得组件字体;
    6) setSize(): 设置组件大小;            getSize(): 取得组件大小;
    7) getPreferredSize(): 取得默认的尺寸;
    8) setLocation(): 设置组件位置;        getLocation():获得组件位置;
    9) setBounds(): 移动并且重新调整尺寸;  getBounds(): 返回这个组件的范围(位置和尺寸);
    10)paint(): 绘制组件; repain():重绘;   update():更新;

2. 按钮(Button)
答：1) 当单击时产生一个动作action;
    2) 构造函数：
       Button()
       Button(String label)
    3) 方法：
       setActionCommand(): 设置这个按钮触发的动作事件的命令名称;
       getActionCommand(): 返回这个按钮触发的动作事件的命令名称;
       setLabel(): 设定这个按钮的标签;
       getLabel(): 得到这个按钮的标签;
       addActionListener(): 加入指定的动作侦听器去接按钮动作事件;
       removeActionListener(): 移除指定的动作侦听器，使按钮不再接收动作事件;
       getActionListeners(): 返回所有登记的动作侦听器的数组;
 
3. 画布(Canvas)
答：1) 用来显示图形;
    2) 绘制外形、像素以及带有许多颜色的文本
    3) 构造方法：
       Canvase()
       Canvas(GraphicsConfiguration conf)
    4) 方法：
       paint()
       update()

4. 复选框(Checkbox)
答：1) 单独使用，显示一选中或不选中的复选框;
    2) 作为复选框组的成员，它的表现和单选按钮同;
    3) 构造函数:
       checkbox()
       checkbox(String label)
       checkbox(String label, boolean state)
       checkbox(String label, boolea state, CheckboxGroup group)
       checkbox(String label, CheckboxGroup, boolean state)
    4) 关于checkbox的方法:
       addItemListener(): 加入指定项目监听器接收复选框项目事件;
       removeItemListener(): 移除指定的项目监听器，使复选框不再接收复选框事件;
       setState(): 将复选框设定为指定状态;
       getState(): 判断复选处于“开”或“关”状态;
       setLabel(): 设置复选框标签;
       getLabel(): 得到复选框标签。
    5) 关于CheckboxGroup的方法
       getSelectedCheckbox(): 从复选框组中得到当前选择;
       setSelectedCheckbox(): 设置复选框组中指定复选框为选中。

5. 下拉列表(Choice)
答: 1) 一种下拉菜单形式的单选项;
    2) 当前选中的项目显示在屏幕上;
    3) 构造函数:
       Choice()
    4) 方法:
       add(): 为下拉列表加入选项元素;
       insert: 在指定位置插入选项元素;
       getSelectedItem(): 以字符串形式返回当前选项;
       getSelectedIndex(): 返回当前选项的索引;
       getItem(): 返回下拉列表中指定索引位置元素的字符串格式;
       addItemListener(): 加入指定项目监听器，接收来自下拉列表的项目事件;
       removeItemListener(): 移除指定项目监听器，使它不再接收来自下拉列表的项目事件;

6. 标签(Label)
答：1) 用以在屏幕上显示文本;
    2) 没有直接的交互动作;
    3) 构造方法：
       Label()
       Label(String text)
       Label(String text, int alignment)
    4) 方法
       setText(): 设置标签的文本为指定内容;
       getText(): 得到标签的文本内容;

7. 列表(List)
答：1) 在屏幕上显示一组文本选项;
    2) 允许用户单选或多选;
    3) 构造方法
       List()
       List(int rows)
       List(int rows, boolean multipleModel)

8. 文本域(Textfield)
答：1) 提供一单行可供编辑的文本
    2) 构造方法
       Textfield()
       Textfield(int columns)
       Textfield(String text, int columns)

9. 文本区(TextArea)
答：1) 提供多行多列的可编辑文本区;
    2) 文本区将显示水平和垂直的滚动条;
    3) 构造方法
       TextArea()
       TextArea(int rows, int cols)
       TextArea(String text)
       TextArea(String text, int rows, int cols)
       TextArea(String text, int rows, int cols, int scrollbars)

10. 对话框(Dialog)
答：1) 一个带有标题和边界的自由窗口;
    2) 黙认的布局管理器是BorderLayout;
    3) 必须拥有一个调用者;
    4) 可以是模式和非模式的。

11. 文件对话框(File Dialog)
答：1) 模式对话框;
    2) 用以选择文件;

12. 滚动面板(Scroll Pane)
答：1) 一个容器类;
    2) 能为单个组件自动水平或垂直滚动;

13. 菜单条(MenuBar)
答：1) 一个菜单条组件是一个水平菜单，它只能加入到一个框架中，并成为所有菜单树的根。
    2) 使用框架的setMenuBar()方法设置菜单条;

14. 菜单(Menu)
答：1) 主要功能是装载菜单项;
    2) 继承自MenuItem类，因此它能装载其它菜单;

15. 菜单项(MenuItem)
答：1) 菜单项组件是菜单树的文本“叶”结点，它们通常被加入到菜单中，以构成一个完整的菜单;
    2) 通常将一个ActionListener加入到一个菜单项对象中，以提供菜单的行为。

16. 弹出式菜单(PopupMenu)
答：1) 提供了一种独立的菜单，可以在任何组件上显示;
    2) 可以将菜单条目和菜单加入到弹出式菜单中去。

AWT事件模型

1. 什么是事件？
答：1) 事件源-事件的产生器;
    2) 事件-描述发生了什么的对象;
    3) 事件处理器-接收事件、解释事件并处理用户交互的方法;

2. 事件源
答：1) 事件源是一个事件的产生者;
    2) 提供方法允许其它方法增加或移除事件处理器;
    例：在Button组件上点击鼠标会产生以这个Button为源的一个ActionEvent, 这个ActionEvent实例是一个对象，它包含关于刚才发生的那个事件的信息的对象。

3. 事件处理器
答：1) 事件处理器就是一个接收事件、解释事件并处理用户交互的方法。

4. 事件类型
答：1) 对于每类事件，都有一个接口，这个接口必须由想接收这个事件的类的对象实现。这个接口还要求定义一个或多个方法。当发生特定的事件时，就会调用这些方法。

5. ActionEvent
答：1) 双击列表项;
    2) 按钮被选中;
    3) 菜单项被选中;
    4) 文本域回车。

6. TextEvent
答：适用二行文本域同步情况

7. ItemEvent
答：1) 多选框选中或取消;
    2) 可选菜单选中或取消;
    3) 下拉列表项选中;
    4) 列表项选中。

8. 事件适配器
答：1) 事件适配器空实现了一个事件处理器的所有方法;
    2) 你只需继承并重写你感兴趣的方法即可

2004-8-31   星期二    晴

Java基础类

1. JFC预览
答：1) Java基础类是关于GUI组件和服务的完整集合，它大大简化了健壮Java应用程序的开发和实现;
    2) Java基础类其中的一部分就是Swing, Swing是构筑在AWT上层的一些组件的集合;
    3) Java基础类主要包含5个API：
       a. AWT: 为各类Java应用程序提供了多种GUI工具;
       b. Java2D: 一图形API, 为Java应用程序提供了一套高级的有关二维图形图像处理的类;
       c. Accessibility API: 提供了一套高级工具，用以辅助开发使用非传统输入和输出的应用程序。
       d. Drag & Drop：提供了Java和本地应用程序之间的互操作性，用来在Java应用程序和不支持Java技术的应用程序之间交换数据。
       e. Swing:JFC模块的重点，用来进行基于窗口的应用程序开发，它提供了一套丰富的组件和工作框架，以指定GUI如何独立于平台地展现其视觉效果。

2. Swing介绍
答：1) 它是围绕着实现AWT各个部分的API构筑的;
    2) 大多数组件不象AWT那样使用与平台相关的实现。

3. 导入Swing过程
答：1) 导入Swing包;
    2) 选择外观和感觉(getLookAndFeel());
    3) 设置窗口容器
       a. JFrame与Frame相似;
       b. 你不能直接将组件加入到JFrame中;
       c. 一个content pane包含了除菜单条外所有Frame的可视组件

4. JComponent类
答：1) 所有Swing都作为JComponent的子类来实现;
    2) Swing组件从JComponent继承了如下功能：
       a. 边框(setBorder()方法指定在组件周围显示的边框, EmptyBorder的实例来指定一个组件在其周围留有一定的额外空间);
       b. 双缓冲(可以改善一个频繁被改变的组件的外观，缺省是双缓冲);
       c. 提示框(通过用setToolTipText()方法来指定一个字符串，提供给用户有关某个组件的帮助信息)
       d. 键盘导航
       e. 应用程序范围的可插式外观和感觉

Java小程序

1. 什么是Applet?
答：1) Applet是能够嵌入到一个HTML页面中，且可通过Web浏览器下载和执行的一种Java类;
    2) Applet通过浏览器或applet viewers运行;

2. Applet的安全限制
答：1) 运行时执行另一程序;
    2) 任何文件的输入/输出;
    3) 调用本地方法;
    4) 尝试打开除提供Applet的主机之外的任何系统的Socket。

3. Applet和AWT的层次
答：java.lang.Object
           |
           |
   java.awt.Component
           |
           |
   java.awt.Containter
           |
           |
    java.awt.Panel
           |
           |
   java.applet.Applet

4. Applet的方法和Applet的生命周期
答：1) init()
       a. 只在Applet首次装入时被调用, 并且在调用start()之前执行完成;
       b. 可用于初始化数据值;
    2) start()
       a. 当Applet成为可见时运行
    3) stop()
       a. 当Applet成为不可见时运行

5. Applet标记
答：1) code=appletFile.class  给定了含有编译好的Applet子类的文件名;
    2) width = pixels  height = pixels  给出了Applet显示区域的初始宽度和高度;
    3) codebase = codebaseURL 指定了Applet的URL(包含有Applet代码的目录, 如该属性未指定，则采用文档的URL);
    4) align = alignment  指定了Applet的对齐方式
    5) <param name = appletAttribute1 value = value>  提供参数
  
6. Applet和浏览器的交互方法
答：1) getParameter(String name)： 取得参数;
    2) getCodeBase(): 返回一个描述Applet类文件本身源目录的URL对象;
    3) getDocumentBase(): 返回一个描述装载Applet的HTML文件的URL对象;

2004-9-1   星期三    雨

线程

1. 什么是线程？
答：1) 一个线程是一个程序单个的连续控制;
    2) 一个软件能处理一系列的线程构造;
    3) 线程能同时运行，彼此独立;
    4) 包为java.lang.Thread;

2. 线程或上下文的构成
答：1) 一个虚拟处理机;
    2) CPU执行的代码
       代码可以或不可以由多个线程共享，这和数据是独立的。两个线程如果执行同一个类的实例代码，则它们可以共享相同的代码。
    3) 代码操作的数据
       数据可以或不可以由多个线程共享，这和代码是独立的。两个线程如果共享对一个公共对象的存取，则它们可以共享相同的数据。

3. 线程机制
答：1) 当线程开始，run()方法里代码被执行;
    2) 创建线程的二种方法：
       a. 继承Thread类;
       b. 实现Runnable接口。

4. 通过继承Thread类创建一个线程
答：1) 定义
       public class MyThread extends Thread{
         public void run(){...}
       }
    2) 初始化
       MyThread testThread = new MyThread()

5. 通过实现runnable接口创建一个线程
答：1) 定义
       public class MyRunnable implements Runnable {
         public void run(){...}
       }
    2) 初始化
       MyRunnable testRunnable = new MyRunnable();
       Thread testThread = new Thread(testRunnable)

6. 二种创建线程方法的比较
答：1) 继承Thread类是面向对象编程;
    2) 实现Runnable接口解决了单继承

7. 线程调度
答：1) 线程是抢占式的，但并不一定是分时的；
    2) 有多个线程可运行，但只有一个线程在实际运行。
    3) 所有可运行线程根据优先级保存在池中，当一个被阻塞的线程变成可运行时，它会被放入相应的可运行池，优先级最高的非空池中的线程得到处理机时间。
    4) sleep()调用会给较低优先级线程一个运行的机会，yield()方法只会给相同优先级线程一个执行的机会。

8. 线程的基本控制
答：1) 启动线程：使用start()方法，这意味着线程可以由JVM调度并执行，并不意味着线程就会立即执行。
    2) 终止一个线程：当一个线程结束运行并终止时，它就不能再运行了。
    3) 测试一个线程：isAlive()方法用来确定一个线程是否仍是活的。活着的线程并不意味着线程正在运行。
    4) 延迟线程：
       sleep()：使线程停止一段时间，间隔期满后，线程不一定立即恢复执行。
       join()：挂起当前线程，直至它所调用的线程终止。

9. synchronized关键字
答：1) 标识一组变量应该被一个线程独占地使用;
    2) public void push(char c){
         synchronized(this){
         ...
         }
       }
       public synchronized void push(char c) {
       ...
       }
    3) 所有对易碎数据的存取应当是同步的，由synchronized保护的易碎数据应当是private的。

10. 线程交互
答：1) wait()：交出锁和CPU的占用;
    2) notify()：将从对象的等待池中移走一个任意的线程，并放到锁池中，那里的对象一直在等待，直到可以获得对象的锁标记。
    3) notifyAll(): 将从等待池中移走所有等待那个对象的线程并放到锁池中，只有锁池中的线程能获取对象的锁标记，锁标记允许线程从上次因调用wait()而中断的地方开始继续运行。

2004-9-2   星期四    阴

流式I/O和文件

1. 流和基础知识
答：1) 一个流是字节的源或目的
    2) 二种基本的流是：输入流和输出流
      
2. InputStream方法
答：1) 三个基本的read()方法
       a. int read(): 从流里读出的一个字节或者-1;
       b. int read(byte[])：将数据读入到字节数组中，并返回所读的字节数;
       c. int read(byte[], int , int)：两个int参数指定了所要填入的数组的子范围。
    2) 其它方法
       a. void close(): 关闭流，如使用过滤器流，关闭栈顶部的流，会关闭其余的流。
       b. int available(): 返回可从流中读取的字节数。
       c. skip(long): 丢弃了流中指定数目的字符。

2. OutputStream方法
答：1) 三个基本的read()方法
       a. void write():
       b. void write(byte[])：
       c. void write(byte[], int , int)：
       写输出流。
    2) 其它方法
       a. void close(): 关闭流，如使用过滤器流，关闭栈顶部的流，会关闭其余的流。
       b. int flush(): 允许你强制执行写操作。

3. FileInputStream和FileOutputStream
答：1) 结点流，使用磁盘文件。
    2) 要构造一个FileInputStream, 所关联的文件必须存在而且是可读的。
    3) 要构造一个FileOutputStream而输出文件已经存在，则它将被覆盖。
       FileInputStream infile = new FileInputStream("myfile.dat");
       FIleOutputStream outfile = new FileOutputStream("results.dat");

4. BufferInputStream和BufferOutputStream
答：过滤器流，可以提高I/O操作的效率

5. DataInputStream和DataOutStream
答：通过流来读写Java基本类,注意DataInputStream和DataOutputStream的方法是成对的。

6. PipedInputStream和PipedOutputStream
答：用来在线程间通信.

7. Reader和Writer
答：1) Java技术使用Unicode来表示字符串和字符，而且提供16位版本的流，以便用类似的方法处理字符。
    2) InputStreamReader和OutputStreamWriter作为字节流与字符流中的接口。
    3) 如果构造了一个连接到流的Reader和Writer，转换规则会在使用缺省平台所定义的字节编码和Unicode之间切换。

8. 文件
答：1) 一个文件对象可以代表文件或者目录;
    2) File类处理所有磁盘操作;
    3) 构造方法：
       a. File(File parent, String child):
       b. File(String pathName);
       c. File(String parent, String child);
       d. File(URI uri)
    4) 目录分隔
       File.separator
9. 随机存取文件
答：1) 实现了二个接口：DataInput和DataOutput;
    2) 只要文件能打开就能读写;
    3) 通过文件指针能读写文件指定位置;
    4) 可以访问在DataInputStream和DataOutputStream中所有的read()和write()操作;
    5) 在文件中移动方法:
       a. long getFilePointer(): 返回文件指针的当前位置。
       b. void seek(long pos): 设置文件指针到给定的绝对位置。
       c. long length(): 返回文件的长度。

10. 串行化
答：1) 将一个对象存放到永久存储器上称为保持;
    2) 只有对象的数据被串行化;
    3) 标记为transient关键字的数据不被串行化。

2004-9-3   星期五    阴

网络

1. socket
答：1) 在一个特定编程模型下，进程间通信链路的端点。
    2) 一个socket包括两个流：一个输入流(读取另一个进程所写的数据)和一个输出流(向另一个进程发送数据)。

2. Java技术中的网络
答：1) 连接的地址(Host name 或者 IP Address);
    2) 端口号(范围从0-65535, 小于1024的端口号保留给预定义的服务);

3. Java中的网络模型:
答：1) 服务器分配一个端口号，如果客户请求一个连接，服务器使用accept()方法打开socket连接;
    2) 客户在host的port端口建立连接;
    3) 服务器和客户使用InputStream和OutputStream进行通信。

4. 建立服务器端
答：1) ServerSocket server = new ServerSocket(post)
    2) Socket connection = server.accept();
    3) ObjectInputStream input = new ObjectInputStream(connection.getInputStream());
       ObjectOutputStream output = new ObjectOutputStream(connection.getOutputStream());
    4) 处理输入和输出流;
    5) 关闭流和socket。

5. 建立客户端
答：1) Socket connection = new Socket(127.0.0.1, 7777);
    2) ObjectInputStream input = new ObjectInputStream(connection.getInputStream());
       ObjectOutputStream output = new ObjectOutputStream(connection.getOutputStream());
    3) 处理输入和输出流;
    4) 关闭流和socket。

6. URL连接
答：1) URL和URLConnection类封装了大量复杂的从远端服务器获取信息的操作；
    2) 支持HTTP和FTP资源
       URL url = new URL("http://www.enterinfo.net")
       URL url = new URL("ftp://TonyDeng@enterinfo.net")
    3) 打开一个网络连接
       URLConnection urlconn = url.openConnection()
    4) 打开一个输入流
       inputStream in = url.openStream()

7. UDP socket
答：1) 无连接的协议
    2) 不保证消息的可靠传输
    3) 它们由Java技术中的DatagramSocket和DatagramPacket类支持