java基础知识整理

第一章
1、Java中没有指针、结构和类型定义等概念，没有全局变量，没有#include和#define等预处理器，也没有多重继承的机制。只允许单重继承。在Java中，class定义的大括号之后没有分隔符“;”。
2、Java源代码使用的是Unicode码，而不是ASCⅡ码，Unicode码是用16位二进制表示的一个字符。Java编译器将Java程序编译成二进制代码。
3、编译后的Java程序指令并不直接在硬件系统的CPU上执行，而是由Java虚拟机（JVM）执行。JVM使用的代码存储在.class文件中。JVM的代码格式为压缩的字节码。
4、三级代码安全检查，即验证、分析和跟踪监测。
5、字节码校验器要对程序中的代码进行四趟扫描。
6、Java程序分为两种：
   （1）Java应用程序（Java Application）；
   （2）Java小应用程序（Java Applet），或叫Java小程序。
7、如果方法不是静态（static）的，则必须先创建类的实例，然后调用实例的方法。
8、String args[]表示命令行参数。
9、Java规定，如果.java文件中包含一个公有类，则存储的文件名要与该共有类的类名一致。
    ※可以在所有类里都写上 main 方法，给程序提供N多个入口，但是最后运行程序的时候也只能从其中的一个入口进去，这就是 main 的作用( 程序入
   口 )。
9、Java规定，在一个源文件中，最多只能定义一个公有类。
10、包说明必须出现在类说明和引入语句之前，引入语句必须出现在所有的类说明之前。
        ※只有package语句是零个或一个，import语句、类定义、接口定义为零个或多个。
11、Java的核心API共有32个包。
第二章
1、Java中的注释有三种：
   （1）//在一行的注释；
   （2）/*在一行或多行的注释*/
   （3）/**文档注释*/
       ※文档注释，用javadoc命令自动生成文档。
2、在Java语言中，标识符是由字母、下划线、美元符（$）开头，由字母、下划线、美元符和数字组成的字符串。
      ※标识符中不能含有其他符号（关键字[int、abstract等]、保留字[null、true、false等]），如+、==、*及%，当然也不允许插入空格。
3、Java命名约定：
  （1）类名和接口名应为名词，每个字的首字母大写；
  （2）方法名应为动词，首字母小写，其余各字的首字母大写，尽量不要在方法名中使用下划线。
   （3）常量：简单类型常量的名字应该全部为大写字母，字与字之间用下划线分隔；对象常量可使用混合大小写。
   （4）变量都使用混合大小写，首字符为小写，后面的字首用大写，变量名中不要使用下划线。
   （5）包：通常全部用小写字母。
4、Java不允许数字类型和布尔类型之间进行转换。
5、类型转换的原则是，位数少的类型转换为位数多的类型。
6、Java中除Object之外的所有类有且只有一个父类，Object是为一个没有父类的类。
7、限定访问权限的修饰符（public、private、protected）如果不写，则表明是“friendly”（包访问权限），相应的成分可以被所在包中的各类访问。
8、抽象方法的方法体是空的，含有抽象方法的类必须说明为抽象类。
9、this指代本类，super指代父类。
10、声明一个引用的格式：类名 变量名;
        ※Java把说明为class类型的变量看作是引用。
11、创建对象实例的格式： 变量名 = new 类名（参数列表）;
      ※当对象作为函数参数时，它传递的是对象的引用。
12、当执行new为一个对象分配内存时，Java自动初始化所分配的内存空间。对于数值变量，赋初值0。对于布尔变量，初值为false。
第三章
1、简单类型的变量在说明之后，系统自动在内存分配相应的存储空间。说明引用后，系统只分配引用空间，程序员要调用new来创建对象实例，然后才分配相应的存储空间。
2、Java允许对浮点数进行取模操作。
3、Java允许“==”和“!=”两种运算用于任何数据类型。
4、位运算符
   （1）位运算符只能对整形和字符型数据进行操作。
   （2）算数右移（>>）运算符使用符号位填充左侧的空位，而逻辑运算符（>>>）使用零填充空位。
   （3）“>>>”运算符只用于整型，它只对int 或long 值起作用。
5、if关键字之后的逻辑表达式必须得到一个逻辑值，不能像其它语言那样以数值来代替。
第四章
1、在Java中，数组是对象。
   ※Java在数组的定义中并不为数组元素分配内存，因此方括号[ ]中不用指出数组中元素的个数（即数组的长度）。
2、数组的初始化分为：
   （1）静态初始化：在定义数组的同时对数组元素进行初始化。
   （2）动态初始化：使用运算符new为数组分配空间。
      ※对于复合类型的数组，需要经过两步进行空间分配。
（1）创建数组本身：type arryName[] = new type[arraySize];
（2）分别创建各个数组元素：
          arrayName[0] = new type(paramList);
           ……
          arrayName[arraySize-1] = new type(paramList);
     ※数组的下标从0开始，一直到arrayName.length-1。
     ※编译器不能检查数组元素的初始化情况。
3、数组变量的类型可以不同于所指向的数组类，但应该是它的父类。
4、多维数组进行动态初始化时，有两种分配内存空间的方法：
   （1）直接为每一维分配空间，如：
              type arrayName[][] = new type[arraylength1][arraylength2];
   （2）从最高维起（而且必须从最高维起），分别为每一维分配内存，如：
       type arrayName[][] = new type[arraylength1][];
         arrayName[0] = new type[arraylength2];
       arrayName[1] = new type[arraylength2];
      ……
       arrayName[arraylength1-1] = new type[arraylength2];
       ※在Java中可以创建非矩阵数组。
   ※数组的维数说明顺序应从高维到低维，先说明高维，再说明低维，反之是不允许的。
   ※与一维数组的长度不同，多维数组的length属性只返回第一维的长度。
5、向量（定义在java.util类包中）
   （1）Vector类的对象可以看作是一个可变大小的数组。创建了Vector的对象后，如果增加或删除了其中的元素，Vector的大小也相应地变大或变小。
   （2）每个向量Vector对象包含一个容量值elementCount和一个容量增量capacityIncrement。
   （3）Vector类的三类构造方法：
         （3.1）public Vector()：构造一个空向量。
            （3.2）public Vector(int initialCapacity)：以指定的初始存储容量
 initialCapacity构造一个空的向量Vector。
         （3.3）public Vector(int initialCapacity int capacityIncrement)：以指定的初始存储容量initialCapacity和容量增量capacityIncrement构造一个空的向量 
                           Vector。
   （4）元素的添加：
         （4.1）addElement(Object obj)：将新元素添加到序列尾部。
         （4.2）insertElementAt(Object obj, int index)：将指定对象obj插入指定位置index处，并将原先索引值等于或大于该指定值的元素索引值加1。
   （5）元素的删除
         （5.1）setElementAt(Object obj, int index)：将向量序列index位置处的对象元素设置为obj，如果这个位置原来有元素，则被新值所覆盖。如果索引  
            值index是负数或超出实际元素的个数，则抛出异常ArrayIndexOutOfBoundsException。
         （5.2）removeElement(Object obj)：删除向量序列中第一个与指定的obj对象相同的元素，同时将后面的元素向前提，补上空位。这个方法返回的是一个布尔型，表示删除操作成功与否。
         （5.3）removeElementAt(int index)：删除index指定处的元素，同时将后面的元素向前提。如果索引值index是负数或超出实际元素的个数，则抛出异常 ArrayIndexOutOfBoundsException。
         （5.4）removeAllElements()：清除向量中的所有元素，同时向量的大小置为零。
   （6）元素的查找
         （6.1）Object elementAt(int index)：返回指定处的元素。如果索引值index是负数或超出实际元素的个数，则抛出异常            
                          ArrayIndexOutOfBoundsException。
         （6.2）boolean contains(Object obj)：检查向量序列中是否包含指定的对象的元素obj。
         （6.3）int indexOf(Object obj, int start_index)：从指定的start_index位置开始向后搜索，返回所找到的第一个与指定对象obj相同的元素的下标位 
            置。若指定的对象不存在，则返回-1。
         （6.4）int lastIndexOf(Object obj, int start_index)：从指定的start_index位置开始向前搜索，返回所找到的第一个与指定对象obj相同的元素的下标位
            置。若指定的对象不存在，则返回-1。
   （7）Vector类中的其他方法：
         （7.1）public final int size()：返回向量中目前实际的元素个数。
         （7.2）public final Boolean contains(Object elem)：如果对象elem是向量中的一个元素值，则返回true，否则返回false。
         （7.3）public final int indexOf(Object element)：从向量的第一个元素开始查找指定对象，并返回该对象的索引值（如果查找不成功则返回-1）。
6、字符串类型
   1、Java中的字符串是一个真正的对象，而不像其他语言那样是一个零结尾的字符数组。
   2、Java提供的标准包java.lang中封装了类String和StringBuffer，分别用于处理不变字符串（字符串一旦创建，其内容就不能改变）和可变字符串。
   3、系统为程序中出现的字符串常量自动创建一个String对象。
   4、String类中常用的方法：
     （4.1）length()：返回字符串中的字符个数。
     （4.2）charAt(int index)：返回字符串中index位置的字符。
     （4.3）toLowerCase()：将当前字符串中所有字符转换为小写形式。
     （4.4）toUpperCase()：将当前字符串中所有字符转换为大写形式。
     （4.5）subString(int beginIndex)：截取当前字符串中从beginIndex开始到末尾的字串。
     （4.6）replace(char oldChar, char newChar)：将当前字符串中出现的所有oldChar转换为newChar。
     （4.7）concat(String str)：将str连接在当前字符串的尾部。
      ※String类的对象实例是不可改变的，对字符串施加操作后并不改变字
符串本身，而是又生成了另一个实例。
      ※只要“+”的两个操作数中有一个是字符串，则另一个也自动变为字符串类型。
      ※为StringBuffer类对象分配内存时，除了字符所占的空间外，再另加16个字符大小的缓冲区。
      ※StringBuffer类对象使用append()方法实现连接。
7、如果数组的方括号紧挨着类型关键字，则说明它们是类型的一部分，则作用
于该声明中的每一个变量。如果数组的方括号紧挨着变量名，则说明它仅作
用于该变量名。
第五章
1、重载方法的参数表必须不同，即参数个数或参数类型不同。
2、构造方法不能说明为native、abstract、synchronized或final，也不能从父类继承构造方法。构造方法必须为所有的变量赋初值。
3、finalize方法：在对实例进行垃圾收集之前，Java自动调用对象的finalize方法，它相当于c++中的析构函数，用来释放对象所占用的系统资源。finalize方法的说明方式如下：public void finalize()throws Throwable
4、Java中用关键字extends表示派生。
5、instanceof运算符：判断它左侧对象是否是它右侧的类的实例。
6、如果在子类的构造方法的定义中调用了父类的构造方法，则调用语句必须出现在子类构造方法的第一行。
7、系统只在实例化该类的第一个类的时候，为类成员分配内存，以后再生成该类的实例对象时，将不再为类成员分配内存，不同对象的类变量将共享同一内存空间。
8、将一个变量定义为类变量（即静态变量）的方法就是将这个变量标记上关键字static。
※静态方法不能被重写。
9、final关键字
（1）用final修饰的类不能再派生子类，用final修饰的方法不能被重写。
（2）如果一个变量被标记为final，则会是它成为一个常量。
（3）如果一个引用类型的变量标记为final，那么这个变量将不能再指向    其它对象，但它所指对象的取值可以改变。
10、抽象类
   （1）抽象类的定义如下：
        public abstract class className{
          //方法体
}
   （2）抽象方法的定义：
        public abstract <returnType> <methodName> (参数列表);
11、接口
   （1）在接口中，所有的方法都是抽象方法，没有方法体；所有的数据成员必须赋初值，且此值将不能再改变。
   （2）Java允许一个类实现多个接口。（通过它实现c++中多重继承的功能）。
   （3）接口的定义形式：
        [接口修饰符]interface 接口名称 [extends 父类名]{
           //方法原型或静态常量
}
   （4）接口的实现格式：
        public class className implement interfaceName{
        /* Bodies for the interface methods*/
        /*Own data and methods*/
}
   （5）在接口的定义中，Java允许省略定义数据成员的final关键字、方法的public及abstract关键字。
   （6）不能直接由接口来创建对象，可以声明接口类型的变量（或数组），并用它来访问对象。
12、内部类：在一个类的内部定义的非静态类。
   （1）只能在被定义的范围内被使用。
   （2）被定义为static型的内部类将自动转化为顶层类，它们不能再使用局部范围中或其它内部类中的数据和变量。
   （3）内部类不能定义static型成员。
13、匿名类
第六章
1、Java把程序运行中可能遇到的错误分为两类：（1）异常；（2）错误
2、Exception类是所有异常的父类，Error类是所有错误的父类。
3、try与catch语句的语法格式：
   try{
   //此处为抛出具体异常的代码
}catch(ExceptionType1 e){
//抛出ExceptionType1异常时要执行的代码
}catch(ExceptionType2 e){
//抛出ExceptionType2异常时要执行的代码
}
……
catch(ExceptionTypek e){
//抛出ExceptionTypek异常时要执行的代码
}finally{
//必须执行的代码
}
※如果在try后花括号内执行了System.exit(0)方法，将不执行finally后面的语句，这是不执行finally后面语句的唯一一种可能。
4、公共异常
  （1）ArithmeticException：整数除法中，如果除数为零，则发生该类异常。
  （2）NullPointerException：如果一个对象还没有实例化就访问该对象或调用它的方法，将导致次异常。
  （3）NegativeArraySizeException：创建数组时，如果元素的个数是一个负数，
将会引发该异常。
  （4）ArrayIndexOutOfBoundsException Java：如果数组下标越界，将会导致该异常。
  （5）SecurityException：若Applet试图进行下述操作，将抛出此类异常：
       （5.1）访问本地文件；
       （5.2）打开一个套接口，而不是返回到提供Applet的主机；
       （5.3）在运行时环境中运行另一个程序。
  （6）ArrayStoreException：程序试图存取数组中错误的数据类型。
  （7）FileNotFoundException：试图存取一个并不存在的文件时发生该异常。
  （8）IOException：通常的I/O错误。
5、Java主要有3类异常：
  （1）Error：很难恢复的错误
  （2）RuntimeException：表示设计或实现方面的问题。
  （3）其它异常：运行时因环境的影响可能发生并可被处理的问题。
6、不在当前方法内处理异常，而是把异常抛出到调用方法中，格式：
   <访问权限修饰符> <放回类型值> <方法名>(参数列表)throws 异常列表
7、用户自定义的所有异常都必须是Exception的子类。
第七章
1、Swing组件和AWT组件
Swing组件：在实现时，不包含任何本地代码，Swing组件可以不受硬件平台的限制，而具有更多的功能。被称为“轻量级组件”。
   AWT组件：包含本地代码，被称为“重量级组件”。
   ※当“轻量级”和“重量级”同时存在时，如果组件区域有重叠，则重量级
组件总是显示在上面。
2、显示在屏幕上的所有组件都必须包含在某个容器中，有些容器是可以嵌套的，
在这个嵌套层次的最外层，必须是一个顶层容器。各种组件（包括容器）可
以通过add()方法添加到容器中。
3、Swing提供了四种顶层容器：JFrame、JApplet、JDialog、JWindow
（1）JFrame：带有标题行和控制按钮的独立窗口
（2）JApplet：用于创建小应用程序，被包含在浏览器窗口中 
（3）JDialog：用于常见对话框
（4）JWindow：不带有标题行和控制按钮的窗口
※在刚刚创建时，JFrame的大小为0，并且不可见。
4、每个顶层容器（JFrame、JApplet、JDialog及JWindow）都有一个内容窗格（ContentPane）。顶层容器中除了菜单之外的组件都放在这个内容窗格中。将
   组件放入内容窗格有两种方法：
（1）通过顶层容器的getContentPane()方法获得其默认的内容窗格（getContentPane()方法的返回类型为java.awt.Contenter，仍然为一容  
器），然后将组件添加到内容窗格中。
（2） 创建一个新的内容窗格代替顶层容器默认的内容窗格。方法：创建一个JPanel的实例（它是java.awt.Contenter的子类），然后将组件添加到JPanel实例中，再通过顶层容器的setContentPane()方法将JPanel实例设置为新的内容窗格。
※顶层容器（JFrame、JApplet、JDialog及JWindow）默认的内容窗格的布局管理器是BorderLayout，而JPanel默认的布局管理器是FlowLayout。
5、（1）setLayout()方法：用于改变容器的布局管理器。
  （2）add()方法：将组件添加到内容窗格。
  （3）setVisible(true)方法：使得顶层容器及其包含的组建对用户可见
6、布局管理器
  （1）FlowLayout布局管理器（定义在java.swt包中）
      （1.1）布局方式：将组件逐个地安放在容器中的一行上，一行放满后就
另起一个新行。
      （1.2）三种构造方法
            （1.2.1）public FlowLayout()
            （1.2.2）public FlowLayout(int align)
            （1.2.3）public FlowLayout(int align, int hgap, int vgap)
             ※align的可取值有三种形式：FlowLayout.LEFT（左对齐）、
FlowLayout.RIGHT（右对齐）、FlowLayout.CENTER（居中）
             ※在默认情况下，FlowLayout将组件居中放置在容器的某一行上。
  （2）BorderLayout布局管理器（定义在java.swt包中）
       （1.1）布局方式：将容器划分成东、南、西、北、中五个区域，分别代
表容器的右、下、左、上、中部，分别用常量BorderLayout.EAST、
BorderLayout.SOUTH、BorderLayout.WEST、BorderLayout.NORTH、
BorderLayout.CENTER表示。
       （1.2）两种构造方法
             （1.2.1）BorderLayout()：构造一个各部分间间距为0的
BorderLayout实例。
             （1.2.2）BorderLayout(int, int)：构造一个各部分间具有指定间距的BorderLayout实例。
              ※如果在add()方法中没有指定将组件放到哪个区域，那么它将
会默认地被放在Center区域。
              ※在容器的每个区域，只能加入一个组件，如果试图向某个区域中加入多个组件，那么只有最后一个组件有效。              
※对于EAST、SOUTH、WEST、NORTH这四个边界区域，如果其
中的某个区域没有使用，那么它的大小将变为0，此时CENTER
区域将会扩张并占据这个未使用的位置。如果四个边界区域都
没有使用，那么CENTER区域将会占据整个窗口。
  （3）GridLayout布局管理器（定义在java.swt包中）
       （1.1）布局方式：它是一种网格式的布局管理器，它将容器空间划分成若干行乘若干列的网格，组件一依次放入其中，每个组件占据一格。
       （1.2）三种构造方法
             （1.2.1）pbulic GridLayout()：创建只有一行的网格。
             （1.2.2）pbulic GridLayout(int rows, int cols)：创建一个rows行乘cols列的网格，rows和cols中的一个值可以为0，但是不能两个都为0。
             （1.2.3）pbulic GridLayout(int rows, int cols, int hgap, int vgap)
  （4）CardLayout布局管理器（定义在java.swt包中）
       （1.1）布局方式：它是一种卡片式的布局管理器，它将容器中的组件处理为一系列的卡片，每一时刻只显示其中的一张。
       （1.2）常用方法
（1.2.1） public void first(Container parent);
//显示第一张卡片
（1.2.2） public void next(Container parent);//显示下一张卡片，如果当前卡片是最后张，则显示第一张
（1.2.3） public void previous(Container parent);
//显示前一张卡片
（1.2.4） public void last(Container parent);//显示最后一张卡片
（1.2.5）public void show(Container parent,String name);
      //显示指定名称的组件
  （5）BoxLayout布局管理器（定义在javax.swing包中）
       （1.1）布局方式：它将容器中的组件按水平方向排成一行或按垂直方向排成一列。
       （1.2）构造方法：BoxLayout(Container target, int axis);
              其中，target指明是为那个容器设置此BoxLayout布局管理器；axis指明组件的排列方式。通常使用的是常量BoxLayout.X_AXIS或BoxLayout.Y_AXIS，分别表示按水平方式排列和按垂直方向排列。
        ※在javax.swing包中定义了一个专门使用BoxLayout的特殊容器Box
类，Box类中提供了创建Box实例的静态方法：
（1） public static Box createHorizontalBox()
//使用水平方向的BoxLayout
（2） public static Box createVerticalBox()
//使用垂直方向的BoxLayout
  ※也可以不使用布局管理器，而通过数值指定组件的位置和大小，这时首先需要调用容器的setLayout(null)将布局管理器设置为空，然后调用组件的setBounds()方法设置组件的位置和大小，setBounds()方法的格式为：
    SetBounds(int x, int y, int width, int heigh)，前两个int型参数设置组件的位置，后两个int型参数设置组件的宽度和高度。
7、事件处理
   （1）每类事件对应一个监听程序接口，它规定了接受并处理该类事件的方法的规范。
   （2）每个组件都有若干个形如addXXXListener(XXXListener)的方法，通过这类方法，可以为组件注册事件监听程序。
   （3）当事件发生时，单个事件的多个监听程序的调用顺序是不确定的。
   （4）常用事件类别及其接口表
   （5）接口及其适配器表
第八章
1、经常用到的按钮有4种
  （1）JButton（普通按钮）
  （2）JToggleButton（切换按钮）
  （3）JCheckBox（复选按钮）
  （4）JRadioButton（单选按钮）
2、（1）setText()：动态地改变按钮上的显示文本。
  （2）setEnabled()：改变按钮的状态（true可用、false不可用）。
  （3）setMnemonic()：为按钮设置快捷键。如：setMnemonic(KeyEvent.VK_S)，
它将S设为快捷键（按Ctrl+S）
  （4）setActionCommand()：为按钮设置一个命令名。
3、按钮
  （1）普通按钮JButton
构造方法主要有以下几种形式：
（1.1）JButton()：创建一个既没有显示文本也没有显示图标的按钮
      （1.2）JButton(Icon icon)：创建一个没有显示文本但有图标的按钮
      （1.3）JButton(String text)：创建一个显示文本但没有图标的按钮
      （1.4）JButton(String text, Icon icon)：创建一个既显示文本又显示图标的按钮
  （2）切换按钮JToggleButton
       构造方法主要有以下几种形式：
       (1.1)JToggleButton()：创建一个既没有显示文本，也没有图标的切换
按钮。
      （1.2）JToggleButton(Icon icon)：创建一个既没有显示文本，但有图标的切换按钮。
      （1.3）JToggleButton(Icon icon, boolean selected)：创建一个既没有显示文本，但有图标和指定初始状态的切换按钮。
      （1.4）JToggleButton(String text)：创建一个有显示文本，但没有图标的切换按钮。
      （1.5）JToggleButton(String text, boolean selected)：创建一个有显示文本和指定初始状态，但没有图标的切换按钮。
      （1.6）JToggleButton(String text, Icon icon)：创建一个既有显示文本又有图标的切换按钮。
      （1.7）JToggleButton(String text, Icon icon, boolean selected)：创建一个既有显示文本又有图标和指定初始状态的切换按钮。
       ※（1）构造方法中如果没有指定按钮的初始状态，则默认状态下处于未选中状态。
         （2）在JToggleButton类中定义了一个isSelected()方法，当返回值为真（true）时表示处于选中状态，而返回值为假（false）则表示处于未选中状态。
         （3）当多个按钮被添加到同一个按钮组（ButtonGroup）之后，只能有一个按钮处于被选中状态。
  （3）复选按钮JCheckBox ，单选按钮JRadioButton都是JToggleButton的
子类，构造方法的格式与JToggleButton相同，它们也都具有选中和未
选中两种状态。
4、标签
   6种构造方法
  （1.1）JLable()：构造一个既不显示文本信息也不显示图标的空标签。
  （1.2）JLable(Icon image)：构造一个显示图标的标签。
  （1.3）JLable(String text)：构造一个显示文本信息的标签。
（1.4）JLable(Icon image, int horizontalAlignment)：构造一个显示图标的标签，水平对齐方式有int型参数指定。
（1.5）JLable(String text, int horizontalAlignment)：构造一个显示文本信息的标签，水平对齐方式有int型参数指定。
（1.6）JLable(String text, Icon image, int horizontalAlignment)：构造一个同时显示文本信息和图标的标签，水平对齐方式有int型参数指定。
 ※（1）表示水平对齐方式的int型参数horizontalAlignment的取值可为JLable.LEFT、JLable.RIGHT和JLable.CENTER等常量，分别表示左对齐、右对齐和居中。
  （2）默认情况下，标签内容在垂直方向上居中显示。
  （3）setHorozontalAlignment(int alignment)方法和
setVerticalAlignment(int alignment)方法可以改变标签内容的对齐方式。在setHorozontalAlignment(int alignment)中，int型参数取值可为JLable.LEFT、JLable.RIGHT和JLable.CENTER等常量；在setVerticalAlignment(int alignment)中，int型参数取值可为JLable.TOP、JLable.BOTTOM和JLable.CENTER等常量
（4）在既包含文本信息又包含图标的标签上，默认情况下，文本的信息显示在图标的右侧，可以通过
setHorizontalTextPositon(int textPosition)和
setVerticalTextPosition(int textPosition)方法指定文本
信息和图标的相对位置。
（5）在程序中，可以使用setText(String text)方法修改显示在标
签上的文本信息。也可以使用setIcon(Icon icon)方法修改标
签上的图标，但是在程序运行过程中，用户不能对标签内容进
行修改。
5、组合框（JComboBox）：它是一个下拉式菜单，有两种形式（不可编辑的和可编辑的）。对于不可编辑的JComboBox，用户只能在现有的选项列表中进行选择；对于可编辑的JComboBox，用户既可以在现有选项中选择，也可以输入新的内容。
  （1）常用构造方法
      （1.1）JComboBox()：创建一个没有任何可选项的组合框。
      （1.2）JComboBox(Object[] items)：根据Object数组创建组合框，Object数组的元素即为组合框中的可选项。
  （2）相关方法
       （1.1）setEditable()：设置组合框为可编辑的（true）还是不可编辑的（false）。
       （1.2）public void addItem(Object anObject)：在末尾位置添加新的可选项。
       （1.3）public void insertItemAt(Object anObject, int index)：在index指定的位置添加新的可选项anObject。
       （1.4）public void removeAllItems()：删除所有可选项。
       （1.5）public void removeItem(Object anObject)：删除由anObject指定的可选项。
       （1.6）public void removeItemAt(int anIndex)：删除指定位置（由anIndex指定）的可选项。
6、列表（JList）：可提供用户进行选择的一系列可选项。
  （1）四种构造方法
      （1.1）JList()：构造一个空列表。
      （1.2）JList(ListModel dataModel)：构造一个列表，列表的可选项由ListModel型参数dataModel指定。
      （1.3）JList(Object[] listData)：构造一个列表，列表的可选项由对象数组listData指定。
      （1.4）JList(Vector listData)：构造一个列表，列表的可选项由Vector型参数ListData指定。
       ※（1）当根据数组或Vector创建列表时，构造方法将自动地创建一个默认的、实现了ListModel接口的对象，该对象是不可变的。
         （2）如果希望列表的可选项是动态改变的，则需要在创建列表时提供一个ListModel对象。
  （2）相关方法
      （1.1）setModel(ListModel model)：设置新的ListModel。
      （1.2）JScrollPane()：将列表放入其中，可为其提供滚动功能。
      （1.3）列表既支持单项选择也支持多项选择，可以使用JList中定义的setSelectionMode(int selectionMode)方法对列表的选择模式进行设置，其中int型参数selectionMode可以使以下常量：
             （1.3.1）ListSelectionMode.SINGLE_SELECTION：只能进行单项选择。
             （1.3.2）ListSelectionMode.SINGLE_INTERVAL_SELECTION：可多项选择，但多个选项必须是连续的。
             （1.3.3）ListSelectionMode.MULTIPLE_INTERVAL_SELECTION：多项选择，多个选项可以是间断的，这是选择模式的默认值。
             （1.3.4）当用户在列表中进行选择时，将引发ListSelectionEvent事件，在JList中提供了addListSelectionListener(ListSelectionListener listener)方法，用于注册对应的事件监听程序。在ListSelectionListener接口中，只包含一个方法：
                      public void valueChanged(ListSelectionEvent e)。
7、文本组建：用于显示信息和提供用户输入功能。在Swing中提供了文本域
（JTextField）、口令输入域（JPasswordField）、文本区（JTextArea）等多
个文本组件，这些文本组件都有一个共同的基类JTextComponent。
在JTextComponent类中定义的主要方法有：
（1） getSelectedText()：从文本组建中提取被选中的文本内容。
（2） getText()：从文本组件中提取所有文本内容。
（3） getText(int offs, int len)：从文本组件中提取指定范围的文本内容。
（4） select(int selectionStart,int selectionEnd)：在文本组件中选中指定范围的文本内容。
（5） selectAll()：在文本组件中选中所有文本内容。
（6） setEditable(Boolean b)：设置为可编辑或不可编辑状态。
（7） setText(String t)：设置文本组件中的文本内容。
（8） setDocument(Document doc)：设置文本组件的文档。
（9） copy():复制选中的文本到剪贴板。
（10） cut()：剪切选中的文本到剪贴板。
（11） paste()：将剪贴板的内容粘贴到当前位置。
   ※文本组件使用文档（Document）保存组件中的文本内容。
8、文本域（JTextField）：它是一个单行的文本输入框，可用于输入少量文本，
它有5种构造方法：
（1） JTextField()：构造一个空文本域。
（2） JTextField(int columns)：构造一个具有指定列数的空文本域，int型参数指定文本域的列数。
（3） JTextField(String text)：构造一个显示指定初始字符串的文本域，String型参数指定要显示的初始字符串。
（4） JTextField(Sting text,int columns)：构造一个具有指定列数、并显示指定初始字符串的文本域，String型参数指定要显示的初始字符串，int型参数指定文本域的列数。
（5） JTextField(Document doc, Sting text,int columns)：构造一个使用指定文档、具有指定列数、并显示指定初始字符串的文本域。Document型参数doc可以为null，此时一个默认的PlainDocument文档对象将会被创建。在其它构造方法中，由于未指定文本域所使用的文档，也会创建一个默认的PlainDocument文档对象。
   ※在构造函数中所指定的列数是一个希望的值，由于组件的大小和位置通常是由布局管理器决定的，因此，指定的这些数据很有可能被忽略。
 9、文本区（JTextArea）：它是一个多行多列的文本输入框。
   （1）常用构造方法
       （1.1）JTextArea（）：构造一个空文本域。
       （1.2）JTextArea（String text）：构造一个显示指定初始字符串的文
本区，String型参数指定要显示的初始字符串。
       （1.3）JTextArea（int rows, int columns）：构造一个具有指定行数和列数的空文本区，rows和columns分别对应行数和列数。
       （1.4）JTextArea（String text, int rows, int columns）：构造一个具有指定行数和列数，并显示指定初始字符串的文本区。
       （1.5）JTextArea（Document doc）：构造一个使用指定文档的文本区。
       （1.6）JTextArea（Document doc，String text, int rows, int columns）
             : 构造一个使用指定文档, 具有指定行数和列数，并显示指定初始字符串的文本区。
        ※与文本域类似，构造方法中指定的行数和列数只是希望的数值，文
本区的大小仍然是由布局管理器决定的。如果构造方法中的Document
参数为null，或者使用不带Document参数的构造方法，默认情况下，
文本区也将会使用一个PlainDocument型文档。文本区本身不带滚动
条，一般将其放入JScrollPane中。
  （2）相关操作方法
       （1.1）append(String str)：将指定文本追加到文本区。
       （1.2）insert(String str, int pos)：将制定文本插入文本区的特定位置。
       （1.3）replaceRange(String str, int start, int end)：用指定文本替换文本区中的部分内容。
        ※当需要识别用户“输入完成”时，通常要在文本区旁边放置一个Apply
或Commit之类的按钮。
10、菜单组件
   （1）菜单栏：它是窗口中的主菜单，用来包容一组菜单。它只有一种构造方法JMenuBar()。JFrame、JApplet、JDialog等类中定义了setJMenuBar(JMenuBar menu)方法，可以把菜单栏放到窗口的上方。
   （2）菜单：最基本的下拉菜单，用来包容一组菜单项或子菜单。菜单的构
造方法如下：public Menu(String lable)。其中String型参数指定了菜单上的文本。菜单可以被加入菜单栏或者另一个菜单中。
   （3）菜单项常用构造方法：
       （1）JMenuItem(Icon icon)：构造一个只显示图标的菜单项，图标由Icon型参数icon指定。
       （2）JMenuItem(String text)：构造一个只显示文本的菜单项，文本由String型参数text指定。      
       （3）JMenuItem（String text, Icon icon）：构造一个同时显示文本和图标的菜单项。
       （4）JMenuItem（String text, int mnemonic）：构造一个显示文本并且有快捷键的菜单项 ，快捷键由int型参数mnemonic指定。
        ※在Menu类中定义了addSeparator()和insertSeparator(int index)
方法，通过这些方法，可以在某个菜单的各个菜单项间加入分隔线。
   （4）复选菜单项和单选菜单项：在复选菜单项前面有一个小方框，在单选菜单项前面有一个小圆圈。
       （1.1）常用复选菜单项构造方法：
             （1.1.1）JCheckBoxMenuItem(Icon icon)
              (1.1.2) JCheckBoxMenuItem(String text) 
              (1.1.3) JCheckBoxMenuItem(String text, boolean b)
              (1.1.4) JCheckBoxMenuItem(String text, Icon icon)
              (1.1.5) JCheckBoxMenuItem(String text, Icon icon, 
boolean b)
        (1.2) 常用单选菜单项构造方法：
             （1.2.1）JRadioButtonMenuItem(Icon icon)
             （1.2.2）JRadioButtonMenuItem(Icon icon, 
Boolean selected)
             （1.2.3）JRadioButtonMenuItem(String text)
             （1.2.4）JRadioButtonMenuItem(String text, 
Boolean selected)
             （1.2.5）JRadioButtonMenuItem(String text, Icon icon)
             （1.2.6）JRadioButtonMenuItem(String text , Icon icon, 
Boolean selected)
（6） 弹出式菜单：它是一种比较特殊的独立菜单，可以根据需要显示在指定的位置。
两种构造方法
（1.1.1）public JPopularMenu()：构造一个没有名称的弹出式菜单。
（1.1.2）public JPopularMenu(String lable)：构造一个指定名称的
弹出式菜单。
※（1）在弹出式菜单中可以加入菜单或菜单项。
  （2）在显示弹出式菜单时，可以调用show()方法：
        Public void show(Component invoker, int x, int y)。在这个方法中需要有一个组件作参数，该组件的位置将作为显示弹出式菜单的参考原点。
11、对话框：它是与框架类似的可移动窗口，它与框架的区别在于，对话框具有较少的修饰，并且能够被设置为“模式”窗口，即在该窗口被关闭之前，其它窗口无法接收任何形式的输入。
   （1）相关构造方法
       （1.1）JDialog(Frame owner)：构造一个没有标题的非模式对话框，Frame型参数指定了对话框的拥有者。
       （1.2）JDialog(Frame owner, Boolean modal)：构造一个没有标题的对话框，boolean型参数modal指定对话框是否为模式窗口。
       （1.3）JDialog(Frame owner, String title)：构造一个有标题的非模式对话框。
       （1.4）JDialog(Frame owner, String title, Boolean modal)：构造一个有标题的对话框。
   （2）注意
        （1.1）当对话框的拥有者被清除时，对话框也会被清除。对话框在显示时，如果其拥有者被最小化，对话框也将变为不可见，当其拥有者再次显示时，对话框会随之变为可见。
        （1.2）刚刚创建的对话框是不可见的，需要调用setVisible(true)方法才能将其显示出来。 
12、标准对话框：JDialog通常用于创建自定义的对话框。在Swing类中还提供
了用于显示标准对话框（JOptionPane）的JOptionPane类。在JOptionPane
类中定义了多个showXxxDialog形式的静态方法，分为四类：
（1） showConfirmDialog：确认对话框，显示问题，要求用户确认（yes/no/cancel）。
（2） showInputDialog：输入对话框，提示用户输入。
（3） showMessageDialog：信息对话框，显示信息，告知用户发生了什么情况。
（4） showOptionDialog：选项对话框，显示选项，要求用户选择。
 ※showMessageDialog有3个同名方法：
     （1）showMessageDialog(Component parentComponent, Object message)
     （2）showMessageDialog(Component parentComponent, Object message, String title, int messageType)
     （3）showMessageDialog(Component parentComponent, Object message, String title, int messageType, Icon icon)
      ※（1）Component parentComponent
             对话框的父窗口对象，其屏幕坐标将决定对话框的显示位置；此参数也可以为null，表示采用默认的Frame作为父窗口，此时对话框将设置在屏幕的正中。
        （2）String title
             对话框的标题
        （3）Object message
             显示在对话框中的描述信息。该参数通常是一个String对象，但也可以是一个图标、一个组件或者一个对象组件。
        （4）int messageType
             对话框多传递的信息参数。可以为以下常量：
（1.1） ERROR_MESSAGE
（1.2） INFORMATION_MESSAGE
（1.3） WARNING_MESSAGE
（1.4） QUESTION_MESSAGE
（1.5） PLAIN_MESSAGE
※除了PLAIN_MESSAGE之外，其它每种类型都对应一个默认图标。
        （5）int optionType
             对话框上按钮的类型，可以为以下常量：
（1.1） DEFAULT_OPTION
（1.2） YES_NO_OPTION
（1.3） YES_NO_CANCEL_OPTION
（1.4） OK_CANCEL_OPTION
        （6）Object[] option
             对话框上的选项。在输入对话框中，通常一组合框形式显示。在选项对话框中，则指按钮的选项类型。该参数通常是一个String数组，但也可以是图标或数组组件。
        （7）Icon icon
             对话框上显示的装饰性图标，如果没有指定，则根据messageType参数显示默认图标。
        （8）Object initialValue
             初始选项或输入值。
13、文件对话框：专门用于对文件（或目录）进行浏览和选择的对话框，有3
种常用构造方法：
（1） JFileChooser()：根据用户的默认目录创建文件对话框。
（2） JFileChooser(File currentDirectory)：根据File型参数指定的目录创建文件对话框。
（3） JFileChooser(String currentDirectoryPath)：根据String型参数指定的目录创建文件对话框。
※刚刚创建的文件对话框是不可见的，可以调用以下方法将其显示出来：
  （1）showOpenDialog(Component parent)：显示一个“打开”文件对
话框。
  （2）showSaveDialog(Component parent)：显示“保存”文件对话框。
  （3）showDialog(Component parent, String approveButtonText)：
显示一个自定义的文件对话框，对话框的标题和按钮上的文件由
String型参数指定。Component型参数指定文件对话框的“父组
件”，将决定对话框的显示位置；此参数也可以为null，此时对话
框将设置在屏幕的正中。
14、控制组件外观之颜色
    可以使用下面的两个方法（在JComponent中定义）设置组件的前景色和背景色：
（1） public void setForeground(Color c)：设置前景色。
（2） public void setBackground(Color c)：设置背景色。
   ※在这两个方法中都需要java.awt.Color类的一个实例作参数，可以使用Color 类中预定义的颜色常量。也可以自己创建新的颜色，如：
      
 
      


15、控制组件外观之字体：可以使用setFont(Font f)方法对组件中文本的字体进行设置，这个方法需要java.awt.Font类的一个实例作参数。在java中没有预定义的字体常量。
自己创建Font对象：Font f = new Font(字体名称,字体风格,字体大小)
字体风格可以有以下几种常量之一：
（1） Font.BOLD
（2） Font.ITALIC
（3） Font.PLAIN
（4） Font.BOLD+ Font.ITALIC
16、控制组件外观之绘图
（1）java.awt.Component类中定义了paint(Graphics g)方法，当组件被显示出来时，该方法被调用。repaint()方法，每当需要重绘组建时，该方法被调用。
（2）javax.swing.JComponent是java.awt.Component的子类。
（2.1）paintComponent (Graphics g)：绘制组件。
（2.2）paintBorder(Graphics g)：绘制组件的边框。
（2.3）paintChildren (Graphics g)：绘制组件中子组件。
    （3）在Graphics中定义的绘图方法：
         （3.1）drawArc(int x, int y, int width, int height, int 
startAngle, int arcAngle)
         （3.1）drawLine(int x1, int y1, int x2, int y2)
         （3.3）drawOval(int x, int y, int width, int height)
         （3.4）drawPolygon(int []xPoint, int []yPoint,int nPoint)
         （3.5）drawRect(int x, int y, int width, int height)
         （3.6）drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
         （3.7）drawString(String str, int x, int y)
         （3.8）fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)
         （3.9）fillOval(int x, int y, int width, int height)
         （3.10）fillPolygon(int []xPoint, int []yPoint,int nPoint)
         （3.11）fillRect(int x, int y, int width, int height)
         （3.12）fill RoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
第九章
1、要运行Applet程序，需要一个对应的HTML文档的配合。
2、几乎所有的浏览器都禁止Applet程序的下述行为。
   （2.1）运行过程中调用执行另一个程序；
   （2.2）所有文件的I/O操作；
   （2.3）调用本机方法；
   （2.4）企图打开提供该Applet的主机以外的某个套接口。
3、要编写Applet，必须以下面的形式创建一个类：
import java.applet.*;
public class AppletName extends Applet{
……
}
※这个类必须是public类型。
4、Applet也是Panel类的子类。默认情况下，Applet使用FlowLayout布局管理器。
5、Applet程序是从构造方法开始执行的。在Applet中，没有任何一个方法在程序的整个生命周期内自始至终一直运行。
6、<applet>标记的语法：
   <applet
        Code = appletFile.class
        Width = pixels   height = pixels
        [codebase = codebaseURL]
        [alt = alternateText]
        [name = appletInstanceName]
        [align = alignment]
        [vspace = pixels]   [hspace = pixels]
>[<param name = appletAttribute1  value = value>]
  [<param name = appletAttribute2 value = value>]
   ……
</applet>
※在默认情况下，浏览器到HTML文件所在的服务器目录中查找该Applet文件。
7、 Applet的显示：Applet中有3个与显示相关的方法，即paint()、update()和repaint()。通常是在图形环境下使用Applet的paint()方法绘制要显示的内容。Applet的显示和刷新由一个独立线程控制，称为AWT线程。
8、Applet的init()、start()、stop()和destroy()：
   （1）当Applet对象被创建并初次装入支持Java的浏览器时，init()方法会被调用。init()方法通常用于完成Applet的数据初始化操作。
   （2）init()方法执行结束后，start()方法紧接着被调用。当包含Applet的浏览器窗口最小化之后再次回复显示，或者从浏览器的另一个窗口切换回包含Applet的窗口时，start()方法会被调用。
（3）离开Applet所在页面时调用stop()方法。stop()方法与start()方法是对应的。
（4）当浏览器终止此Applet时，调用destroy()方法。浏览器关闭时也会自动调用。
9、用appletviewer运行Applet时，它需要一个HTML文件名作命令行参数，例如：$  appletviewer HelloWorld.html
10、目前Java核心类包支持gif和jpeg两种格式的图像（但在扩展包中可以支持更多的图像格式）。
11、Applet类中有两个方法可以返回URL对象：
    （1）getDocumentBase()：返回当前Applet所在的HTML文件的URL。
    （2）getCodeBase()：返回当前Applet所在目录的URL。
12、在Applet中播放声音：
    （1）使用java.applet.Applet类的getAudioClip()方法可以获得AudioClip声音对象，该方法有两种形式：
          (1.1)public AudioClip getAudioClip(URL url)
          (1.2)public AudioClip getAudioClip(URL url, String name)
    （2）播放AudioClip声音对象可以使用AudioClip中的play()方法，例如：
        sound.play();
        也可以使用AudioClip中的loop()方法，该方法循环播放声音对象：
        sound.loop();
（3）使用AudioClip中的stop()方法可以停止声音对象的播放：
Sound.stop();
第十章






第十一章
1、进程是程序在处理机中的一次运行。线程是进程执行过程中产生的多条执行
线索，是比进程单位更小的执行单位，它没有入口，也没有出口。
2、在Java中，线程可以认为是由三部分组成的：虚拟CPU、执行的代码以及处理的数据。
3、多线程的优势体现在以下几个方面：
   （1）多线程编程简单，效率高；
   （2）适合于开发服务程序；、
   （3）适合于开发有多种交互接口的程序；
   （4）适合于有人机交互又有计算量的程序。
4、当生成一个Thread类的对象后，就产生了一个线程。方法run()称为线程体。
5、线程一共有四种状态：新建（new）、可运行状态（runnable）、死亡（dead）及堵塞（blocked）。
  （1）新建：已有了相应的内存空间以及其他资源。如：
              Thread thread = new Thread(“test”);
  （2）可运行状态：调用线程的start()方法可使线程处于“可运行”状态。如：thread.start();
  （3）死亡：死亡有两个原因，一是run()方法中最后一个语句执行完毕；二是当线程处于“可运行”状态，调用stop()方法结束了线程的运行。如thread.stop();
  （4）阻塞：一个正在执行的线程因特殊原因被暂停执行。如：sleep()和wait().
  （5）中断线程：interrupt()不仅可中断正在运行的线程，而且也能中断处于blocked状态的线程。
6、创建线程
   类Thread的构造方法如下：
   public Thread(ThreadGroup group, Runnable target, String name);
其中，group指明了线程所属的线程组；target是线程体run()方法所在的
对象 ；name是线程的名称。
创建线程的方法：
（1） 继承Thread类
用Thread类的子类创建线程的过程包括以下三步：
（1.1） 从Thread类派生出一个子类，在类中一定要实现run()；
class Lefthand extends Thread{
public void run(){
……
}
}
（1.2） 然后用该类创建一个对象；
Lefthand left = new Lefthand();
（1.3） 用start()方法启动线程。
left.start();
（2） 实现Runnalbe接口
Runnable接口中只定义了一个方法就是run()方法。
7、线程的启动
   （1）yield()：强制终止线程的执行。
   （2）isAlive()：测试当前线程是否在活动。
   （3）sleep(int millsecond)：使线程休眠一段时间，时间长短由参数所决定。
   （4）void Wait()：使线程处于等待状态。
8、活动状态不意味着这个线程正在执行，而只说明这个线程已被启动。
9、暂停一个线程也称为挂起。
第十二章