Java期末复习基础知识整理（有点长）

平台无关：

在一个计算机上编译得到的字节码文件可以复制到任何一个安装了Java运行环境的计算机上直接使用。字节码由Java虚拟机负责解释运行，即Java虚拟机负责将字节码翻译成本地计算机的机器码，并将机器码交给本地的操作系统来运行。

Java程序的开发步骤 ：

1.编写源文件:扩展名必须是.java。

2.编译Java源程序:用Java编译器（javac.exe）编译源文件，得到字节码文件。

3.运行Java程序:使用Java解释器（java.exe）来解释执行字节码文件。  

保存源文件：

如果源文件中有多个类，那么只能有一个类是public类；如果有一个类是public类，那么源文件的名字必须与这个类的名字完全相同，扩展名是java；如果源文件没有public类，那么源文件的名字只要和某个类的名字相同，并且扩展名是java就可以了

标识符：

用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符，简单地说，标识符就是一个名字 .

标识符由字母、下划线、美元符号和数字组成，长度不受限制。

标识符的第一个字符不能是数字字符。

标识符不能是关键字（关键字见下面的2.1.3节）

标识符不能是true、false和null（尽管true、false和null不是关键字）

这8种基本数据类型习惯上可分为以下四大类型：

  逻辑类型：boolean

  整数类型：byte、short、int、long

  字符类型：char

  浮点类型：float、double

1．int 型

          对于int型变量，内存分配给4个字节（byte），占32位。

2．byte 型  

        常量：Java中不存在byte型常量的表示法，但可以把一定范围内的int型常量

          赋值给byte型变量。  

        变量：使用关键字byte来声明byte 型变量  

          例如： byte x= -12,tom=28,漂亮=98;

          对于byte型内存分配给1个字节，占8位 。

3 ．short 型

        常量：和byte型类似，Java中也不存在short型常量的表示法，但可以把一定

          范围内的int型常量赋值给short型变量。

        变量：使用关键字short来声明short型变量

          例如： short x=12,y=1234;

          对于short型变量，内存分配给2个字节，占16位.

4. long 型

        常量：long型常量用后缀L来表示，例如108L(十进制)、07123L(八进制)、

          0x3ABCL(十六进制) 。

        变量：使用关键字long来声明long型变量，

          例如： long width=12L,height=2005L,length;

          对于long型变量，内存分配给8个字节，占64位。

简单数据类型的级别与类型转换运算：

Java中数据的基本类型（不包括逻辑类型）按精度从“低”到“高”排列：

byte  short  char  int  long  float  double

★当把级别低的变量的值赋给级别高的变量时，系统自动完成数据类型的转换

★当把级别高的变量的值赋给级别低的变量时，必须使用显示类型转换运算。显示转换的格式：（类型名）要转换的值;

  例如

    int x=(int)34.89;

★当把一个int型常量赋值给一个byte和short型变量时，不可以超出这些变量的取值范围，否则必须进行类型转换运算；例如，常量128的属于int型常量，超出byte变量的取值范围，如果赋值给byte型变量，必须进行byte类型转换运算（将导致精度的损失），如下所示：

     byte a=(byte)128;

输入基本型数据 ：

  ◆可以使用Scanner类创建一个对象：

           Scanner reader=new Scanner(System.in);

  ◆reader对象调用下列方法，读取用户在命令行（例如，MS-DOS窗口）输入的各种基本类型数据：

 nextBoolean()、 nextByte()、 nextShort()、 nextInt()   

 nextLong()、nextFloat()、nextDouble()

输出基本型数据：

JDK1.5新增了和C语言中printf函数类似的输出数据的方法，格式如下：

     System.out.printf("格式控制部分"，表达式1，表达式2，…表达式n)

格式控制部分由格式控制符号：%d、%c、%f、%s和普通的字符组成，普通字符原样输出。格式符号用来输出表达式的值。

输出数据时也可以控制数据在命令行的位置，例如：%md输出的int型数据占m列；%m.nf输出的浮点型数据占m列，小数点保留n位。例如：System.out.printf("%d,%f",12, 23.78);

数组 ：

1 声明数组：

声明一维数组有下列两种格式：

数组的元素类型 数组名[];

数组的元素类型 [] 数组名;

例如：

float boy[];

char [] cat;

2 为数组分配元素 :

为数组分配元素的格式如下：

数组名 = new 数组元素的类型[数组元素的个数];

例如： boy = new float[4];

3数组的引用:

数组属于引用型变量，两个相同类型的数组如果具有相同的引用，它们就有完全相同的元素

 

instanceof 运算符是二目运算符，左面的操作元是一个对象；右面是一个类。当左面的对象是右面的类或子类创建的对象时，该运算符运算的结果是true ，否则是false。

Java里的语句可分为以下六种：

1．方法调用语句。如：System.out.println(" Hello");

2．表达式语句   表示式尾加上分号。比如赋值语句：x=23;

3．复合语句

  可以用{  }把一些语句括起来构成复合语句，如：

       {   z=123+x;

           System.out.println("How are you");

        }

4．空语句。 一个分号也是一条语句，称做空语句。

5．控制语句。控制语句分为条件分支语句、开关语句和循环语句。

6．package语句和 import语句。它们和类、对象有关

for语句与数组 ：

 JDK1.5后,对for语句的功能给予扩充、增强，以便更好地遍历数组。语法格式如下：

for(声明循环变量：数组的名字) {

…

}

其中，声明的循环变量的类型必须和数组的类型相同。这种形式的for语句类似自然语言中的“for each”语句，为了便于理解上述for语句，可以将这种形式的for语句中翻译成“对于循环变量依次取数组的每一个元素的值”。

 类体：

◆类体的内容由两部分构：一部分是变量的声明，用来刻画属性；另一部分是方法的定义，用来刻画行为功能

类体中变量声明部分所声明的变量被称作成员变量和类的成员变量不同的是，局部变量只在方法内有效，而且与其声明的位置有关如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，即该成员变量在这个方法内暂时失效。如果想在该方法中使用被隐藏的成员变量，必须使用关键字this（在4.9节this关键字）

局部变量没有默认值：

成员变量有默认值（见后面的4.3节），但局部变量没有默认值，因此在使用局部变量之前，必须保证局部变量有具体的值

   对成员变量的操作只能放在方法中，方法可以对成员变量和该方法体中声明的局部变量进行操作。在声明成员变量时可以同时赋予初值，但是不可以在类体中有单独的赋值语句（不可以有变量的声明和方法的定义以外的其它语句）

构造方法与对象的创建 ：

   类是面向对象语言中最重要的一种数据类型，那么就可以用它来声明变量。在面向对象语言中，用类声明的变量被称作对象。和基本数据类型不同，在用类声明对象后，还必须要创建对象，即为声明的对象分配变量(确定对象所具有的属性)，当使用一个类创建一个对象时，也称给出了这个类的一个实例。通俗的讲，类是创建对象的“模板”，没有类就没有对象。构造方法和对象的创建密切相关

构造方法 ： 构造方法是一种特殊方法，它的名字必须与它所在的类的名字完全相同，而且没有类型。允许一个类中编写若干个构造方法，但必须保证他们的参数不同，即参数的个数不同，或者是参数的类型不同。

创建对象 ：    

创建一个对象包括对象的声明和为对象分配变量两个步骤。

1. 对象的声明
2. 为声明的对象分配变量

使用对象 ：

1．对象操作自己的变量（体现对象的属性）

   通过使用运算符“.” 对象操作自己的变量（对象的属性）

2．对象调用类中的方法（体现对象的行为）

   对象创建之后，可以使用点运算符“.”调用创建它的类中的方法，从而产生一定的行为（功能）.

3． 体现封装

    当对象调用方法时，方法中出现的成员变量就是指分配给该对象的变量。在讲述类的时候讲过：类中的方法可以操作成员变量。当对象调用方法时，方法中出现的成员变量就是指分配给该对象的变量。

 对象的引用和实体 ：

当用类创建一个对象时，类中的成员变量在分配内存空间，这些内存空间称作该对象的实体或对象的变量，而对象中存放着引用。一个类创建的两个对象，如果具有相同的引用，那么就具有完全相同的实体。

参数传值：

 方法中最重要的部分之一就是方法的参数，参数属于局部变量，当对象调用方法时，参数被分配内存空间，并要求调用者向参数专递值，即方法被调用时，参数变量必须有具体的值。

 传值机制 ：

 在Java中，方法的所有参数都是“传值”的，也就是说，方法中参数变量的值是调用者指定的值的拷贝。例如，如果向方法的int型参数x传递一个int值，那么参数x得到的值是传递的值的拷贝。

基本数据类型参数的传值 ：

对于基本数据类型的参数，向该参数传递的值的级别不可以高于该参数的级别 。

引用类型参数的传值：

当参数是引用类型时，“传值”传递的是变量中存放的“引用”，而不是变量所引用的实体

对象的组合  :

一个类可以把对象作为自己的成员变量，如果用这样的类创建对象，那么该对象中就会有其它对象，也就是说该对象将其他对象作为自己的组成部分，或者说该对象是由几个对象组合而成。

组合与复用  :

如果一个对象a组合了对象b，那么对象a就可以委托对象b调用其方法，即对象a以组合的方式复用对象b的方法。例如，圆锥对象在计算体积时，首先委托圆锥的底（一个Circle对象）bottom调用getArea()方法计算底的面积，然后圆锥对象再计算出自身的体积

实例变量和类变量的声明:

在声明成员变量时，用关键字static给予修饰的称作类变量，否则称作实例变量（类变量也称为static变量，静态变量）。

实例变量和类变量的区别:

1．不同对象的实例变量互不相同

2．所有对象共享类变量

3．通过类名直接访问类变量

实例方法和类方法的定义:

类中的方法也可分为实例方法和类方法。方法声明时，方法类型前面不加关键字static修饰的是实例方法、加static关键字修饰的是类方法(静态方法)。

实例方法和类方法的区别 :

1．对象调用实例方法

   当对象调用实例方法时，该方法中出现的实例变量就是分配给该对象的实例变量；该方法中出现的类变量也是分配给该对象的变量，只不过这个变量和所有的其他对象共享而已。

2．类名调用类方法

从而类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。和实例方法不同的是，类方法不可以操作实例变量，这是因为在类创建对象之前，实例成员变量还没有分配内存。

方法重载的语法规则 :

方法重载的意思是：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同

this关键字 :

this是Java的一个关键字，表示某个对象。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象.当this关键字出现实例方法中时，this就代表正在调用该方法的当前对象。

在构造方法中使用this  :

this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。

在实例方法中使用this  :

实例方法必须只能通过对象来调用，不能用类名来调用。当this关键字出现实例方法中时，代表正在调用该方法的当前对象。

实例方法可以操作类的成员变量，当实例成员变量在实例方法中出现时，默认的格式是：this.成员变量;

当static成员变量在实例方法中出现时，默认的格式是：

     类名.成员变量;

包 :

包是Java语言中有效地管理类的一个机制。

包名的目的是有效的区分名字相同的类。不同Java源文件中两个类名字相同时，它们可以通过隶属不同的包来相互区分。

包语句 :

通过关键字package声明包语句。

       package语句作为Java源文件的第一条语句， 为该源文件中声明的类指定包名。  import 语句 :

  一个类可能需要另一个类声明的对象作为自己的成员或方法中的局部变量，如果这两个类在同一个包中，当然没有问题。

   如果一个类想要使用的那个类和它不在一个包中，要使用import语句完成使命。

引入自定义包中的类 :

用户程序也可以使用import语句引入非类库中有包名的类，如：

   import tom.jiafei.*;

访问权限 :

  当用一个类创建了一个对象之后，该对象可以通过“.”运算符操作自己的变量、使用类中的方法，但对象操作自己的变量和使用类中的方法是有一定限制的。

何谓访问权限 :

   所谓访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符使用类中的方法。访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法。

私有变量和私有方法 :

用关键字private修饰的成员变量和方法称为私有变量和私有方法。

对于私有成员变量或方法，只有在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法。

某个类在另外一个类中创建对象后，如果不希该对象直接访问自己的变量，即通过“.”运算符来操作自己的成员变量，就应当将该成员变量访问权限设置为private。面向对象编程提倡对象应当调用方法来改变自己的属性，类应当提供操作数据的方法，这些方法可以经过精心的设计，使得对数据的操作更加合理

共有变量和共有方法 :

用public修饰的成员变量和方法被称为共有变量和共有方法 。

我们在任何一个类中用类Tom 创建了一个对象后，该对象能访问自己的public变量和类中的public方法（也可以通过类名来操作成员变量、方法） 。

友好变量和友好方法:

当在另外一个类中用类Tom 创建了一个对象后，如果这个类与Tom类在同一个包中，那么该对象能访问自己的友好变量和友好方法。 在任何一个与Tom同一包中的类中，也可以通过Tom类的类名访问Tom类的类友好成员变量和类友好方法。

受保护的成员变量和方法:

用protected修饰的成员变量和方法被称为受保护的成员变量和受保护的方法

public类与友好类 :

类声明时，如果在关键字class前面加上public关键字，就称这样的类是一个public 类 。

可以在任何另外一个类中,使用public类创建对象。

如果一个类不加public修饰，这样的类被称作友好类。

在另外一个类中使用友好类创建对象时，要保证它们是在同一包中。

基本类型的类封装:

Java提供了基本数据类型相关的类，实现了对基本数据类型的封装。这些类分别是：Byte、Integer、Short、Long、Float、Double和Character类。这些类在java.lang包中。

对象数组:

如果程序需要某个类的若干个对象，比如Student类的10个对象，显然如下声明10个Student对象是不可取的：

Student stu1,stu2, stu3,stu4,stu5,stu6,stu7,stu8, stu9,stu10;

正确的做法是使用对象数组，即数组的元素是对象，例如：

       Student [] stu;

       stu = new Student[10];

需要注意的是，上述代码仅仅定义了数组stu有10个元素，并且每个元素都是一个Student类型的对象，但这些对象目前都是空对象，因此在使用数组stu中的对象之前，应当创建数组所包含的对象，例如：            

stu[0] = new Student();  

反编译和文档生成器 :

◆反编译器javap.exe可以将字节码反编译为源码，以便查看源码类中的public方法名字和public成员变量的名字，例如：

    javap java.awt.Button

使用javadoc.exe可以制做源文件类结构的html格式文档

jar文件 :

可以使用jar.exe命令把一些类的字节码文件压缩成一个jar文件，然后将这个jar文件存放到Java运行环境的扩展中，即将该jar文件存放在JDK安装目录的jre\lib\ext文件夹中。这样，Java应用程序就可以使用这个jar文件中的类来创建对象了

将C:\1000\moon\star目录中的TestOne.class 和TestTwo.class(二者包名是moon.star)压缩成一个jar文件：Jerry.jar的步骤:

1. 清单文件:hello.mf(保存到C:\1000)

Manifest-Version: 1.0

Class: moon.start.TestOne moon.star.TestTwo

Created-By: 1.6

  2.  使用jar命令来生成一个名字为Jerry.jar的文件

C:\1000> jar cfm Jerry.jar hello.mf moon\star\TestOne.class moon\star\TestTwo.class

子类与父类 :

  利用继承，可以先编写一个共有属性的一般类，根据该一般类再编写具有特殊属性的新类，新类继承一般类的状态和行为，并根据需要增加它自己的新的状态和行为。

由继承而得到的类称为子类，被继承的类称为父类（超类）。

声明子类 :

使用关键字extends来定义一个类的子类,格式如下：

     class 子类名  extends  父类名 {

           …

     }

类的树形结构:

 Java的类按继承关系形成树形结构这个树形结构中，根节点是Object类

    （Object是java.lang包中的类），即Object是所有类的祖先类。

除了Object类每个类有且仅有一个父类，一个类可以有多个或零个子类。如果一个类（除了Object类）的声明中没有使用extends关键字，这个类被系统默认为是Object的子类，即类声明“class A”与“class A extends Object”是等同的。

子类的继承性 ：

 所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己定义的任何实例方法操作。

所谓子类继承父类的方法作为子类中的一个方法，就好象它们是在子类中直接定义了一样，可以被子类中自己定义的任何实例方法调用。

子类和父类在同一包中的继承性 ：

如果子类和父类在同一个包中，那么，子类自然地继承了其父类中不是private的成员变量作为自己的成员变量，并且也自然地继承了父类中不是private的方法作为自己的方法，继承的成员变量或方法的访问权限保持不变。

子类和父类不在同一包中的继承性：

  如果子类和父类不在同一个包中，那么，子类继承了父类的protected、public成员变量做为子类的成员变量，并且继承了父类的protected、public方法为子类的方法，继承的成员或方法的访问权限保持不变。

子类与对象：

子类对象的特点

子类的构造方法创建一个子类的对象时，不仅子类中声明的成员变量被分配了内存，而且父类的成员变量也都分配了内存空间，但只将子类继承的那部分成员变量作为分配给子类对象的变量 。子类中有一部分方法是从父类继承的，这部分方法可以操作子类未继承的变量 。

成员变量的隐藏 ：

 对于子类可以从父类继承的成员变量，只要子类中声明的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量，子类自己声明定义的方法操作与父类同名的成员变量是指子类重新声明定义的这个成员变量。

方法重写（Override）：

  子类通过重写可以隐藏已继承的实例方法。

1．重写的语法规则

如果子类可以继承父类的某个实例方法，那么子类就有权利重写这个方法。

方法重写是指：子类中定义一个方法，这个方法的类型和父类的方法的类型一致或者是父类的方法的类型的子类型，并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同。

2．重写的目的

子类通过方法的重写可以隐藏继承的方法，子类通过方法的重写可以把父类的状态和行为改变为自身的状态和行为。

重写的注意事项 ：

重写父类的方法时，不允许降低方法的访问权限，但可以提高访问权限（访问限制修饰符按访问权限从高到低的排列顺序是：public、protected、友好的、private。）

用super操作被隐藏的成员变量和方法：

子类可以隐藏从父类继承的成员变量和方法，如果在子类中想使用被子类隐藏的成员变量或方法就可以使用关键字super。比如super.x、super.play()就是访问和调用被子类隐藏的成员变量x和方法play().

使用super调用父类的构造方法：

子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。

final关键字可以修饰类、成员变量和方法中的局部变量。

可以使用final将类声明为final类。final类不能被继承，即不能有子类。如：

   final class A {

      … …

   }

如果用final修饰父类中的一个方法，那么这个方法不允许子类重写。

如果成员变量或局部变量被修饰为final的，就是常量。

对象的上转型对象 ：
 假设，A类是B类的父类，当用子类创建一个对象，并把这个对象的引用放到父类的对象中时，比如：

A a;

a=new B();

 或

A a;

B b=new B();

a=b;

这时，称对象a是对象b的上转型对象

1．上转型对象不能操作子类新增的成员变量；不能调用子类新增的方法。

2．上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法。上转型对象操作子类继承的方法或子类重写的实例方法，其作用等价于子类对象去调用这些方法。因此，如果子类重写了父类的某个实例方法后，当对象的上转型对象调用这个实例方法时一定是调用了子类重写的实

继承与多态：

多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为

用关键字abstract修饰的类/方法称为abstract类/方法（抽象类）。如：

abstract class A {

  … …

}

注意：

1．abstract类中可以有abstract方法

2．abstract类不能用new运算创建对象

面向抽象编程 ：

  在设计一个程序时，可以通过在abstract类中声明若干个abstract方法，表明这些方法在整个系统设计中的重要性，方法体的内容细节由它的非abstract子类去完成。使用多态进行程序设计的核心技术之一是使用上转型对象，即将abstract类声明对象作为其子类的上转型对象，那么这个上转型对象就可以调用子类重写的方法。所谓面向抽象编程，是指当设计某种重要的类时，不让该类面向具体的类，而是面向抽象类，即所设计类中的重要数据是抽类声明的对象，而不是具体类声明的对象。Pillar类就是面向抽象类Geometry，Cirle和Rectangle 都是Geometry的子类．

 开-闭原则 ：

所谓“开-闭原则”(Open-Closed Principle)就是让设计的系统应当对扩展开放，对修改关闭。

在设计系统时，应当首先考虑到用户需求的变化，将应对用户变化的部分设计为对扩展开放，而设计的核心部分是经过精心考虑之后确定下来的基本结构，这部分应当是对修改关闭的，即不能因为用户的需求变化而再发生变化，因为这部分不是用来应对需求变化的。

 如果系统的设计遵守了“开-闭原则”，那么这个系统一定是易维护的，因为在系统中增加新的模块时，不必去修改系统中的核心模块。

接口 ：

  为了克服Java单继承的缺点，Java使用了接口，一个类可以实现多个接口。

  使用关键字interface来定义一个接口。接口的定义和类的定义很相似，分为接口的声明和接口体。

1．接口声明

接口通过使用关键字interface来声明，格式： interface 接口的名字

2．接口体

接口体中包含常量定义和方法定义两部分。

实现接口 ：

一个类通过使用关键字implements声明自己实现一个或多个接口。

class A implements Printable,Addable

如果一个类实现了某个接口，那么这个类必须重写该接口的所有方法。

 Java提供的接口都在相应的包中，通过import语句不仅可以引入包中的类，也可以引入包中的接口，例如：

import java.io.*;   不仅引入了java.io包中的类，也同时引入了该包中的接口

理解接口：

 接口的思想在于它可以要求某些类有相同名称的方法，但方法的具体内容（方法体的内容）可以不同，即要求这些类实现接口，以保证这些类一定有接口中所声明的方法（即所谓的方法绑定）。接口在要求一些类有相同名称的方法的同时，并不强迫这些类具有相同的父类。比如，各式各样的电器产品，它们可能归属不同的种类，但国家标准要求电器产品都必须提供一个名称为on的功能（为达到此目的，只需要求它们实现同一接口，该接口中有名字为on的方法），但名称为on的功能的具体行为由各个电器产品去实现。

接口回调是指：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法。实际上，当接口变量调用被类重写的接口方法时，就是通知相应的对象调用这个方法。

接口与多态:

  可以通过在接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。

接口参数 :

 如果一个方法的参数是接口类型，我们就可以将任何实现该接口的类的实例的引用传递给该接口参数，那么接口参数就可以回调类实现的接口方法。

 abstract类与接口的比较 ：

接口和abstract类的比较如下：

1．abstract类和接口都可以有abstract方法。

2．接口中只可以有常量,不能有变量；而abstract类中即可以有常量也可以有变量。

3．abstract类中也可以有非abstract方法,接口不可以。

 面向接口编程：

面向接口去设计程序，可以通过在接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。

使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。

内部类：

Java支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类成为内部类的外嵌类。某种类型的农场饲养了一种特殊种类的牛，但不希望其他农场饲养这种特殊种类的牛，那么这种类型的农场就可以将创建这种特殊种牛的类作为自己的内部类。

和子类有关的匿名类 ：

 Java允许我们直接使用一个类的子类的类体创建一个子类对象。

创建子类对象时，除了使用父类的构造方法外还有类体，此类体被认为是一个子类去掉类声明后的类体，称作匿名类。

假设Bank是类，那么下列代码就是用Bank的一个子类（匿名类）创建对象：

    new Bank () {          

        匿名类的类体

};

和接口有关的匿名类 ：

假设Computable是一个接口，那么，Java允许直接用接口名和一个类体创建一个匿名对象，此类体被认为是实现了Computable接口的类去掉类声明后的类体，称作匿名类。

下列代码就是用实现了Computable接口的类（匿名类）创建对象：

      new Computable() {

            实现接口的匿名类的类体

       } ;    

异常类 ：

所谓异常就是程序运行时可能出现一些错误，比如试图打开一个根本不存在的文件等，异常处理将会改变程序的控制流程，让程序有机会对错误作出处理。

异常对象可以调用如下方法得到或输出有关异常的信息：

 public String getMessage();

 public void printStackTrace();

 public String toString();  

try~catch语句：

 Java使用try~catch语句来处理异常，将可能出现的异常操作放在try~catch语句的try部分，将发生异常后的处理放在catch部分。

 try~catch语句的格式如下：

  try {

      包含可能发生异常的语句

 }

 catch(ExceptionSubClass1  e) {

    …

 }

 catch(ExceptionSubClass2  e) {

    …

 }

自定义异常类：

我们也可以扩展Exception类定义自己的异常类，然后规定哪些方法产生这样的异常。

一个方法在声明时可以使用throws关键字声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操作，即用相应的异常类创建对象，并使用throw关键字抛出该异常对象，导致该方法结束执行。

断言：

 断言语句用于调试代码阶段。在调试代码阶段让断言语句发挥作用，这样就可以发现一些致命的错误，当程序正式运行时就可以关闭断言语句，但仍把断言语句保留在源代码中，如果以后应用程又需要调试，可以重新启用断言语句。

使用关键字assert声明一条断言语句，断言语句有以下两种格式：

  assert booleanExpression;

  assert booleanExpression:messageException;

String类 ：

  Java专门提供了用来处理字符序列的String类。String类在java.lang包中，由于java.lang包中的类被默认引入，因此程序可以直接使用String类。需要注意的是Java把String类声明为final类，因此用户不能扩展String类，即String类不可以有子类。

String 类的常用方法：

1．public int length():获取一个字符串的长度

2．public boolean equals(String s):比较当前字符串对象的实体是否与参数s指定的字符串的实体相同                 

3．public boolean startsWith(String s)

   public boolean endsWith(String s)方法:判断当前字符串对象的前缀（后缀）是否参数s指定的字符串

    String tom = "天气预报，阴有小雨",jerry = "比赛结果，中国队赢得胜利";

    tom.startsWith(“天气”)的值是true；

    tom.endsWith("大雨")的值是false，

4. public int compareTo(String s):按字典序与参数s指定的字符串比较大小

     如果当前字符串与s相同，该方法返回值0；

     如果当前字符串对象大于s，该方法返回正值；

     如果小于s，该方法返回负值。

     例如，字符a在Unicode表中的排序位置是97、字符b是98，那么对于

        String str = "abcde";   str.compareTo("boy")小于0；

其相关方法 public int compareToIgnoreCase(String s)

5.public boolean contains(String s):判断当前字符串对象是否含有参数指定的字符串s 

        例如  tom=“student”；那么tom.contains(“stu”)的值就是true；

                   而tom.contains("ok")的值是false。

6. public int indexOf (String s):从当前字符串的头开始检索字符串s，并返回首次出现s的位置,其相关方法：

   indexOf(String s ,int startpoint)

   lastIndexOf (String s)

    例如 String tom = "I am a good cat"；

              tom.indexOf("a");//值是2

              tom.indexOf("good",2);//值是7

              tom.indexOf("a",7);//值是13

              tom.indexOf("w",2);//值是-1

7. public String substring(int startpoint):获得一个当前字符串的子串  

     其相关方法：substring(int start ,int end)

    例如：  String tom = "我喜欢篮球";

                  String s = tom.substring(1,3);

                  那么s是："喜欢"

1. public String trim() :得到一个s去掉前后空格后的字符串对象

符串与基本数据的相互转化：

java.lang包中的Integer类调用其类方法：

      public static int parseInt(String s)

可以将由“数字”字符组成的字符串，如“876”，转化为int型数据

可以使用String 类的类方法

        public static String valueOf(byte n)

       public static String valueOf(int n)

       public static String valueOf(long n)  

       public static String valueOf(float n)

对象的字符串表示 ：

 所有的类都默认是java.lang包中Object类的子类或间接子类。

Object类有一个public String toString()方法，一个对象通过调用该方法可以获得该对象的字符串表示。一个对象调用toString()方法返回的字符串的一般形式为：创建对象的类的名字@对象的引用的字符串表示

字符串与字符、字节数组：

String 类的构造方法：

◆ String(char[])和String(char[]，int offset，int length)分别用字符数组中的全部字符和部分字符创建字符串对象

◆ String类提供了将字符串存放到数组中的方法：

   public void getChars(int start,int end,char c[],int offset )

◆将字符串中的全部字符存放在一个字符数组中的方法：

public char[] toCharArray()

◆String(byte[])用指定的字节数组构造一个字符串对象。

   String(byte[]，int offset，int length) 用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。

◆public byte[] getBytes() 方法使用平台默认的字符编码，将当前字符串转化为一个字节数组。

◆ public byte[] getBytes(String charsetName) 使用参数指定字符编码，将当前字符串转化为一个字节数组。  

字符串的加密算法  ：

使用一个字符串password作为密码对另一个字符串sourceString进行加密 。将密码password存放到一个字符数组char [] p = password.toCharArray();

假设数组p的长度为n，那么就将待加密的字符串sourceString按顺序以n个字符为一组，对每一组中的字符用数组a的对应字符做加法运算。

正则表达式及字符串的替换与分解：

 1．正则表达式

一个正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称作正则表达式中的元字符。比如，“\\dcat”中的\\d就是有特殊意义的元字符，代表0到9中的任何一个。字符串对象调用 public boolean matches(String regex)方法可以判断当前字符串对象是否和参数regex指定的正则表达式匹配。

 2．字符串的替换

 字符串对象调用public String replaceAll(String regex,String replacement)方法返回一个字符串，该字符串是当前字符串中所有和参数regex指定的正则表达式匹配的子字符串被参数replacement指定的字符串替换后的字符串，例如：

     String s ="12hello567bird".replaceAll("[a-zA-Z]+","你好");

字符串的分解

 3.字符串调用public String[] split(String regex)使用参数指定的正则表达式regex做为分隔标记分解出其中的单词，并将分解出的单词存放在字符串数组中。

      例如，对于字符串str  

 String str = "1949年10月1日是中华人民共和国成立的日子";

如果准备分解出全部由数字字符组成的单词，就必须用非数字字符串做为分隔标记，因此，可以使用正则表达式：String regex="\\D+";

做为分隔标记分解出str中的单词：String digitWord[]=str.split(regex);

那么，digitWord[0]、digitWord[1]和digitWord[2]就分别是“1949”、“10”和“1”。

StringTokenizer类 ：

本节学习怎样使用StringTokenizer对象分解字符串。

StringTokenizer类在java.util包中，有两个常用的构造方法：

◆StringTokenizer（String s）：为字符串s构造一个分析器。使用默认的分隔标记，即空格符（若干个空格被看做一个空格）、换行符、回车符、Tab符、进纸符。

◆ StringTokenizer(String s, String delim)：为字符串s构造一个分析器。参数dilim中的字符被作为分隔标记 。

例如：

    StringTokenizer fenxi = new StringTokenizer("you are welcome");

    StringTokenizer fenxi = new StringTokenizer("you,are ; welcome",  ", ; ");

◆ StringTokenizer对象称作一个字符串分析器可以使用下列方法：

     nextToken()：逐个获取字符串中的语言符号（单词），字符串分析器中的负责计数的变量的值就自动减一  。

hasMoreTokens()：只要字符串中还有语言符号，即计数变量的值大于0，该方法就返回true，否则返回false。 countTokens()：得到分析器中计数变量的值。

  Scanner类：

使用Scanner类从字符串中解析程序所需要的数据。

    1．使用默认分隔标记解析字符串

       创建Scanner对象，并将要解析的字符串传递给所构造的对象,

     例如 String NBA = "I Love This Game";

     如下构造一个Scanner对象：

     Scanner scanner = new Scanner(NBA);

那么scanner将空格做为分隔标记来解析字符串中的单词，解析操作的特点如下：

◆ scanner调用next()方法依次返回NBA中的单词，如果NBA最后一个单词已被next()方法返回，scanner调用hasNext()将返回false，否则返回true。

◆  对于被解析的字符串中的数字型的单词，比如618，168.98等，scanner可以用nextInt()或nextDouble()方法来代替next()方法，即scanner可以调用nextInt()或nextDouble()方法将数字型单词转化为int或double数据返回。

◆ 如果单词不是数字型单词，scanner调用nextInt()或nextDouble()方法将发生InputMismatchException异常，在处理异常时可以调用next()方法返回该非数字化单词。

       例题13    使用Scanner对象解析字符串"TV cost 876 dollar.Computer cost 2398 dollar.telephone cost 1278 dollar"中的全部价格数字（价格数字的前后需有空格），并计算了总消费。

  2．使用正则表达式作为分隔标记解析字符串

       Scanner对象可以调用 useDelimiter(正则表达式); 方法将一个正则表达式作为分隔标记，即和正则表达式匹配的字符串都是分隔标记。

 Date类 ：

   Date类在java.util包中。

1.使用Date类的无参数构造方法创建的对象可以获取本地当前时间。 Date()

     例： Date nowTime=new Date();

当前nowTime对象中含有的日期、时间就是创建nowTime对象时的本地计算机的日期和时间。例如，假设当前时间是：2011年3月10日23:05:32（CST时区），那么

System.out.println(nowTime); 输出结果是：Thu Mar 10 23:05:32 CST 2011。

      Date对象表示时间的默认顺序是：星期、月、日、小时、分、秒、年

2.使用带参数的构造方法  Date(long time)

计算机系统将其自身的时间的“公元”设置在1970年1月1日0时（格林威治时间），可以根据这个时间使用Date的带参数的构造方法：Date(long time)来创建一个Date对象，例如：

        Date date1=new Date(1000), date2=new Date(-1000);

其中的参数取正数表示公元后的时间，取负数表示公元前的时间，例如1000表示1000毫秒，那么，date1含有的日期、时间就是计算机系统公元后1秒时刻的日期、时间。如果运行Java程序的本地时区是北京时区（与格林威治时间相差8个小时），那么上述date1就是1970年01月01日08时00分01秒、date2就是1970年01月01日07时59分59秒。

3.System类的静态方法 public long currentTimeMillis() 获取系统当前时间

Calendar类：

1  Calendar类在java.util包中。使用Calendar类的static方法 getInstance()可以初始化一个日历对象，如：

    Calendar calendar= Calendar.getInstance();

2 calendar对象可以调用方法：

   public final void set(int year,int month,int date)

   public final void set(int year,int month,int date,int hour,int minute)

   public final void set(int year,int month, int date, int hour, int minute,int second)

     将日历翻到任何一个时间

3 calendar对象常用方法

◆public int get(int field) ：可以获取有关年份、月份、小时、星期等信息

   例如：calendar.get(Calendar.MONTH); 返回一个整数，如果该整数是0表示当前日历是在一月，该整数是1表示当前日历是在二月等。

   例如：calendar.get(Calendar.DAY_OF_WEEK);返回一个整数，如果该整数是1表示星期日，如果是2表示是星期一，依次类推，如果是7表示是星期六。    

◆ public long getTimeInMillis() ：可以将时间表示为毫秒。 

format方法 ：

Formatter类的format方法：format(格式化模式, 日期列表)

按着“格式化模式”返回“日期列表”中所列各个日期中所含数据（年，月，日，小时等数据）的字符串表示。Java已经将format方法做为了String类的静态方法，因此，程序可以直接使用String类调用format方法对日期进行格式化。

1．格式化模式

format方法中的“格式化模式”是一个用双引号括起的字符序列（字符串）,该字符序列中的字符由时间格式符和普通字符所构成。例如："日期:%ty-%tm-%td"

String s = String.format("%tY年%tm月%td日",new Date(),new Date(),new Date()); 那么s就是"2011年02月10日

2．日期列表

format方法中的“日期列表”可以是用逗号分隔的Calendar对象或Date对象。 format方法默认按从左到右的顺序使用“格式化模式”中的格式符来格式“日期列表”中对应的日期，而“格式化模式”中的普通字符保留原样。

3.格式化同一日期     可以在“格式化模式”中使用“<”，比如："%ty-%，例如：String s = String.format("%ty年%

不同区域的星期格式 ：

如果想用特定地区的星期格式来表示日期中的星期，可以用format的重载方法：

format (Locale locale,格式化模式,日期列表);

其中的参数locale是一个Locale类的实例，用于表示地域。

Locale类的static常量都是Locale对象，其中US是表示美国的static常量。

比如，假设当前时间是2011-02-10，对于（%ta表示简称的星期）：

String s = String.format(Locale.US,"%ta(%

那么s是"Thu(2011-02-10)"，

对于（%tA表示全称的星期）

String s = String.format(Locale.JAPAN,"%tA(%

那么s是"木曜日(2011-02-10)"。

  Math类 ：

 Math类在java.lang包中。Math类包含许多用来进行科学计算的类方法，这些方法可以直接通过类名调用。另外，Math类还有两个静态常量，它们分别是：

E   2.7182828284590452354和PI    3.14159265358979323846。

以下是Math类的常用类方法：

* public static long abs(double a)  返回a的绝对值。

* public static double max(double a,double b) 返回a、b的最大值。

* public static double min(double a,double b) 返回a、b的最小值。

* public static double random()  产生一个0到1之间的随机数（不包括0和1）。

* public static double pow(double a,double b) 返回a的b次幂。

* public static double sqrt(double a) 返回a的平方根。

* public static double log(double a)  返回a的对数。

* public static double sin(double a) 返回正弦值。

* public static double asin(double a)  返回反正弦值。

 BigInteger类 ：

1 java.math包中的BigInteger类提供任意精度的整数运算。可以使用构造方法：

      public BigInteger(String val)  构造一个十进制的BigInteger对象。

2 以下是BigInteger类的常用类方法：

*public BigInteger add(BigInteger val)  返回当前大整数对象与参数指定的大整数对象的和。

*public BigInteger subtract(BigInteger val)返回当前大整数对象与参数指定的大整数对象的差。

* public BigInteger multiply(BigInteger val)返回当前大整数对象与参数指定的大整数对象的积。

*public BigInteger divide(BigInteger val)返回当前大整数对象与参数指定的大整数对象的商。

*public BigInteger remainder(BigInteger val)返回当前大整数对象与参数指定的大整数对象的余。

*public int compareTo(BigInteger val) 返回当前大整数对象与参数指定的大整数的比较结果，返回值是1、-1或0，分别表示当前大整数对象大于、小于或等于参数指定的大整数。

*public BigInteger abs()  返回当前大整数对象的绝对值。

*public BigInteger pow(int a)  返回当前大整数对象的a次幂。

*public String toString()  返回当前大整数对象十进制的字符串表示。

*public String toString(int p)  返回当前大整数对象p进制的字符串表示。

Random类 ：

  Java提供了更为灵活的用于获得随机数的Random类（该类在java.util包中）。 Random类的如下构造方法：

     public Random();

     public Random(long seed);使用参数seek指定的种子创建一个Random对象

     人们习惯地将Random对象称为随机数生成器。

◆ 返回一个随机整数   随机数生成器random调用不带参数的nextInt()方法：

      Random random=new Random();

      random.nextInt();

◆ 返回一个0至n之间（包括0，但不包括n）的随机数 随机数生成器random调用带参数的nextInt(int m)方法（参数m必须取正整数值）

    例如，random.nextInt(100);返回一个0至100之间的随机整数(包括0，但不包括100)。

◆ 随机得到true和false两个表示真和假的boolean值， 随机数生成器random调用nextBoolean()方法

   例如 random.nextBoolean();返回一个随机boolean值。

Formatter 类：

Formatter类提供了一个和C语言printf函数类似的format方法：

format（格式化模式,值列表）

该方法按着“格式化模式”返回“值列表”的字符串表示。

Java已经将format方法做为了String类的静态方法，因此，程序可以直接使用String类调用format方法对数字进行格式化。

1．格式化模式  format方法中的“格式化模式”是一个用双引号括起的字符序列(字符串),该字符序列中的字符由格式符和普通字符所构成。

例如："输出结果%d,%f,%d"中的%d和%f是格式符号 .

     format方法返回的字符串就是“格式化模式”中的格式符被替换为它得到的格式化结果后的字符串。例如：String s = String.format(“%.2f”,3.141592);那么s就是“3.14”.

2．值列表   format方法中的“值列表”是用逗号分隔的变量、常量或表达式。 例如：

String s=format("%d元%0.3f公斤%d台",888,999.777666,123); 那么,s就是"888元999.778公斤123台"。

3．格式化顺序

format方法默认按从左到右的顺序使用“格式化模式”中的格式符来格式化“值列表”中对应的值，而“格式化模式”中的普通字符保留原样。

例如，假设int型变量x和double型变量y的值分别是888和3.1415926，

那么对于String s = format("从左向右：%d,%.3f,%d",x,y,100);字符串s就是：从左向右：888,3.142,100

格式化整数：

1．%d，%o，%x和%格式符可格式化byte、Byte、short、Short、int、Integer、long和Long型数据，详细说明见Page204. 例如，对于：

String s = String.format("%d,%o,%x,%X",703576,703576,703576,703576);

字符串s就是：703576,2536130,abc58,ABC58

2．修饰符

加号修饰符"+"格式化正整数时，强制添加上正号,例如，%+d将123格式化为"+123"。

逗号修饰符“,”格式化整数时,按"千"分组，例如，对于：

String s=String.format("按千分组:%,d。按千分组带正号%+,d",1235678,9876);

字符串s就是：按千分组:1,235,678。按千分组带正号+9,876

3．数据的宽度

数据的宽度就是format方法返回的字符串的长度。规定数据宽度的一般格式为“%md”,其效果是在数字的左面增加空格;或"%-md“,其效果是在数字的右面增加空格,

例如，将数字59格式化为宽度为8的字符串：String s=String.format("%8d",59);

字符串s就是："      59"，其长度（s.length()）为8，即s在59左面添加了6个空格字符。

对于：String s=String.format(“%-8d”,59);字符串s就是："59        ",其长度(s.length())为8。

对于：String s=String.format("%5d%5d%8d",59,60,90);字符串s就是："   59   60      90"(长度为18

格式化浮点数 ：

1．%f,%e(%E),%g(%G)和%a(%A)格式符可格式化float、Float、double和Double:

   %f 将值格式化为十进制浮点数，小数保留6位。

   %e（%E） 将值格式化为科学记数法的十进制的浮点数（%E在格式化时将其中的指数符号大写，例如5E10）。

例如，对于：String s = String.format("%f,%e",13579.98,13579.98);

字符串s就是：13579.980000,1.357998e+04

2．修饰符

加号修饰符"+"格式化正数时,强制添加上正号,例如%+f将123.78格式化为"+123.78", %+E将123.78格式化为"+1.2378E+2"。 逗号修饰符“,”格式化浮点数时,将整数部分按“千”分组,

例如,对于：String s=String.format("整数部分按千分组: %+,f",1235678.9876);

字符串s就是：整数部分按千分组:+1,235,678.987600

3．限制小数位数与数据的“宽度”

     ◆  "%.nf"可以限制小数的位数,其中的n是保留的小数位数,例如%.3f将6.1256格式化为"6.126"（保留3位小数）。

 规定宽度的一般格式为“%mf”(在数字的左面增加空格),或“%-md”(在数字的右面增加空格)。

例如,将数字59.88格式化为宽度为11的字符串

String s=String.format(“%11f”,59.88); 字符串s就是："  59.880000"，其长度(s.length())为11。

String s=String.format(“%-11f”,59.88);字符串s就是： "59.880000  "，其长度(s.length())为11。

◆在指定宽度的同时也可以限制小数位数(%m.nf),

String s=String.format(“%11.2f”,59.88);  字符串s就是："      59.88"，即s在59.88左面添加了6个空格字符。

◆ 在宽度的前面增加前缀0,表示用数字0（不用空格）来填充宽度左面的富裕部分，例如：

String s=String.format(“%011f”,59.88); 字符串s就是："0059.880000"，其长度（s.length()）11

StringBuffer对象的创建：

StringBuffer类能创建可修改的字符串序列，该类的对象的实体的内存空间可以自动的改变大小，便于存放一个可变的字符序列。一个StringBuffer对象调用append方法可以追加字符序列，如图819所示。例如：

StringBuffer s = new StringBuffer("我喜欢");

s.append("玩篮球");   

StringBuffer类有三个构造方法：

1．StringBuffer()

2．StringBuffer(int size)

3．StringBuffer(String s)

StringBuffer类的常用方法：

1．StringBuffer append(String s):将一个字符串对象追加到当前StringBuffer对象中 StringBuffer append(int n)：将一个int型数据转化为字符串对象后再追加到当前StringBuffer对象中StringBuffer append(Object o)：将一个Object对象的字符串表示追加到当前StringBuffer对象中

类似的方法还有：

   StringBuffer append(long n),StringBuffer append(boolean n),

   StringBuffer append(float n),StringBuffer append(double n),

   StringBuffer append(char n)

2．public chat charAt(int n ):得到参数n指定的置上的单个字符

   public void setCharAt(int n ,char ch):将当前StringBuffer对象实体中的字符串位置n处的字符用参数ch指定的字符替换

3．StringBuffer insert(int index, String str) :将参数str指定的字符串插入到参数index指定的位置

4．public StringBuffer reverse() :将该对象实体中的字符翻转

5．StringBuffer delete(int startIndex, int endIndex):从当前StringBuffer对象实体中的字符串中删除一个子字符串

   其相关方法:deleteCharAt(int index) 删除当前StringBuffer对象实体的字符串中index位置处的一个字符。

1. StringBuffer replace(int startIndex,int endIndex,String str):将当前StringBuffer对象实体中的字符串的一个子字符串用参数str指定的字符串替换    

Pattern与Matcher类：

Java提供了专门用来进行模式匹配的Pattern类和Matcher类，这些类在java.util.regex包中。  以下结合具体问题来讲解使用Pattern类和Matcher类的步骤。假设有字符串：

String input = "hello,good morning,this is a good idea"

我们想知道input从哪个位置开始至哪个位置结束曾出现了字符串good。

使用Pattern类和Matcher类检索字符串str中的子字符串的步骤如下：

1．建立模式对象

使用正则表达式regex做参数得到一个称为模式的Pattern类的实例pattern：

例如：String regex = "good";

     Pattern pattern = Pattern.compile(regex);

模式对象是对正则表达式的封装。Pattern类调用类方法compile(String regex)返回一个模式对象，其中的参数regex是一个正则表达式, 称为模式对象使用的模式。

2．得到匹配对象

     模式对象pattern调用matcher(CharSequence input)方法返回一个Matcher对象matcher，称为匹配对象             

Matcher matcher = pattern.matcher(input);

Matcher对象matcher可以使用下列方法寻找字符串input中是否有和模式regex匹配的子序列（regex是创建模式对象pattern时使用的正则表达式）。

◆public boolean find():寻找input和regex匹配的下一子序列，如果成功该方法返回true，否则返回false。

◆ public boolean matches()：matcher调用该方法判断input是否完全和regex匹配。

◆ public boolean lookingAt()：matcher调用该方法判断从input的开始位置是否有和regex匹配的子序列。

◆ public boolean find(int start) : matcher调用该方法判断input从参数start指定位置开始是否有和regex匹配的子序列 。

◆ public String replaceAll(String replacement) matcher调用该方法可以返回一个字符串,该字符串是通过把input中与模式regex匹配的子字符串全部替换为参数replacement指定的字符串得到的.

◆ public String replaceFirst(String replacement) matcher调用该方法可以返回一个字符串，该字符串是通过把input中第1个与模式regex匹配的子字符串替换为参数replacement指定的字符串得到的。

使用Class实例化一个对象 ：

 Class是java.lang包中的类，该类的实例可以帮助程序创建其他类的实例或者取得其他类的对象的内部信息。

创建对象最常用的方式就是使用new运算符和类的构造方法，实际上也可以使用Class对象得到某个类的实例。步骤如下：

（1）使用Class的类方法得到一个和某类（参数className指定的类）相关的Class对象：

 public static Class forName(String className) throws ClassNotFoundException

 上述方法返回一个和参数className指定的类相关的Class对象。

（2）步骤（1）中获得的Class对象调用

public Object newInstance() throws InstantiationException,IllegalAccessException

方法就可以得到一个className类的对象。要特别注意的是：使用Class对象调用newInstance()实例化一个className类的对象时，className类必须有无参数的构造方法。

获取类的有关信息 ：

Class对象经常调用的方法如下：

◆ String getName() 返回类的名字

◆ Constructor[] getDeclaredConstructors()  返回类的全部构造方法。

◆ Field[] getDeclaredFields()  返回类的全部成员变量。

◆ Method[] getDeclaredMethods()  返回类的全部方法。

 Java Swing概述 ：

 javax.swing包中JComponent类是java.awt包中Container类的一个直接子类、是java.awt包中Component类的一个间接子类，学习GUI编程主要是学习掌握使用Component类的一些重要的子类。以下是GUI编程经常提到的基本知识点 。

(1)Java把Component类的子类或间接子类创建的对象称为一个组件。

(2)Java把Container的子类或间接子类创建的对象称为一个容器。

(3)可以向容器添加组件。Container类提供了一个public方法：add( )，一个容器可以调用这个方法将组件添加到该容器中。

(4)容器调用removeAll()方法可以移掉容器中的全部组件；调用remove(Component c)方法可以移掉容器中参数c指定的组件。

(5)注意到容器本身也是一个组件，因此可以把一个容器添加到另一个容器中实现容器的嵌套。

(6)每当容器添加新的组件或移掉组件时，应当让容器调用validate()方法，以保证容器中的组件能正确显示出来

窗口 ：

Java提供的JFrame类的实例是一个底层容器，即通常所称的窗口。其他组件必须被添加到底层容器中，以便借助这个地层容器和操作系统进行信息交互。 JFrame类是Container类的间接子类。当需要一个窗口时，可使用JFrame或其子类创建一个对象

   JFrame常用方法 ：

JFrame() 创建一个无标题的窗口。

JFrame(String s) 创建标题为s的窗口。

public void setBounds(int a,int b,int width,int height 设置窗口的初始位置是(a,b)，即距屏幕左面a个像素、距屏幕上方b个像素；窗口的宽是width，高是height。

public void setSize(int width,int height) 设置窗口的大小。

public void setLocation(int x,int y) 设置窗口的位置，默认位置是(0,0)。

public void setVisible(boolean b) 设置窗口是否可见，窗口默认是不可见的。

public void setResizable(boolean b) 设置窗口是否可调整大小，默认可调整大小。

public void dispose() 撤消当前窗口，并释放当前窗口所使用的资源。

public void setExtendedState(int state) 设置窗口的扩展状态.

public void setDefaultCloseOperation(int operation)  该方法用来设置单击窗体右上角的关闭图标后，程序会做出怎样的处理。

菜单条、菜单、菜单项 ：

1．菜单条

    JComponent类的子类JMenubar负责创建菜单条，JFrame类有一个将菜单条放置到窗口中的方法:setJMenuBar(JMenuBar bar);该方法将菜单条添加到窗口的顶端

2．菜单:JComponent类的子类JMenu负责创建菜单, JMenu类的主要方法有以下几种

   public void add(JMenuItem item) 向菜单增加由参数item指定的菜单选项。

   public JMenuItem getItem(int n) 得到指定索引处的菜单选项。

   public int getItemCount() 得到菜单选项的数目。

3.菜单项

   JComponent类的子类JMenuItem负责创建菜单项,JMenuItem类的主要方法有以下几种：

  JMenuItem(String s) 构造有标题的菜单项。

  JMenuItem(String text, Icon icon) 构造有标题和图标的菜单项

  public void setAccelerator(KeyStroke keyStroke) 为菜单项设置快捷键。

常用组件 ：

1．文本框：由JComponent的子类JTextField创建文本框。

2．文本区：由JComponent的子类JTexArea创建文本区。

3．按钮：由JComponent的子类JButton类用来创建按钮。

4．标签：由JComponent的子类JLabel类用来创建标签。

5．选择框：由JComponent的子类JCheckBox类用来创建选择框。

6．单选按钮：由JComponent的子类JRadioButton类用来创建单项选择框。

7．下拉列表：由JComponent的子类JComboBox类用来创建下拉列表。

8．密码框：由JComponent的子类JPasswordField创建密码框。

密码框可以使用setEchoChar(char c)重新设置回显字符 。

密码框调用char[] getPassword()方法可以返回实际的密码

常用容器：

 JComponent是Container的子类，因此JComponent子类创建的组件也都是容器。容器经常用来添加组件。Jframe是底层容器，本节提到的容器被习惯地称做中间容器，中间容器必须被添加到底层容器中才能发挥作用。

1．JPanel 面板:使用JPanel创建面板，再向这个面板添加组件，然后把这个面板添加到其它容器中。JPanel面板的默认布局是FlowLayout布局。

2．滚动窗格JScrollPane:可以将文本区放到一个滚动窗格中。

 JScorollPane scroll=new JScorollPane(new JTextArea());

3．拆分窗格JSplitPane:窗格有两种类型：水平拆分和垂直拆分

JSplitPane的两个常用的构造方法：

  JSplitPane(int a,Component b,Component c)

  JSplitPane(int a, boolean b,Component c,Component d)  

4．JLayeredPane分层窗格:分层窗格使用

add(Jcomponent com, int layer);添加组件com，并指定com所在的层

public void setLayer(Component c,int layer)可以重新设置组件c所在的层

public int getLayer(Component c)可以获取组件c所在的层数。

常用布局：

 容器可以使用方法setLayout(布局对象);设置自己的布局,控制组件在容器中的位置。  

1．FlowLayout布局 :

1)创建布局对象 FlowLayout flow=new FlowLayout();

2)容器con使用布局对象con.setLayout(flow);

3)con可以使用Container类提供的add方法将组件顺序地添加到容器中;

FlowLayout布局对象调用相应的方法可以重新设置布局的对齐方式等.

2．BorderLayout布局 :

BorderLayout 布局是Window型容器的默认布局 。

使用BorderLayout布局的容器con，可以使用add方法将一个组件b添加到中心区域：con.add(b,BorderLayout.CENTER);或  con.add(BorderLayour.CENTER,b);

3．CardLayout 布局 :  使用CardLayout的一般步骤如下：

  1)创建CardLayout对象 CardLayout card=new CardLayout();

  2)为容器设置布局 con.setLayout(card);

  3)容器调用add(String s,Component b)将组件b加入容器，并给出了显示该组件的代号s。

  4)布局对象card用CardLayout类提供的show()方法，显示容器con中组件代号为s的组件：card.show(con,s);

4．GridLayout布局 :

GridLayout布局策略是把容器划分成若干行乘若干列的网格区域，组件就位于这些划分出来的小格中。 GridLayout布局编辑器的一般步骤如下：

1)创建布局对象，指定划分网格的行数m和列数n GridLayout grid=new new GridLayout(10,8);

2)使用GridLayout布局的容器调用方法add(Component c)将组件c加入容器。

5．BoxLayout布局:

使用盒式布局的容器将组件排列在一行或一列 .BoxLayout布局的一般步骤如下：

1)创建布局对象，使用BoxLayou的构造方法BoxLayout(Container con，,int axis)可以创建一个盒式布局对象.

2)可以使用Box类的类（静态）方法 createHorizontalBox()获得一个具有行型盒式布局的盒式容器；  使用Box类的类（静态）方法 createVerticalBox()获得一个具有列型盒式布局的盒式容器。

3)控制盒式布局容器中组件之间的距离

Box类调用静态方法createHorizontalStrut(int width)可以得到一个不可见的水平Struct对象，称做水平支撑。 Box类调用静态方法createVertialStrut(int height)可以得到一个不可见的垂直Struct对象，称做垂直支撑。

例子5  Example9_5.java  WindowBoxLayout.java

两个列型盒式容器boxV1、boxV2和一个行型盒式容器baseBox。

在列型盒式容器的组件之间添加垂直支撑，控制组件之间的距离，将boxV1、boxV2添加到baseBox中，并在它俩之间添加了水平支撑。程序运行效果如图9.6。

6．null布局 :

空布局容器可以准确地定位组件在容器的位置和大小。组件调用setBounds(int a,int b,int width,int height)方法可以设置本身的大小和在容器中的位置。

处理事件：

学习组件除了要熟悉组件的属性和功能外，一个更重要的方面是学习怎样处理组件上发生的界面事件。当用户在文本框中键入文本后按回车键、单击按钮、在一个下拉式列表中选择一个条目等操作时，都发生界面事件。

程序有时需对发生的事件作出反应，来实现特定的任务，例如，用户单击一个名字叫“确定”或名字叫“取消”的按钮，程序可能需要作出不同的处理。

 事件处理模式 ：

1．事件源 :能够产生事件的对象都可以成为事件源 .

2．监视器 :事件源通过调用相应的方法将某个对象注册为自己的监视器。对于文本框，这个方法是：addActionListener(监视器);事件源注册监视器之后，相应的操作就会导致相应的事件的发生，并通知监视器，监视器就会作出相应的处理。

3．处理事件的接口:

监视器负责处理事件源发生的事件。监视器是一个对象，为了处理事件源发生的事件，监视器这个对象会自动调用一个方法来处理事件。 Java规定：为了让监视器这个对象能对事件源发生的事件进行处理，创建该监视器对象的类必须声明实现相应的接口，那么当事件源发生事件时，监视器就自动调用被类重写的某个接口方法

ActionEvent事件：

 1． ActionEvent事件源 :

文本框、按纽、菜单项、密码框和单选按纽都可以触发ActionEvent事件，即都可以成为ActionEvent事件的事件源。

2．注册监视器: 能触发ActionEvent事件的组件使用

addActionListener(ActionListener listen)

将实现ActionListener接口的类的实例注册为事件源的监视器。

3．ActionListener接口 :

ActionListener接口在java.awt.event包中,该接口中只有一个方法：

public void actionPerformed(ActinEvent e)

事件源触发ActionEvent事件后，监视器将发现触发的ActionEvent事件，然后调用接口中的方法：actionPerformed(ActinEvent e)对发生的事件作出处理。ActionEvent类事先创建的事件对象就会传递给该方法的参数e。  

4．ActionEvent类中的方法 :

public Object getSource() 调用该方法可以获取发生ActionEvent事件的事件源对象的引用。

public String getActionCommand() 调用该方法可以获取发生ActionEvent事件时，和该事件相关的一个命令字符串。

ItemEvent事件：

1．ItemEvent事件源 :选择框、下拉列表都可以触发ItemEvent事件。

2．注册监视器:能触发ItemEvent事件的组件使用

addItemListener(ItemListener listen)

将实现ItemListener接口的类的实例注册为事件源的监视器。

3．ItemListener接口 :

ItemListener接口在java.awt.event包中,该接口中只有一个方法：

public void itemStateChanged(ItemEvent e)

事件源触发ItemEvent事件后，监视器将发现触发的ItemEvent事件，然后调用接口中的itemStateChanged(ItemEvent  e)方法对发生的事件作出处理。ItemEvent类事先创建的事件对象就会传递给该方法的参数e。

4． ItemEvent类中的方法 :

getSource()方法返回发生Itemevent事件的事件源外

getItemSelectable()方法返回发生Itemevent事件的事件源。

 DocumentEvent事件：

1. DocumentEvent事件源 :文本区所维护的文档能触发DocumentEvent事件  

2．注册监视器:能触发DocumentEven事件的事件源使用

addDucumentListener(DocumentListener listen)

将实现DocumentListener接口的类的实例注册为事件源的监视器。

3．DocumentListener接口 :

DocumentListener接口在javax.swing.event包中，该接口中有三个方法：

public void changedUpdate(DocumentEvent e)    

public void removeUpdate(DocumentEvent e)

public void insertUpdate(DocumentEvent e)

MouseEvent事件：

任何组件上都可以发生鼠标事件，如：鼠标进入组件、退出组件、在组件上方单击鼠标、拖动鼠标等都触发鼠标事件，即导致MouseEvent类自动创建一个事件对象。

 1．使用MouseListener接口可以处理以下5种操作触发的鼠标事件

    在事件源上按下鼠标键、在事件源上释放鼠标键、在事件源上击鼠标键、鼠标进入事件源、鼠标退出事件源。

 ▶ MouseEvent 中有下列几个重要的方法：

   getX() 获取鼠标指针在事件源坐标系中的x-坐标。

   getY() 获取鼠标指针在事件源坐标系中的y-坐标。

   getModifiers() 获取鼠标的左键或右键。

   getClickCount() 获取鼠标被单击的次数。

   getSource() 获取发生鼠标事件的事件源。

 ▶事件源注册监视器的方法是addMouseListener(MouseListener listener)。

 ▶ MouseListener接口中有如下方法：

   mousePressed(MouseEvent) 负责处理在组件上按下鼠标键触发的鼠标事件

   mouseReleased(MouseEvent) 负责处理在组件上释放鼠标键触发的鼠标事件

   mouseEntered(MouseEvent) 负责处理鼠标进入组件触发的鼠标事件

   mouseExited(MouseEvent) 负责处理鼠标离开组件触发的鼠标事件

   mouseClicked(MouseEvent) 负责处理在组件上单击鼠标键触发的

2．使用MouseMotionListener接口可以处理以下两种操作触发的鼠标事件，  在事件源上拖动鼠标、在事件源上移动鼠标。

 ▶ 事件源注册监视器的方法是

    addMouseMotionListener(MouseMotionListener listener)。

 ▶ MouseMotionListener接口中有如下方法：

    mouseDragged(MouseEvent)  负责处理拖动鼠标触发的鼠标事件。

mouseMoved(MouseEvent)  负责处理移动鼠标触发的鼠标事件。

  焦点事件：

1．焦点事件源 :组件可以触发焦点事件。

2．注册监视器:组件可以使用

    addFocusListener(FocusListener listener)

注册焦点事件监视器。

3．FocusListener接口 :

   创建监视器的类必须要实现FocusListener接口，该接口有两个方法：

      public void focusGained(FocusEvent e)

      public void focusLost(FocusEvent e)

   当发生FocusEvent事件时，监视器调用类实现的接口中的相应方法。

 4．组件也可调用

       public boolean requestFocusInWindow()

方法可以获得输入焦点。

键盘事件：

当一个组件处于激活状态时，敲击键盘上一个键就导致这个组件触发键盘事件。

1.某个组件使用addKeyListener方法注册监视器。

2.接口KeyListener中有如下方法：

  public void keyPressed(KeyEvent e),

  public void keyTyped(KeyEvent e),

  public void KeyReleased(KeyEvent e)  

3.相关方法：

   public int getKeyCode()判断哪个键被按下、敲击或释放,返回一个键码值 。      

   getKeyChar()判断哪个键被按下、敲击或释放，返回键上的字符。

 窗口事件：

JFrame及子类创建的窗口可以调用

setDefaultCloseOperation(int operation);

方法设置窗口的关闭方式（如前面各个例子所示）.

但是setDefaultCloseOperation方式可能不能满足程序的需要，比如，用户单击窗口上的关闭图标时，可能程序需要提示用户是否需要保存窗口中的有关数据到磁盘等 .

1. WindowListener接口.

1.  public void windowActivated(WindowEvent e)  当窗口从非激活状态到激活时，窗口的监视器调用该方法。
2.  public void windowDeactivated(WindowEvent e)  当窗口激活状态到非激活状态时，窗口的监视器调用该方法。
3.  public void windowClosing(WindowEvent e)  当窗口正在被关闭时，窗口的监视器调用该方法。
4.  public void windowClosed(WindowEvent e)  当窗口关闭后，窗口的监视器调用该方法。（5） public void windowIconified(WindowEvent e)  当窗口图标化时，窗口的监视器调用该方法。

6） public void windowDeiconified(WindowEvent e)  当窗口撤消图标化时，窗口的监视器调用该方法。

7） public void windowOpened(WindowEvent e)  当窗口打开时，窗口的监视器调用该方法。

2. WindowAdapter适配器 .

适配器可以代替接口来处理事件，当Java提供处理事件的接口中多于一个方法时，Java相应地就提供一个适配器类，比如WindowAdapter类。适配器已经实现了相应的接口，例如WindowAdapter类实现了WindowListener接口。因此，可以使用WindowAdapte的子类创建的对象做监视器，在子类中重写所需要的接口方法即可。

匿名类实例或窗口做监视器：

匿名类的方便之处是匿名类的外嵌类的成员变量在匿名类中仍然有效，当发生事件时，监视器就比较容易操作事件源所在的外嵌类中的成员.当事件的处理比较简单、系统也不复杂时，使用匿名类做监视器是一个不错的选择。

让事件源所在的类的实例作为监视器，能让事件的处理比较方便，这是因为，监视器可以方便的操作事件源所在的类中的其他成员。当事件的处理比较简单，系统也不复杂时，让事件源所在的类的实例作为监视器是一个不错的选择。

事件总结：

1．授权模式

Java的事件处理是基于授权模式，即事件源调用调用方法将某个对象注册为自己的监视器。

2．接口回调

addXXXListener(XXXListener listener)方法中的参数是一个接口，listener可以引用任何实现了该接口的类所创建的对象，当事件源发生事件时，接口listener立刻回调被类实现的接口中的某个方法。

3.方法绑定

当事件源触发事件发生后，监视器准确知道去调用哪个方法。

4.保持松耦合

当事件源触发事件发生后，系统知道某个方法会被执行，但无须关心到底是哪个对象去调用了这个方法，因为任何实现接口的类的实例(做为监视器)都可以调用这个方法来处理事件

 

 使用MVC结构 ：

 模型-视图-控制器（Model-View-Controller），简称为MVC。

   MVC是一种先进的设计结构，其目的是以会话形式提供方便的GUI支持。

   MVC是一种通过三个不同部分构造一个软件或组件的理想办法：

▶模型(model)  用于存储数据的对象。

▶视图(view)   为模型提供数据显示的对象。

▶控制器(controller)处理用户的交互操作，对于用户的操作作出响应，让模型和视图进行必要的交互，即通过视图修改、获取模型中的数据；当模型中的数据变化时，让视图更新显示。

对话框 ：

JDialog类和JFrame都是Window的子类，二者的实例都是底层容器。

JDialog类创建的对话框必须要依赖于某个窗口。

对话框分为无模式和有模式两种。

有模式的对话框：当这个对话框处于激活状态时，只让程序响应对话框内部的事件，而且将堵塞其它线程的执行，用户不能再激活对话框所在程序中的其它窗口，直到该对话框消失不可见。

无模式对话框：当这个对话框处于激活状态时，能再激活其它窗口，也不堵塞其它线程的执行。

消息对话框 :

消息对话框是有模式对话框，进行一个重要的操作动作之前,最好能弹出一个消息对话框。可以用javax.swing包中的JOptionPane类的静态方法:

    public static void showMessageDialog(

                       Component parentComponent,

                       String message,

                       String title,

                       int messageType)

创建一个消息对话框。

输入对话框 :

输入对话框含有供用户输入文本的文本框、一个确认和取消按钮，是有模式对话框 。

可以用javax.swing包中的JOptionPane类的静态方法：

  public static String showInputDialog(Component parentComponent,

                                      Object message,

                                      String title,

                                      int messageType)

  创建一个输入对话框。

确认对话框 :

确认对话框是有模式对话框。

可以用javax.swing包中的JOptionPane类的静态方法:

public static int showConfirmDialog(Component parentComponent,

                                    Object message,

                                    String title,

                                    int optionType)

 得到一个确认对话框。

颜色对话框:

 可以用javax.swing包中的JColorChooser类的静态方法: public static Color showDialog（Component component,        

                                        String title,

                                        Color initialColor）

创建一个有模式的颜色对话框  。

自定义对话框:

创建对话框与创建窗口类似，通过建立JDialog的子类来建立一个对话框类，然后这个类的一个实例，即这个子类创建的一个对象，就是一个对话框。对话框是一个容器，它的默认布局是BorderLayout，对话框可以添加组件，实现与用户的交互操作。

构造对话框的2个常用构造方法

JDialog() 构造一个无标题的初始不可见的对话框，对话框依赖一个默认的不可见的窗口，该窗口由Java运行环境提供。

JDialog(JFrame owner) 构造一个无标题的初始不可见的无模式的对话框，owner是对话框所依赖的窗口，如果owner取null，对话框依赖一个默认的不可见的窗口，该窗口由Java运行环境提供。

树组件与表格组件:

树组件:

1. DefaultMutableTreeNode节点

DefaultMutableTreeNode类的两个常用的构造方法是：

DefaultMutableTreeNode(Object userObject)

DefaultMutableTreeNode(Object userObject,boolean allowChildren)

2．树上的TreeSelectionEvent事件

使用addTreeSelectionListener(TreeSelectionListener listener)方法获得一个监视器。

表格组件:

表格组件以行和列的形式显示数据，允许对表格中的数据进行编辑。表格的模型功能强大、灵活并易于执行。表格是最复杂的组件，对于初学者，这里只介绍默认的表格模型。

JTable有7个构造方法，这里介绍常用的三个。

     JTable() 创建默认的表格模型。

     JTable(int a,int b) 创建a行,b列的默认模型表格

     JTable (Object data[][],Object  columnName[]) 创建默认表格模型对象，并且显示由data指定的二维数组的值，其列名由数组columnName指定。

通过对表格中的数据进行编辑，可以修改表格中二维数组data中对应的数据数据。在表格中输入或修改数据后，需按回车或用鼠标单击表格的单元格确定所输入或修改的结果。当表格需要刷新显示时，让表格调用repaint方法。

按钮绑定到键盘 :

(1) 获取输入映射.   按钮首先调用

   public final InputMap getInputMap(int condition)  

   方法返回一个InputMap对象.

（2）绑定按钮的键盘操作.   步骤（1）返回的输入映射首先调用方法

   public void put(KeyStroke keyStroke,Object actionMapKey)

  将敲击键盘上的某键指定为按钮的键盘操作.

（3）为按钮的键盘操作指定监视器.    按钮调用方法

    public final ActionMap getActionMap()

    返回一个ActionMap对象：

    ActionMap actionmap = button.getActionMap();

    然后，该对象actionmap调用方法：

    public void put(Object key,Action action)

    为按钮的键盘操作指定监视器

打印组件:

步骤如下：

1.获取ToolKit对象

让组件调用getToolkit()方法返回系统提供的Toolkit对象。

2.获得PrintJob对象

Toolkit对象调用getPrintJob()方法返回一个PrintJob对象。

3.获取Graphics对象

PrintJob对象使用getGraphics()方法获得一个Graphics对象。

4.打印组件

步骤3获取的Graphics对象是g，组件调用

paintAll(g)

将打印出该组件及其子组件。如果调用方法：

pain(g)

平台无关：

在一个计算机上编译得到的字节码文件可以复制到任何一个安装了Java运行环境的计算机上直接使用。字节码由Java虚拟机负责解释运行，即Java虚拟机负责将字节码翻译成本地计算机的机器码，并将机器码交给本地的操作系统来运行。

Java程序的开发步骤 ：

1.编写源文件:扩展名必须是.java。

2.编译Java源程序:用Java编译器（javac.exe）编译源文件，得到字节码文件。

3.运行Java程序:使用Java解释器（java.exe）来解释执行字节码文件。  

保存源文件：

如果源文件中有多个类，那么只能有一个类是public类；如果有一个类是public类，那么源文件的名字必须与这个类的名字完全相同，扩展名是java；如果源文件没有public类，那么源文件的名字只要和某个类的名字相同，并且扩展名是java就可以了

标识符：

用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符，简单地说，标识符就是一个名字 .

标识符由字母、下划线、美元符号和数字组成，长度不受限制。

标识符的第一个字符不能是数字字符。

标识符不能是关键字（关键字见下面的2.1.3节）

标识符不能是true、false和null（尽管true、false和null不是关键字）

这8种基本数据类型习惯上可分为以下四大类型：

  逻辑类型：boolean

  整数类型：byte、short、int、long

  字符类型：char

  浮点类型：float、double

1．int 型

          对于int型变量，内存分配给4个字节（byte），占32位。

2．byte 型  

        常量：Java中不存在byte型常量的表示法，但可以把一定范围内的int型常量

          赋值给byte型变量。  

        变量：使用关键字byte来声明byte 型变量  

          例如： byte x= -12,tom=28,漂亮=98;

          对于byte型内存分配给1个字节，占8位 。

3 ．short 型

        常量：和byte型类似，Java中也不存在short型常量的表示法，但可以把一定

          范围内的int型常量赋值给short型变量。

        变量：使用关键字short来声明short型变量

          例如： short x=12,y=1234;

          对于short型变量，内存分配给2个字节，占16位.

4. long 型

        常量：long型常量用后缀L来表示，例如108L(十进制)、07123L(八进制)、

          0x3ABCL(十六进制) 。

        变量：使用关键字long来声明long型变量，

          例如： long width=12L,height=2005L,length;

          对于long型变量，内存分配给8个字节，占64位。

简单数据类型的级别与类型转换运算：

Java中数据的基本类型（不包括逻辑类型）按精度从“低”到“高”排列：

byte  short  char  int  long  float  double

★当把级别低的变量的值赋给级别高的变量时，系统自动完成数据类型的转换

★当把级别高的变量的值赋给级别低的变量时，必须使用显示类型转换运算。显示转换的格式：（类型名）要转换的值;

  例如

    int x=(int)34.89;

★当把一个int型常量赋值给一个byte和short型变量时，不可以超出这些变量的取值范围，否则必须进行类型转换运算；例如，常量128的属于int型常量，超出byte变量的取值范围，如果赋值给byte型变量，必须进行byte类型转换运算（将导致精度的损失），如下所示：

     byte a=(byte)128;

输入基本型数据 ：

  ◆可以使用Scanner类创建一个对象：

           Scanner reader=new Scanner(System.in);

  ◆reader对象调用下列方法，读取用户在命令行（例如，MS-DOS窗口）输入的各种基本类型数据：

 nextBoolean()、 nextByte()、 nextShort()、 nextInt()   

 nextLong()、nextFloat()、nextDouble()

输出基本型数据：

JDK1.5新增了和C语言中printf函数类似的输出数据的方法，格式如下：

     System.out.printf("格式控制部分"，表达式1，表达式2，…表达式n)

格式控制部分由格式控制符号：%d、%c、%f、%s和普通的字符组成，普通字符原样输出。格式符号用来输出表达式的值。

输出数据时也可以控制数据在命令行的位置，例如：%md输出的int型数据占m列；%m.nf输出的浮点型数据占m列，小数点保留n位。例如：System.out.printf("%d,%f",12, 23.78);

数组 ：

1 声明数组：

声明一维数组有下列两种格式：

数组的元素类型 数组名[];

数组的元素类型 [] 数组名;

例如：

float boy[];

char [] cat;

2 为数组分配元素 :

为数组分配元素的格式如下：

数组名 = new 数组元素的类型[数组元素的个数];

例如： boy = new float[4];

3数组的引用:

数组属于引用型变量，两个相同类型的数组如果具有相同的引用，它们就有完全相同的元素

 

instanceof 运算符是二目运算符，左面的操作元是一个对象；右面是一个类。当左面的对象是右面的类或子类创建的对象时，该运算符运算的结果是true ，否则是false。

Java里的语句可分为以下六种：

1．方法调用语句。如：System.out.println(" Hello");

2．表达式语句   表示式尾加上分号。比如赋值语句：x=23;

3．复合语句

  可以用{  }把一些语句括起来构成复合语句，如：

       {   z=123+x;

           System.out.println("How are you");

        }

4．空语句。 一个分号也是一条语句，称做空语句。

5．控制语句。控制语句分为条件分支语句、开关语句和循环语句。

6．package语句和 import语句。它们和类、对象有关

for语句与数组 ：

 JDK1.5后,对for语句的功能给予扩充、增强，以便更好地遍历数组。语法格式如下：

for(声明循环变量：数组的名字) {

…

}

其中，声明的循环变量的类型必须和数组的类型相同。这种形式的for语句类似自然语言中的“for each”语句，为了便于理解上述for语句，可以将这种形式的for语句中翻译成“对于循环变量依次取数组的每一个元素的值”。

 类体：

◆类体的内容由两部分构：一部分是变量的声明，用来刻画属性；另一部分是方法的定义，用来刻画行为功能

类体中变量声明部分所声明的变量被称作成员变量和类的成员变量不同的是，局部变量只在方法内有效，而且与其声明的位置有关如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，即该成员变量在这个方法内暂时失效。如果想在该方法中使用被隐藏的成员变量，必须使用关键字this（在4.9节this关键字）

局部变量没有默认值：

成员变量有默认值（见后面的4.3节），但局部变量没有默认值，因此在使用局部变量之前，必须保证局部变量有具体的值

   对成员变量的操作只能放在方法中，方法可以对成员变量和该方法体中声明的局部变量进行操作。在声明成员变量时可以同时赋予初值，但是不可以在类体中有单独的赋值语句（不可以有变量的声明和方法的定义以外的其它语句）

构造方法与对象的创建 ：

   类是面向对象语言中最重要的一种数据类型，那么就可以用它来声明变量。在面向对象语言中，用类声明的变量被称作对象。和基本数据类型不同，在用类声明对象后，还必须要创建对象，即为声明的对象分配变量(确定对象所具有的属性)，当使用一个类创建一个对象时，也称给出了这个类的一个实例。通俗的讲，类是创建对象的“模板”，没有类就没有对象。构造方法和对象的创建密切相关

构造方法 ： 构造方法是一种特殊方法，它的名字必须与它所在的类的名字完全相同，而且没有类型。允许一个类中编写若干个构造方法，但必须保证他们的参数不同，即参数的个数不同，或者是参数的类型不同。

创建对象 ：    

创建一个对象包括对象的声明和为对象分配变量两个步骤。

1. 对象的声明
2. 为声明的对象分配变量

使用对象 ：

1．对象操作自己的变量（体现对象的属性）

   通过使用运算符“.” 对象操作自己的变量（对象的属性）

2．对象调用类中的方法（体现对象的行为）

   对象创建之后，可以使用点运算符“.”调用创建它的类中的方法，从而产生一定的行为（功能）.

3． 体现封装

    当对象调用方法时，方法中出现的成员变量就是指分配给该对象的变量。在讲述类的时候讲过：类中的方法可以操作成员变量。当对象调用方法时，方法中出现的成员变量就是指分配给该对象的变量。

 对象的引用和实体 ：

当用类创建一个对象时，类中的成员变量在分配内存空间，这些内存空间称作该对象的实体或对象的变量，而对象中存放着引用。一个类创建的两个对象，如果具有相同的引用，那么就具有完全相同的实体。

参数传值：

 方法中最重要的部分之一就是方法的参数，参数属于局部变量，当对象调用方法时，参数被分配内存空间，并要求调用者向参数专递值，即方法被调用时，参数变量必须有具体的值。

 传值机制 ：

 在Java中，方法的所有参数都是“传值”的，也就是说，方法中参数变量的值是调用者指定的值的拷贝。例如，如果向方法的int型参数x传递一个int值，那么参数x得到的值是传递的值的拷贝。

基本数据类型参数的传值 ：

对于基本数据类型的参数，向该参数传递的值的级别不可以高于该参数的级别 。

引用类型参数的传值：

当参数是引用类型时，“传值”传递的是变量中存放的“引用”，而不是变量所引用的实体

对象的组合  :

一个类可以把对象作为自己的成员变量，如果用这样的类创建对象，那么该对象中就会有其它对象，也就是说该对象将其他对象作为自己的组成部分，或者说该对象是由几个对象组合而成。

组合与复用  :

如果一个对象a组合了对象b，那么对象a就可以委托对象b调用其方法，即对象a以组合的方式复用对象b的方法。例如，圆锥对象在计算体积时，首先委托圆锥的底（一个Circle对象）bottom调用getArea()方法计算底的面积，然后圆锥对象再计算出自身的体积

实例变量和类变量的声明:

在声明成员变量时，用关键字static给予修饰的称作类变量，否则称作实例变量（类变量也称为static变量，静态变量）。

实例变量和类变量的区别:

1．不同对象的实例变量互不相同

2．所有对象共享类变量

3．通过类名直接访问类变量

实例方法和类方法的定义:

类中的方法也可分为实例方法和类方法。方法声明时，方法类型前面不加关键字static修饰的是实例方法、加static关键字修饰的是类方法(静态方法)。

实例方法和类方法的区别 :

1．对象调用实例方法

   当对象调用实例方法时，该方法中出现的实例变量就是分配给该对象的实例变量；该方法中出现的类变量也是分配给该对象的变量，只不过这个变量和所有的其他对象共享而已。

2．类名调用类方法

从而类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。和实例方法不同的是，类方法不可以操作实例变量，这是因为在类创建对象之前，实例成员变量还没有分配内存。

方法重载的语法规则 :

方法重载的意思是：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同

this关键字 :

this是Java的一个关键字，表示某个对象。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象.当this关键字出现实例方法中时，this就代表正在调用该方法的当前对象。

在构造方法中使用this  :

this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。

在实例方法中使用this  :

实例方法必须只能通过对象来调用，不能用类名来调用。当this关键字出现实例方法中时，代表正在调用该方法的当前对象。

实例方法可以操作类的成员变量，当实例成员变量在实例方法中出现时，默认的格式是：this.成员变量;

当static成员变量在实例方法中出现时，默认的格式是：

     类名.成员变量;

包 :

包是Java语言中有效地管理类的一个机制。

包名的目的是有效的区分名字相同的类。不同Java源文件中两个类名字相同时，它们可以通过隶属不同的包来相互区分。

包语句 :

通过关键字package声明包语句。

       package语句作为Java源文件的第一条语句， 为该源文件中声明的类指定包名。  import 语句 :

  一个类可能需要另一个类声明的对象作为自己的成员或方法中的局部变量，如果这两个类在同一个包中，当然没有问题。

   如果一个类想要使用的那个类和它不在一个包中，要使用import语句完成使命。

引入自定义包中的类 :

用户程序也可以使用import语句引入非类库中有包名的类，如：

   import tom.jiafei.*;

访问权限 :

  当用一个类创建了一个对象之后，该对象可以通过“.”运算符操作自己的变量、使用类中的方法，但对象操作自己的变量和使用类中的方法是有一定限制的。

何谓访问权限 :

   所谓访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符使用类中的方法。访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法。

私有变量和私有方法 :

用关键字private修饰的成员变量和方法称为私有变量和私有方法。

对于私有成员变量或方法，只有在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法。

某个类在另外一个类中创建对象后，如果不希该对象直接访问自己的变量，即通过“.”运算符来操作自己的成员变量，就应当将该成员变量访问权限设置为private。面向对象编程提倡对象应当调用方法来改变自己的属性，类应当提供操作数据的方法，这些方法可以经过精心的设计，使得对数据的操作更加合理

共有变量和共有方法 :

用public修饰的成员变量和方法被称为共有变量和共有方法 。

我们在任何一个类中用类Tom 创建了一个对象后，该对象能访问自己的public变量和类中的public方法（也可以通过类名来操作成员变量、方法） 。

友好变量和友好方法:

当在另外一个类中用类Tom 创建了一个对象后，如果这个类与Tom类在同一个包中，那么该对象能访问自己的友好变量和友好方法。 在任何一个与Tom同一包中的类中，也可以通过Tom类的类名访问Tom类的类友好成员变量和类友好方法。

受保护的成员变量和方法:

用protected修饰的成员变量和方法被称为受保护的成员变量和受保护的方法

public类与友好类 :

类声明时，如果在关键字class前面加上public关键字，就称这样的类是一个public 类 。

可以在任何另外一个类中,使用public类创建对象。

如果一个类不加public修饰，这样的类被称作友好类。

在另外一个类中使用友好类创建对象时，要保证它们是在同一包中。

基本类型的类封装:

Java提供了基本数据类型相关的类，实现了对基本数据类型的封装。这些类分别是：Byte、Integer、Short、Long、Float、Double和Character类。这些类在java.lang包中。

对象数组:

如果程序需要某个类的若干个对象，比如Student类的10个对象，显然如下声明10个Student对象是不可取的：

Student stu1,stu2, stu3,stu4,stu5,stu6,stu7,stu8, stu9,stu10;

正确的做法是使用对象数组，即数组的元素是对象，例如：

       Student [] stu;

       stu = new Student[10];

需要注意的是，上述代码仅仅定义了数组stu有10个元素，并且每个元素都是一个Student类型的对象，但这些对象目前都是空对象，因此在使用数组stu中的对象之前，应当创建数组所包含的对象，例如：            

stu[0] = new Student();  

反编译和文档生成器 :

◆反编译器javap.exe可以将字节码反编译为源码，以便查看源码类中的public方法名字和public成员变量的名字，例如：

    javap java.awt.Button

使用javadoc.exe可以制做源文件类结构的html格式文档

jar文件 :

可以使用jar.exe命令把一些类的字节码文件压缩成一个jar文件，然后将这个jar文件存放到Java运行环境的扩展中，即将该jar文件存放在JDK安装目录的jre\lib\ext文件夹中。这样，Java应用程序就可以使用这个jar文件中的类来创建对象了

将C:\1000\moon\star目录中的TestOne.class 和TestTwo.class(二者包名是moon.star)压缩成一个jar文件：Jerry.jar的步骤:

1. 清单文件:hello.mf(保存到C:\1000)

Manifest-Version: 1.0

Class: moon.start.TestOne moon.star.TestTwo

Created-By: 1.6

  2.  使用jar命令来生成一个名字为Jerry.jar的文件

C:\1000> jar cfm Jerry.jar hello.mf moon\star\TestOne.class moon\star\TestTwo.class

子类与父类 :

  利用继承，可以先编写一个共有属性的一般类，根据该一般类再编写具有特殊属性的新类，新类继承一般类的状态和行为，并根据需要增加它自己的新的状态和行为。

由继承而得到的类称为子类，被继承的类称为父类（超类）。

声明子类 :

使用关键字extends来定义一个类的子类,格式如下：

     class 子类名  extends  父类名 {

           …

     }

类的树形结构:

 Java的类按继承关系形成树形结构这个树形结构中，根节点是Object类

    （Object是java.lang包中的类），即Object是所有类的祖先类。

除了Object类每个类有且仅有一个父类，一个类可以有多个或零个子类。如果一个类（除了Object类）的声明中没有使用extends关键字，这个类被系统默认为是Object的子类，即类声明“class A”与“class A extends Object”是等同的。

子类的继承性 ：

 所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己定义的任何实例方法操作。

所谓子类继承父类的方法作为子类中的一个方法，就好象它们是在子类中直接定义了一样，可以被子类中自己定义的任何实例方法调用。

子类和父类在同一包中的继承性 ：

如果子类和父类在同一个包中，那么，子类自然地继承了其父类中不是private的成员变量作为自己的成员变量，并且也自然地继承了父类中不是private的方法作为自己的方法，继承的成员变量或方法的访问权限保持不变。

子类和父类不在同一包中的继承性：

  如果子类和父类不在同一个包中，那么，子类继承了父类的protected、public成员变量做为子类的成员变量，并且继承了父类的protected、public方法为子类的方法，继承的成员或方法的访问权限保持不变。

子类与对象：

子类对象的特点

子类的构造方法创建一个子类的对象时，不仅子类中声明的成员变量被分配了内存，而且父类的成员变量也都分配了内存空间，但只将子类继承的那部分成员变量作为分配给子类对象的变量 。子类中有一部分方法是从父类继承的，这部分方法可以操作子类未继承的变量 。

成员变量的隐藏 ：

 对于子类可以从父类继承的成员变量，只要子类中声明的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量，子类自己声明定义的方法操作与父类同名的成员变量是指子类重新声明定义的这个成员变量。

方法重写（Override）：

  子类通过重写可以隐藏已继承的实例方法。

1．重写的语法规则

如果子类可以继承父类的某个实例方法，那么子类就有权利重写这个方法。

方法重写是指：子类中定义一个方法，这个方法的类型和父类的方法的类型一致或者是父类的方法的类型的子类型，并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同。

2．重写的目的

子类通过方法的重写可以隐藏继承的方法，子类通过方法的重写可以把父类的状态和行为改变为自身的状态和行为。

重写的注意事项 ：

重写父类的方法时，不允许降低方法的访问权限，但可以提高访问权限（访问限制修饰符按访问权限从高到低的排列顺序是：public、protected、友好的、private。）

用super操作被隐藏的成员变量和方法：

子类可以隐藏从父类继承的成员变量和方法，如果在子类中想使用被子类隐藏的成员变量或方法就可以使用关键字super。比如super.x、super.play()就是访问和调用被子类隐藏的成员变量x和方法play().

使用super调用父类的构造方法：

子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。

final关键字可以修饰类、成员变量和方法中的局部变量。

可以使用final将类声明为final类。final类不能被继承，即不能有子类。如：

   final class A {

      … …

   }

如果用final修饰父类中的一个方法，那么这个方法不允许子类重写。

如果成员变量或局部变量被修饰为final的，就是常量。

对象的上转型对象 ：
 假设，A类是B类的父类，当用子类创建一个对象，并把这个对象的引用放到父类的对象中时，比如：

A a;

a=new B();

 或

A a;

B b=new B();

a=b;

这时，称对象a是对象b的上转型对象

1．上转型对象不能操作子类新增的成员变量；不能调用子类新增的方法。

2．上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法。上转型对象操作子类继承的方法或子类重写的实例方法，其作用等价于子类对象去调用这些方法。因此，如果子类重写了父类的某个实例方法后，当对象的上转型对象调用这个实例方法时一定是调用了子类重写的实

继承与多态：

多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为

用关键字abstract修饰的类/方法称为abstract类/方法（抽象类）。如：

abstract class A {

  … …

}

注意：

1．abstract类中可以有abstract方法

2．abstract类不能用new运算创建对象

面向抽象编程 ：

  在设计一个程序时，可以通过在abstract类中声明若干个abstract方法，表明这些方法在整个系统设计中的重要性，方法体的内容细节由它的非abstract子类去完成。使用多态进行程序设计的核心技术之一是使用上转型对象，即将abstract类声明对象作为其子类的上转型对象，那么这个上转型对象就可以调用子类重写的方法。所谓面向抽象编程，是指当设计某种重要的类时，不让该类面向具体的类，而是面向抽象类，即所设计类中的重要数据是抽类声明的对象，而不是具体类声明的对象。Pillar类就是面向抽象类Geometry，Cirle和Rectangle 都是Geometry的子类．

 开-闭原则 ：

所谓“开-闭原则”(Open-Closed Principle)就是让设计的系统应当对扩展开放，对修改关闭。

在设计系统时，应当首先考虑到用户需求的变化，将应对用户变化的部分设计为对扩展开放，而设计的核心部分是经过精心考虑之后确定下来的基本结构，这部分应当是对修改关闭的，即不能因为用户的需求变化而再发生变化，因为这部分不是用来应对需求变化的。

 如果系统的设计遵守了“开-闭原则”，那么这个系统一定是易维护的，因为在系统中增加新的模块时，不必去修改系统中的核心模块。

接口 ：

  为了克服Java单继承的缺点，Java使用了接口，一个类可以实现多个接口。

  使用关键字interface来定义一个接口。接口的定义和类的定义很相似，分为接口的声明和接口体。

1．接口声明

接口通过使用关键字interface来声明，格式： interface 接口的名字

2．接口体

接口体中包含常量定义和方法定义两部分。

实现接口 ：

一个类通过使用关键字implements声明自己实现一个或多个接口。

class A implements Printable,Addable

如果一个类实现了某个接口，那么这个类必须重写该接口的所有方法。

 Java提供的接口都在相应的包中，通过import语句不仅可以引入包中的类，也可以引入包中的接口，例如：

import java.io.*;   不仅引入了java.io包中的类，也同时引入了该包中的接口

理解接口：

 接口的思想在于它可以要求某些类有相同名称的方法，但方法的具体内容（方法体的内容）可以不同，即要求这些类实现接口，以保证这些类一定有接口中所声明的方法（即所谓的方法绑定）。接口在要求一些类有相同名称的方法的同时，并不强迫这些类具有相同的父类。比如，各式各样的电器产品，它们可能归属不同的种类，但国家标准要求电器产品都必须提供一个名称为on的功能（为达到此目的，只需要求它们实现同一接口，该接口中有名字为on的方法），但名称为on的功能的具体行为由各个电器产品去实现。

接口回调是指：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法。实际上，当接口变量调用被类重写的接口方法时，就是通知相应的对象调用这个方法。

接口与多态:

  可以通过在接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。

接口参数 :

 如果一个方法的参数是接口类型，我们就可以将任何实现该接口的类的实例的引用传递给该接口参数，那么接口参数就可以回调类实现的接口方法。

 abstract类与接口的比较 ：

接口和abstract类的比较如下：

1．abstract类和接口都可以有abstract方法。

2．接口中只可以有常量,不能有变量；而abstract类中即可以有常量也可以有变量。

3．abstract类中也可以有非abstract方法,接口不可以。

 面向接口编程：

面向接口去设计程序，可以通过在接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。

使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。

内部类：

Java支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类成为内部类的外嵌类。某种类型的农场饲养了一种特殊种类的牛，但不希望其他农场饲养这种特殊种类的牛，那么这种类型的农场就可以将创建这种特殊种牛的类作为自己的内部类。

和子类有关的匿名类 ：

 Java允许我们直接使用一个类的子类的类体创建一个子类对象。

创建子类对象时，除了使用父类的构造方法外还有类体，此类体被认为是一个子类去掉类声明后的类体，称作匿名类。

假设Bank是类，那么下列代码就是用Bank的一个子类（匿名类）创建对象：

    new Bank () {          

        匿名类的类体

};

和接口有关的匿名类 ：

假设Computable是一个接口，那么，Java允许直接用接口名和一个类体创建一个匿名对象，此类体被认为是实现了Computable接口的类去掉类声明后的类体，称作匿名类。

下列代码就是用实现了Computable接口的类（匿名类）创建对象：

      new Computable() {

            实现接口的匿名类的类体

       } ;    

异常类 ：

所谓异常就是程序运行时可能出现一些错误，比如试图打开一个根本不存在的文件等，异常处理将会改变程序的控制流程，让程序有机会对错误作出处理。

异常对象可以调用如下方法得到或输出有关异常的信息：

 public String getMessage();

 public void printStackTrace();

 public String toString();  

try~catch语句：

 Java使用try~catch语句来处理异常，将可能出现的异常操作放在try~catch语句的try部分，将发生异常后的处理放在catch部分。

 try~catch语句的格式如下：

  try {

      包含可能发生异常的语句

 }

 catch(ExceptionSubClass1  e) {

    …

 }

 catch(ExceptionSubClass2  e) {

    …

 }

自定义异常类：

我们也可以扩展Exception类定义自己的异常类，然后规定哪些方法产生这样的异常。

一个方法在声明时可以使用throws关键字声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操作，即用相应的异常类创建对象，并使用throw关键字抛出该异常对象，导致该方法结束执行。

断言：

 断言语句用于调试代码阶段。在调试代码阶段让断言语句发挥作用，这样就可以发现一些致命的错误，当程序正式运行时就可以关闭断言语句，但仍把断言语句保留在源代码中，如果以后应用程又需要调试，可以重新启用断言语句。

使用关键字assert声明一条断言语句，断言语句有以下两种格式：

  assert booleanExpression;

  assert booleanExpression:messageException;

String类 ：

  Java专门提供了用来处理字符序列的String类。String类在java.lang包中，由于java.lang包中的类被默认引入，因此程序可以直接使用String类。需要注意的是Java把String类声明为final类，因此用户不能扩展String类，即String类不可以有子类。

String 类的常用方法：

1．public int length():获取一个字符串的长度

2．public boolean equals(String s):比较当前字符串对象的实体是否与参数s指定的字符串的实体相同                 

3．public boolean startsWith(String s)

   public boolean endsWith(String s)方法:判断当前字符串对象的前缀（后缀）是否参数s指定的字符串

    String tom = "天气预报，阴有小雨",jerry = "比赛结果，中国队赢得胜利";

    tom.startsWith(“天气”)的值是true；

    tom.endsWith("大雨")的值是false，

4. public int compareTo(String s):按字典序与参数s指定的字符串比较大小

     如果当前字符串与s相同，该方法返回值0；

     如果当前字符串对象大于s，该方法返回正值；

     如果小于s，该方法返回负值。

     例如，字符a在Unicode表中的排序位置是97、字符b是98，那么对于

        String str = "abcde";   str.compareTo("boy")小于0；

其相关方法 public int compareToIgnoreCase(String s)

5.public boolean contains(String s):判断当前字符串对象是否含有参数指定的字符串s 

        例如  tom=“student”；那么tom.contains(“stu”)的值就是true；

                   而tom.contains("ok")的值是false。

6. public int indexOf (String s):从当前字符串的头开始检索字符串s，并返回首次出现s的位置,其相关方法：

   indexOf(String s ,int startpoint)

   lastIndexOf (String s)

    例如 String tom = "I am a good cat"；

              tom.indexOf("a");//值是2

              tom.indexOf("good",2);//值是7

              tom.indexOf("a",7);//值是13

              tom.indexOf("w",2);//值是-1

7. public String substring(int startpoint):获得一个当前字符串的子串  

     其相关方法：substring(int start ,int end)

    例如：  String tom = "我喜欢篮球";

                  String s = tom.substring(1,3);

                  那么s是："喜欢"

1. public String trim() :得到一个s去掉前后空格后的字符串对象

符串与基本数据的相互转化：

java.lang包中的Integer类调用其类方法：

      public static int parseInt(String s)

可以将由“数字”字符组成的字符串，如“876”，转化为int型数据

可以使用String 类的类方法

        public static String valueOf(byte n)

       public static String valueOf(int n)

       public static String valueOf(long n)  

       public static String valueOf(float n)

对象的字符串表示 ：

 所有的类都默认是java.lang包中Object类的子类或间接子类。

Object类有一个public String toString()方法，一个对象通过调用该方法可以获得该对象的字符串表示。一个对象调用toString()方法返回的字符串的一般形式为：创建对象的类的名字@对象的引用的字符串表示

字符串与字符、字节数组：

String 类的构造方法：

◆ String(char[])和String(char[]，int offset，int length)分别用字符数组中的全部字符和部分字符创建字符串对象

◆ String类提供了将字符串存放到数组中的方法：

   public void getChars(int start,int end,char c[],int offset )

◆将字符串中的全部字符存放在一个字符数组中的方法：

public char[] toCharArray()

◆String(byte[])用指定的字节数组构造一个字符串对象。

   String(byte[]，int offset，int length) 用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。

◆public byte[] getBytes() 方法使用平台默认的字符编码，将当前字符串转化为一个字节数组。

◆ public byte[] getBytes(String charsetName) 使用参数指定字符编码，将当前字符串转化为一个字节数组。  

字符串的加密算法  ：

使用一个字符串password作为密码对另一个字符串sourceString进行加密 。将密码password存放到一个字符数组char [] p = password.toCharArray();

假设数组p的长度为n，那么就将待加密的字符串sourceString按顺序以n个字符为一组，对每一组中的字符用数组a的对应字符做加法运算。

正则表达式及字符串的替换与分解：

 1．正则表达式

一个正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称作正则表达式中的元字符。比如，“\\dcat”中的\\d就是有特殊意义的元字符，代表0到9中的任何一个。字符串对象调用 public boolean matches(String regex)方法可以判断当前字符串对象是否和参数regex指定的正则表达式匹配。

 2．字符串的替换

 字符串对象调用public String replaceAll(String regex,String replacement)方法返回一个字符串，该字符串是当前字符串中所有和参数regex指定的正则表达式匹配的子字符串被参数replacement指定的字符串替换后的字符串，例如：

     String s ="12hello567bird".replaceAll("[a-zA-Z]+","你好");

字符串的分解

 3.字符串调用public String[] split(String regex)使用参数指定的正则表达式regex做为分隔标记分解出其中的单词，并将分解出的单词存放在字符串数组中。

      例如，对于字符串str  

 String str = "1949年10月1日是中华人民共和国成立的日子";

如果准备分解出全部由数字字符组成的单词，就必须用非数字字符串做为分隔标记，因此，可以使用正则表达式：String regex="\\D+";

做为分隔标记分解出str中的单词：String digitWord[]=str.split(regex);

那么，digitWord[0]、digitWord[1]和digitWord[2]就分别是“1949”、“10”和“1”。

StringTokenizer类 ：

本节学习怎样使用StringTokenizer对象分解字符串。

StringTokenizer类在java.util包中，有两个常用的构造方法：

◆StringTokenizer（String s）：为字符串s构造一个分析器。使用默认的分隔标记，即空格符（若干个空格被看做一个空格）、换行符、回车符、Tab符、进纸符。

◆ StringTokenizer(String s, String delim)：为字符串s构造一个分析器。参数dilim中的字符被作为分隔标记 。

例如：

    StringTokenizer fenxi = new StringTokenizer("you are welcome");

    StringTokenizer fenxi = new StringTokenizer("you,are ; welcome",  ", ; ");

◆ StringTokenizer对象称作一个字符串分析器可以使用下列方法：

     nextToken()：逐个获取字符串中的语言符号（单词），字符串分析器中的负责计数的变量的值就自动减一  。

hasMoreTokens()：只要字符串中还有语言符号，即计数变量的值大于0，该方法就返回true，否则返回false。 countTokens()：得到分析器中计数变量的值。

  Scanner类：

使用Scanner类从字符串中解析程序所需要的数据。

    1．使用默认分隔标记解析字符串

       创建Scanner对象，并将要解析的字符串传递给所构造的对象,

     例如 String NBA = "I Love This Game";

     如下构造一个Scanner对象：

     Scanner scanner = new Scanner(NBA);

那么scanner将空格做为分隔标记来解析字符串中的单词，解析操作的特点如下：

◆ scanner调用next()方法依次返回NBA中的单词，如果NBA最后一个单词已被next()方法返回，scanner调用hasNext()将返回false，否则返回true。

◆  对于被解析的字符串中的数字型的单词，比如618，168.98等，scanner可以用nextInt()或nextDouble()方法来代替next()方法，即scanner可以调用nextInt()或nextDouble()方法将数字型单词转化为int或double数据返回。

◆ 如果单词不是数字型单词，scanner调用nextInt()或nextDouble()方法将发生InputMismatchException异常，在处理异常时可以调用next()方法返回该非数字化单词。

       例题13    使用Scanner对象解析字符串"TV cost 876 dollar.Computer cost 2398 dollar.telephone cost 1278 dollar"中的全部价格数字（价格数字的前后需有空格），并计算了总消费。

  2．使用正则表达式作为分隔标记解析字符串

       Scanner对象可以调用 useDelimiter(正则表达式); 方法将一个正则表达式作为分隔标记，即和正则表达式匹配的字符串都是分隔标记。

 Date类 ：

   Date类在java.util包中。

1.使用Date类的无参数构造方法创建的对象可以获取本地当前时间。 Date()

     例： Date nowTime=new Date();

当前nowTime对象中含有的日期、时间就是创建nowTime对象时的本地计算机的日期和时间。例如，假设当前时间是：2011年3月10日23:05:32（CST时区），那么

System.out.println(nowTime); 输出结果是：Thu Mar 10 23:05:32 CST 2011。

      Date对象表示时间的默认顺序是：星期、月、日、小时、分、秒、年

2.使用带参数的构造方法  Date(long time)

计算机系统将其自身的时间的“公元”设置在1970年1月1日0时（格林威治时间），可以根据这个时间使用Date的带参数的构造方法：Date(long time)来创建一个Date对象，例如：

        Date date1=new Date(1000), date2=new Date(-1000);

其中的参数取正数表示公元后的时间，取负数表示公元前的时间，例如1000表示1000毫秒，那么，date1含有的日期、时间就是计算机系统公元后1秒时刻的日期、时间。如果运行Java程序的本地时区是北京时区（与格林威治时间相差8个小时），那么上述date1就是1970年01月01日08时00分01秒、date2就是1970年01月01日07时59分59秒。

3.System类的静态方法 public long currentTimeMillis() 获取系统当前时间

Calendar类：

1  Calendar类在java.util包中。使用Calendar类的static方法 getInstance()可以初始化一个日历对象，如：

    Calendar calendar= Calendar.getInstance();

2 calendar对象可以调用方法：

   public final void set(int year,int month,int date)

   public final void set(int year,int month,int date,int hour,int minute)

   public final void set(int year,int month, int date, int hour, int minute,int second)

     将日历翻到任何一个时间

3 calendar对象常用方法

◆public int get(int field) ：可以获取有关年份、月份、小时、星期等信息

   例如：calendar.get(Calendar.MONTH); 返回一个整数，如果该整数是0表示当前日历是在一月，该整数是1表示当前日历是在二月等。

   例如：calendar.get(Calendar.DAY_OF_WEEK);返回一个整数，如果该整数是1表示星期日，如果是2表示是星期一，依次类推，如果是7表示是星期六。    

◆ public long getTimeInMillis() ：可以将时间表示为毫秒。 

format方法 ：

Formatter类的format方法：format(格式化模式, 日期列表)

按着“格式化模式”返回“日期列表”中所列各个日期中所含数据（年，月，日，小时等数据）的字符串表示。Java已经将format方法做为了String类的静态方法，因此，程序可以直接使用String类调用format方法对日期进行格式化。

1．格式化模式

format方法中的“格式化模式”是一个用双引号括起的字符序列（字符串）,该字符序列中的字符由时间格式符和普通字符所构成。例如："日期:%ty-%tm-%td"

String s = String.format("%tY年%tm月%td日",new Date(),new Date(),new Date()); 那么s就是"2011年02月10日

2．日期列表

format方法中的“日期列表”可以是用逗号分隔的Calendar对象或Date对象。 format方法默认按从左到右的顺序使用“格式化模式”中的格式符来格式“日期列表”中对应的日期，而“格式化模式”中的普通字符保留原样。

3.格式化同一日期     可以在“格式化模式”中使用“<”，比如："%ty-%，例如：String s = String.format("%ty年%

不同区域的星期格式 ：

如果想用特定地区的星期格式来表示日期中的星期，可以用format的重载方法：

format (Locale locale,格式化模式,日期列表);

其中的参数locale是一个Locale类的实例，用于表示地域。

Locale类的static常量都是Locale对象，其中US是表示美国的static常量。

比如，假设当前时间是2011-02-10，对于（%ta表示简称的星期）：

String s = String.format(Locale.US,"%ta(%

那么s是"Thu(2011-02-10)"，

对于（%tA表示全称的星期）

String s = String.format(Locale.JAPAN,"%tA(%

那么s是"木曜日(2011-02-10)"。

  Math类 ：

 Math类在java.lang包中。Math类包含许多用来进行科学计算的类方法，这些方法可以直接通过类名调用。另外，Math类还有两个静态常量，它们分别是：

E   2.7182828284590452354和PI    3.14159265358979323846。

以下是Math类的常用类方法：

* public static long abs(double a)  返回a的绝对值。

* public static double max(double a,double b) 返回a、b的最大值。

* public static double min(double a,double b) 返回a、b的最小值。

* public static double random()  产生一个0到1之间的随机数（不包括0和1）。

* public static double pow(double a,double b) 返回a的b次幂。

* public static double sqrt(double a) 返回a的平方根。

* public static double log(double a)  返回a的对数。

* public static double sin(double a) 返回正弦值。

* public static double asin(double a)  返回反正弦值。

 BigInteger类 ：

1 java.math包中的BigInteger类提供任意精度的整数运算。可以使用构造方法：

      public BigInteger(String val)  构造一个十进制的BigInteger对象。

2 以下是BigInteger类的常用类方法：

*public BigInteger add(BigInteger val)  返回当前大整数对象与参数指定的大整数对象的和。

*public BigInteger subtract(BigInteger val)返回当前大整数对象与参数指定的大整数对象的差。

* public BigInteger multiply(BigInteger val)返回当前大整数对象与参数指定的大整数对象的积。

*public BigInteger divide(BigInteger val)返回当前大整数对象与参数指定的大整数对象的商。

*public BigInteger remainder(BigInteger val)返回当前大整数对象与参数指定的大整数对象的余。

*public int compareTo(BigInteger val) 返回当前大整数对象与参数指定的大整数的比较结果，返回值是1、-1或0，分别表示当前大整数对象大于、小于或等于参数指定的大整数。

*public BigInteger abs()  返回当前大整数对象的绝对值。

*public BigInteger pow(int a)  返回当前大整数对象的a次幂。

*public String toString()  返回当前大整数对象十进制的字符串表示。

*public String toString(int p)  返回当前大整数对象p进制的字符串表示。

Random类 ：

  Java提供了更为灵活的用于获得随机数的Random类（该类在java.util包中）。 Random类的如下构造方法：

     public Random();

     public Random(long seed);使用参数seek指定的种子创建一个Random对象

     人们习惯地将Random对象称为随机数生成器。

◆ 返回一个随机整数   随机数生成器random调用不带参数的nextInt()方法：

      Random random=new Random();

      random.nextInt();

◆ 返回一个0至n之间（包括0，但不包括n）的随机数 随机数生成器random调用带参数的nextInt(int m)方法（参数m必须取正整数值）

    例如，random.nextInt(100);返回一个0至100之间的随机整数(包括0，但不包括100)。

◆ 随机得到true和false两个表示真和假的boolean值， 随机数生成器random调用nextBoolean()方法

   例如 random.nextBoolean();返回一个随机boolean值。

Formatter 类：

Formatter类提供了一个和C语言printf函数类似的format方法：

format（格式化模式,值列表）

该方法按着“格式化模式”返回“值列表”的字符串表示。

Java已经将format方法做为了String类的静态方法，因此，程序可以直接使用String类调用format方法对数字进行格式化。

1．格式化模式  format方法中的“格式化模式”是一个用双引号括起的字符序列(字符串),该字符序列中的字符由格式符和普通字符所构成。

例如："输出结果%d,%f,%d"中的%d和%f是格式符号 .

     format方法返回的字符串就是“格式化模式”中的格式符被替换为它得到的格式化结果后的字符串。例如：String s = String.format(“%.2f”,3.141592);那么s就是“3.14”.

2．值列表   format方法中的“值列表”是用逗号分隔的变量、常量或表达式。 例如：

String s=format("%d元%0.3f公斤%d台",888,999.777666,123); 那么,s就是"888元999.778公斤123台"。

3．格式化顺序

format方法默认按从左到右的顺序使用“格式化模式”中的格式符来格式化“值列表”中对应的值，而“格式化模式”中的普通字符保留原样。

例如，假设int型变量x和double型变量y的值分别是888和3.1415926，

那么对于String s = format("从左向右：%d,%.3f,%d",x,y,100);字符串s就是：从左向右：888,3.142,100

格式化整数：

1．%d，%o，%x和%格式符可格式化byte、Byte、short、Short、int、Integer、long和Long型数据，详细说明见Page204. 例如，对于：

String s = String.format("%d,%o,%x,%X",703576,703576,703576,703576);

字符串s就是：703576,2536130,abc58,ABC58

2．修饰符

加号修饰符"+"格式化正整数时，强制添加上正号,例如，%+d将123格式化为"+123"。

逗号修饰符“,”格式化整数时,按"千"分组，例如，对于：

String s=String.format("按千分组:%,d。按千分组带正号%+,d",1235678,9876);

字符串s就是：按千分组:1,235,678。按千分组带正号+9,876

3．数据的宽度

数据的宽度就是format方法返回的字符串的长度。规定数据宽度的一般格式为“%md”,其效果是在数字的左面增加空格;或"%-md“,其效果是在数字的右面增加空格,

例如，将数字59格式化为宽度为8的字符串：String s=String.format("%8d",59);

字符串s就是："      59"，其长度（s.length()）为8，即s在59左面添加了6个空格字符。

对于：String s=String.format(“%-8d”,59);字符串s就是："59        ",其长度(s.length())为8。

对于：String s=String.format("%5d%5d%8d",59,60,90);字符串s就是："   59   60      90"(长度为18

格式化浮点数 ：

1．%f,%e(%E),%g(%G)和%a(%A)格式符可格式化float、Float、double和Double:

   %f 将值格式化为十进制浮点数，小数保留6位。

   %e（%E） 将值格式化为科学记数法的十进制的浮点数（%E在格式化时将其中的指数符号大写，例如5E10）。

例如，对于：String s = String.format("%f,%e",13579.98,13579.98);

字符串s就是：13579.980000,1.357998e+04

2．修饰符

加号修饰符"+"格式化正数时,强制添加上正号,例如%+f将123.78格式化为"+123.78", %+E将123.78格式化为"+1.2378E+2"。 逗号修饰符“,”格式化浮点数时,将整数部分按“千”分组,

例如,对于：String s=String.format("整数部分按千分组: %+,f",1235678.9876);

字符串s就是：整数部分按千分组:+1,235,678.987600

3．限制小数位数与数据的“宽度”

     ◆  "%.nf"可以限制小数的位数,其中的n是保留的小数位数,例如%.3f将6.1256格式化为"6.126"（保留3位小数）。

 规定宽度的一般格式为“%mf”(在数字的左面增加空格),或“%-md”(在数字的右面增加空格)。

例如,将数字59.88格式化为宽度为11的字符串

String s=String.format(“%11f”,59.88); 字符串s就是："  59.880000"，其长度(s.length())为11。

String s=String.format(“%-11f”,59.88);字符串s就是： "59.880000  "，其长度(s.length())为11。

◆在指定宽度的同时也可以限制小数位数(%m.nf),

String s=String.format(“%11.2f”,59.88);  字符串s就是："      59.88"，即s在59.88左面添加了6个空格字符。

◆ 在宽度的前面增加前缀0,表示用数字0（不用空格）来填充宽度左面的富裕部分，例如：

String s=String.format(“%011f”,59.88); 字符串s就是："0059.880000"，其长度（s.length()）11

StringBuffer对象的创建：

StringBuffer类能创建可修改的字符串序列，该类的对象的实体的内存空间可以自动的改变大小，便于存放一个可变的字符序列。一个StringBuffer对象调用append方法可以追加字符序列，如图819所示。例如：

StringBuffer s = new StringBuffer("我喜欢");

s.append("玩篮球");   

StringBuffer类有三个构造方法：

1．StringBuffer()

2．StringBuffer(int size)

3．StringBuffer(String s)

StringBuffer类的常用方法：

1．StringBuffer append(String s):将一个字符串对象追加到当前StringBuffer对象中 StringBuffer append(int n)：将一个int型数据转化为字符串对象后再追加到当前StringBuffer对象中StringBuffer append(Object o)：将一个Object对象的字符串表示追加到当前StringBuffer对象中

类似的方法还有：

   StringBuffer append(long n),StringBuffer append(boolean n),

   StringBuffer append(float n),StringBuffer append(double n),

   StringBuffer append(char n)

2．public chat charAt(int n ):得到参数n指定的置上的单个字符

   public void setCharAt(int n ,char ch):将当前StringBuffer对象实体中的字符串位置n处的字符用参数ch指定的字符替换

3．StringBuffer insert(int index, String str) :将参数str指定的字符串插入到参数index指定的位置

4．public StringBuffer reverse() :将该对象实体中的字符翻转

5．StringBuffer delete(int startIndex, int endIndex):从当前StringBuffer对象实体中的字符串中删除一个子字符串

   其相关方法:deleteCharAt(int index) 删除当前StringBuffer对象实体的字符串中index位置处的一个字符。

1. StringBuffer replace(int startIndex,int endIndex,String str):将当前StringBuffer对象实体中的字符串的一个子字符串用参数str指定的字符串替换    

Pattern与Matcher类：

Java提供了专门用来进行模式匹配的Pattern类和Matcher类，这些类在java.util.regex包中。  以下结合具体问题来讲解使用Pattern类和Matcher类的步骤。假设有字符串：

String input = "hello,good morning,this is a good idea"

我们想知道input从哪个位置开始至哪个位置结束曾出现了字符串good。

使用Pattern类和Matcher类检索字符串str中的子字符串的步骤如下：

1．建立模式对象

使用正则表达式regex做参数得到一个称为模式的Pattern类的实例pattern：

例如：String regex = "good";

     Pattern pattern = Pattern.compile(regex);

模式对象是对正则表达式的封装。Pattern类调用类方法compile(String regex)返回一个模式对象，其中的参数regex是一个正则表达式, 称为模式对象使用的模式。

2．得到匹配对象

     模式对象pattern调用matcher(CharSequence input)方法返回一个Matcher对象matcher，称为匹配对象             

Matcher matcher = pattern.matcher(input);

Matcher对象matcher可以使用下列方法寻找字符串input中是否有和模式regex匹配的子序列（regex是创建模式对象pattern时使用的正则表达式）。

◆public boolean find():寻找input和regex匹配的下一子序列，如果成功该方法返回true，否则返回false。

◆ public boolean matches()：matcher调用该方法判断input是否完全和regex匹配。

◆ public boolean lookingAt()：matcher调用该方法判断从input的开始位置是否有和regex匹配的子序列。

◆ public boolean find(int start) : matcher调用该方法判断input从参数start指定位置开始是否有和regex匹配的子序列 。

◆ public String replaceAll(String replacement) matcher调用该方法可以返回一个字符串,该字符串是通过把input中与模式regex匹配的子字符串全部替换为参数replacement指定的字符串得到的.

◆ public String replaceFirst(String replacement) matcher调用该方法可以返回一个字符串，该字符串是通过把input中第1个与模式regex匹配的子字符串替换为参数replacement指定的字符串得到的。

使用Class实例化一个对象 ：

 Class是java.lang包中的类，该类的实例可以帮助程序创建其他类的实例或者取得其他类的对象的内部信息。

创建对象最常用的方式就是使用new运算符和类的构造方法，实际上也可以使用Class对象得到某个类的实例。步骤如下：

（1）使用Class的类方法得到一个和某类（参数className指定的类）相关的Class对象：

 public static Class forName(String className) throws ClassNotFoundException

 上述方法返回一个和参数className指定的类相关的Class对象。

（2）步骤（1）中获得的Class对象调用

public Object newInstance() throws InstantiationException,IllegalAccessException

方法就可以得到一个className类的对象。要特别注意的是：使用Class对象调用newInstance()实例化一个className类的对象时，className类必须有无参数的构造方法。

获取类的有关信息 ：

Class对象经常调用的方法如下：

◆ String getName() 返回类的名字

◆ Constructor[] getDeclaredConstructors()  返回类的全部构造方法。

◆ Field[] getDeclaredFields()  返回类的全部成员变量。

◆ Method[] getDeclaredMethods()  返回类的全部方法。

 Java Swing概述 ：

 javax.swing包中JComponent类是java.awt包中Container类的一个直接子类、是java.awt包中Component类的一个间接子类，学习GUI编程主要是学习掌握使用Component类的一些重要的子类。以下是GUI编程经常提到的基本知识点 。

(1)Java把Component类的子类或间接子类创建的对象称为一个组件。

(2)Java把Container的子类或间接子类创建的对象称为一个容器。

(3)可以向容器添加组件。Container类提供了一个public方法：add( )，一个容器可以调用这个方法将组件添加到该容器中。

(4)容器调用removeAll()方法可以移掉容器中的全部组件；调用remove(Component c)方法可以移掉容器中参数c指定的组件。

(5)注意到容器本身也是一个组件，因此可以把一个容器添加到另一个容器中实现容器的嵌套。

(6)每当容器添加新的组件或移掉组件时，应当让容器调用validate()方法，以保证容器中的组件能正确显示出来

窗口 ：

Java提供的JFrame类的实例是一个底层容器，即通常所称的窗口。其他组件必须被添加到底层容器中，以便借助这个地层容器和操作系统进行信息交互。 JFrame类是Container类的间接子类。当需要一个窗口时，可使用JFrame或其子类创建一个对象

   JFrame常用方法 ：

JFrame() 创建一个无标题的窗口。

JFrame(String s) 创建标题为s的窗口。

public void setBounds(int a,int b,int width,int height 设置窗口的初始位置是(a,b)，即距屏幕左面a个像素、距屏幕上方b个像素；窗口的宽是width，高是height。

public void setSize(int width,int height) 设置窗口的大小。

public void setLocation(int x,int y) 设置窗口的位置，默认位置是(0,0)。

public void setVisible(boolean b) 设置窗口是否可见，窗口默认是不可见的。

public void setResizable(boolean b) 设置窗口是否可调整大小，默认可调整大小。

public void dispose() 撤消当前窗口，并释放当前窗口所使用的资源。

public void setExtendedState(int state) 设置窗口的扩展状态.

public void setDefaultCloseOperation(int operation)  该方法用来设置单击窗体右上角的关闭图标后，程序会做出怎样的处理。

菜单条、菜单、菜单项 ：

1．菜单条

    JComponent类的子类JMenubar负责创建菜单条，JFrame类有一个将菜单条放置到窗口中的方法:setJMenuBar(JMenuBar bar);该方法将菜单条添加到窗口的顶端

2．菜单:JComponent类的子类JMenu负责创建菜单, JMenu类的主要方法有以下几种

   public void add(JMenuItem item) 向菜单增加由参数item指定的菜单选项。

   public JMenuItem getItem(int n) 得到指定索引处的菜单选项。

   public int getItemCount() 得到菜单选项的数目。

3.菜单项

   JComponent类的子类JMenuItem负责创建菜单项,JMenuItem类的主要方法有以下几种：

  JMenuItem(String s) 构造有标题的菜单项。

  JMenuItem(String text, Icon icon) 构造有标题和图标的菜单项

  public void setAccelerator(KeyStroke keyStroke) 为菜单项设置快捷键。

常用组件 ：

1．文本框：由JComponent的子类JTextField创建文本框。

2．文本区：由JComponent的子类JTexArea创建文本区。

3．按钮：由JComponent的子类JButton类用来创建按钮。

4．标签：由JComponent的子类JLabel类用来创建标签。

5．选择框：由JComponent的子类JCheckBox类用来创建选择框。

6．单选按钮：由JComponent的子类JRadioButton类用来创建单项选择框。

7．下拉列表：由JComponent的子类JComboBox类用来创建下拉列表。

8．密码框：由JComponent的子类JPasswordField创建密码框。

密码框可以使用setEchoChar(char c)重新设置回显字符 。

密码框调用char[] getPassword()方法可以返回实际的密码

常用容器：

 JComponent是Container的子类，因此JComponent子类创建的组件也都是容器。容器经常用来添加组件。Jframe是底层容器，本节提到的容器被习惯地称做中间容器，中间容器必须被添加到底层容器中才能发挥作用。

1．JPanel 面板:使用JPanel创建面板，再向这个面板添加组件，然后把这个面板添加到其它容器中。JPanel面板的默认布局是FlowLayout布局。

2．滚动窗格JScrollPane:可以将文本区放到一个滚动窗格中。

 JScorollPane scroll=new JScorollPane(new JTextArea());

3．拆分窗格JSplitPane:窗格有两种类型：水平拆分和垂直拆分

JSplitPane的两个常用的构造方法：

  JSplitPane(int a,Component b,Component c)

  JSplitPane(int a, boolean b,Component c,Component d)  

4．JLayeredPane分层窗格:分层窗格使用

add(Jcomponent com, int layer);添加组件com，并指定com所在的层

public void setLayer(Component c,int layer)可以重新设置组件c所在的层

public int getLayer(Component c)可以获取组件c所在的层数。

常用布局：

 容器可以使用方法setLayout(布局对象);设置自己的布局,控制组件在容器中的位置。  

1．FlowLayout布局 :

1)创建布局对象 FlowLayout flow=new FlowLayout();

2)容器con使用布局对象con.setLayout(flow);

3)con可以使用Container类提供的add方法将组件顺序地添加到容器中;

FlowLayout布局对象调用相应的方法可以重新设置布局的对齐方式等.

2．BorderLayout布局 :

BorderLayout 布局是Window型容器的默认布局 。

使用BorderLayout布局的容器con，可以使用add方法将一个组件b添加到中心区域：con.add(b,BorderLayout.CENTER);或  con.add(BorderLayour.CENTER,b);

3．CardLayout 布局 :  使用CardLayout的一般步骤如下：

  1)创建CardLayout对象 CardLayout card=new CardLayout();

  2)为容器设置布局 con.setLayout(card);

  3)容器调用add(String s,Component b)将组件b加入容器，并给出了显示该组件的代号s。

  4)布局对象card用CardLayout类提供的show()方法，显示容器con中组件代号为s的组件：card.show(con,s);

4．GridLayout布局 :

GridLayout布局策略是把容器划分成若干行乘若干列的网格区域，组件就位于这些划分出来的小格中。 GridLayout布局编辑器的一般步骤如下：

1)创建布局对象，指定划分网格的行数m和列数n GridLayout grid=new new GridLayout(10,8);

2)使用GridLayout布局的容器调用方法add(Component c)将组件c加入容器。

5．BoxLayout布局:

使用盒式布局的容器将组件排列在一行或一列 .BoxLayout布局的一般步骤如下：

1)创建布局对象，使用BoxLayou的构造方法BoxLayout(Container con，,int axis)可以创建一个盒式布局对象.

2)可以使用Box类的类（静态）方法 createHorizontalBox()获得一个具有行型盒式布局的盒式容器；  使用Box类的类（静态）方法 createVerticalBox()获得一个具有列型盒式布局的盒式容器。

3)控制盒式布局容器中组件之间的距离

Box类调用静态方法createHorizontalStrut(int width)可以得到一个不可见的水平Struct对象，称做水平支撑。 Box类调用静态方法createVertialStrut(int height)可以得到一个不可见的垂直Struct对象，称做垂直支撑。

例子5  Example9_5.java  WindowBoxLayout.java

两个列型盒式容器boxV1、boxV2和一个行型盒式容器baseBox。

在列型盒式容器的组件之间添加垂直支撑，控制组件之间的距离，将boxV1、boxV2添加到baseBox中，并在它俩之间添加了水平支撑。程序运行效果如图9.6。

6．null布局 :

空布局容器可以准确地定位组件在容器的位置和大小。组件调用setBounds(int a,int b,int width,int height)方法可以设置本身的大小和在容器中的位置。

处理事件：

学习组件除了要熟悉组件的属性和功能外，一个更重要的方面是学习怎样处理组件上发生的界面事件。当用户在文本框中键入文本后按回车键、单击按钮、在一个下拉式列表中选择一个条目等操作时，都发生界面事件。

程序有时需对发生的事件作出反应，来实现特定的任务，例如，用户单击一个名字叫“确定”或名字叫“取消”的按钮，程序可能需要作出不同的处理。

 事件处理模式 ：

1．事件源 :能够产生事件的对象都可以成为事件源 .

2．监视器 :事件源通过调用相应的方法将某个对象注册为自己的监视器。对于文本框，这个方法是：addActionListener(监视器);事件源注册监视器之后，相应的操作就会导致相应的事件的发生，并通知监视器，监视器就会作出相应的处理。

3．处理事件的接口:

监视器负责处理事件源发生的事件。监视器是一个对象，为了处理事件源发生的事件，监视器这个对象会自动调用一个方法来处理事件。 Java规定：为了让监视器这个对象能对事件源发生的事件进行处理，创建该监视器对象的类必须声明实现相应的接口，那么当事件源发生事件时，监视器就自动调用被类重写的某个接口方法

ActionEvent事件：

 1． ActionEvent事件源 :

文本框、按纽、菜单项、密码框和单选按纽都可以触发ActionEvent事件，即都可以成为ActionEvent事件的事件源。

2．注册监视器: 能触发ActionEvent事件的组件使用

addActionListener(ActionListener listen)

将实现ActionListener接口的类的实例注册为事件源的监视器。

3．ActionListener接口 :

ActionListener接口在java.awt.event包中,该接口中只有一个方法：

public void actionPerformed(ActinEvent e)

事件源触发ActionEvent事件后，监视器将发现触发的ActionEvent事件，然后调用接口中的方法：actionPerformed(ActinEvent e)对发生的事件作出处理。ActionEvent类事先创建的事件对象就会传递给该方法的参数e。  

4．ActionEvent类中的方法 :

public Object getSource() 调用该方法可以获取发生ActionEvent事件的事件源对象的引用。

public String getActionCommand() 调用该方法可以获取发生ActionEvent事件时，和该事件相关的一个命令字符串。

ItemEvent事件：

1．ItemEvent事件源 :选择框、下拉列表都可以触发ItemEvent事件。

2．注册监视器:能触发ItemEvent事件的组件使用

addItemListener(ItemListener listen)

将实现ItemListener接口的类的实例注册为事件源的监视器。

3．ItemListener接口 :

ItemListener接口在java.awt.event包中,该接口中只有一个方法：

public void itemStateChanged(ItemEvent e)

事件源触发ItemEvent事件后，监视器将发现触发的ItemEvent事件，然后调用接口中的itemStateChanged(ItemEvent  e)方法对发生的事件作出处理。ItemEvent类事先创建的事件对象就会传递给该方法的参数e。

4． ItemEvent类中的方法 :

getSource()方法返回发生Itemevent事件的事件源外

getItemSelectable()方法返回发生Itemevent事件的事件源。

 DocumentEvent事件：

1. DocumentEvent事件源 :文本区所维护的文档能触发DocumentEvent事件  

2．注册监视器:能触发DocumentEven事件的事件源使用

addDucumentListener(DocumentListener listen)

将实现DocumentListener接口的类的实例注册为事件源的监视器。

3．DocumentListener接口 :

DocumentListener接口在javax.swing.event包中，该接口中有三个方法：

public void changedUpdate(DocumentEvent e)    

public void removeUpdate(DocumentEvent e)

public void insertUpdate(DocumentEvent e)

MouseEvent事件：

任何组件上都可以发生鼠标事件，如：鼠标进入组件、退出组件、在组件上方单击鼠标、拖动鼠标等都触发鼠标事件，即导致MouseEvent类自动创建一个事件对象。

 1．使用MouseListener接口可以处理以下5种操作触发的鼠标事件

    在事件源上按下鼠标键、在事件源上释放鼠标键、在事件源上击鼠标键、鼠标进入事件源、鼠标退出事件源。

 ▶ MouseEvent 中有下列几个重要的方法：

   getX() 获取鼠标指针在事件源坐标系中的x-坐标。

   getY() 获取鼠标指针在事件源坐标系中的y-坐标。

   getModifiers() 获取鼠标的左键或右键。

   getClickCount() 获取鼠标被单击的次数。

   getSource() 获取发生鼠标事件的事件源。

 ▶事件源注册监视器的方法是addMouseListener(MouseListener listener)。

 ▶ MouseListener接口中有如下方法：

   mousePressed(MouseEvent) 负责处理在组件上按下鼠标键触发的鼠标事件

   mouseReleased(MouseEvent) 负责处理在组件上释放鼠标键触发的鼠标事件

   mouseEntered(MouseEvent) 负责处理鼠标进入组件触发的鼠标事件

   mouseExited(MouseEvent) 负责处理鼠标离开组件触发的鼠标事件

   mouseClicked(MouseEvent) 负责处理在组件上单击鼠标键触发的

2．使用MouseMotionListener接口可以处理以下两种操作触发的鼠标事件，  在事件源上拖动鼠标、在事件源上移动鼠标。

 ▶ 事件源注册监视器的方法是

    addMouseMotionListener(MouseMotionListener listener)。

 ▶ MouseMotionListener接口中有如下方法：

    mouseDragged(MouseEvent)  负责处理拖动鼠标触发的鼠标事件。

mouseMoved(MouseEvent)  负责处理移动鼠标触发的鼠标事件。

  焦点事件：

1．焦点事件源 :组件可以触发焦点事件。

2．注册监视器:组件可以使用

    addFocusListener(FocusListener listener)

注册焦点事件监视器。

3．FocusListener接口 :

   创建监视器的类必须要实现FocusListener接口，该接口有两个方法：

      public void focusGained(FocusEvent e)

      public void focusLost(FocusEvent e)

   当发生FocusEvent事件时，监视器调用类实现的接口中的相应方法。

 4．组件也可调用

       public boolean requestFocusInWindow()

方法可以获得输入焦点。

键盘事件：

当一个组件处于激活状态时，敲击键盘上一个键就导致这个组件触发键盘事件。

1.某个组件使用addKeyListener方法注册监视器。

2.接口KeyListener中有如下方法：

  public void keyPressed(KeyEvent e),

  public void keyTyped(KeyEvent e),

  public void KeyReleased(KeyEvent e)  

3.相关方法：

   public int getKeyCode()判断哪个键被按下、敲击或释放,返回一个键码值 。      

   getKeyChar()判断哪个键被按下、敲击或释放，返回键上的字符。

 窗口事件：

JFrame及子类创建的窗口可以调用

setDefaultCloseOperation(int operation);

方法设置窗口的关闭方式（如前面各个例子所示）.

但是setDefaultCloseOperation方式可能不能满足程序的需要，比如，用户单击窗口上的关闭图标时，可能程序需要提示用户是否需要保存窗口中的有关数据到磁盘等 .

1. WindowListener接口.

1.  public void windowActivated(WindowEvent e)  当窗口从非激活状态到激活时，窗口的监视器调用该方法。
2.  public void windowDeactivated(WindowEvent e)  当窗口激活状态到非激活状态时，窗口的监视器调用该方法。
3.  public void windowClosing(WindowEvent e)  当窗口正在被关闭时，窗口的监视器调用该方法。
4.  public void windowClosed(WindowEvent e)  当窗口关闭后，窗口的监视器调用该方法。（5） public void windowIconified(WindowEvent e)  当窗口图标化时，窗口的监视器调用该方法。

6） public void windowDeiconified(WindowEvent e)  当窗口撤消图标化时，窗口的监视器调用该方法。

7） public void windowOpened(WindowEvent e)  当窗口打开时，窗口的监视器调用该方法。

2. WindowAdapter适配器 .

适配器可以代替接口来处理事件，当Java提供处理事件的接口中多于一个方法时，Java相应地就提供一个适配器类，比如WindowAdapter类。适配器已经实现了相应的接口，例如WindowAdapter类实现了WindowListener接口。因此，可以使用WindowAdapte的子类创建的对象做监视器，在子类中重写所需要的接口方法即可。

匿名类实例或窗口做监视器：

匿名类的方便之处是匿名类的外嵌类的成员变量在匿名类中仍然有效，当发生事件时，监视器就比较容易操作事件源所在的外嵌类中的成员.当事件的处理比较简单、系统也不复杂时，使用匿名类做监视器是一个不错的选择。

让事件源所在的类的实例作为监视器，能让事件的处理比较方便，这是因为，监视器可以方便的操作事件源所在的类中的其他成员。当事件的处理比较简单，系统也不复杂时，让事件源所在的类的实例作为监视器是一个不错的选择。

事件总结：

1．授权模式

Java的事件处理是基于授权模式，即事件源调用调用方法将某个对象注册为自己的监视器。

2．接口回调

addXXXListener(XXXListener listener)方法中的参数是一个接口，listener可以引用任何实现了该接口的类所创建的对象，当事件源发生事件时，接口listener立刻回调被类实现的接口中的某个方法。

3.方法绑定

当事件源触发事件发生后，监视器准确知道去调用哪个方法。

4.保持松耦合

当事件源触发事件发生后，系统知道某个方法会被执行，但无须关心到底是哪个对象去调用了这个方法，因为任何实现接口的类的实例(做为监视器)都可以调用这个方法来处理事件

 

 使用MVC结构 ：

 模型-视图-控制器（Model-View-Controller），简称为MVC。

   MVC是一种先进的设计结构，其目的是以会话形式提供方便的GUI支持。

   MVC是一种通过三个不同部分构造一个软件或组件的理想办法：

▶模型(model)  用于存储数据的对象。

▶视图(view)   为模型提供数据显示的对象。

▶控制器(controller)处理用户的交互操作，对于用户的操作作出响应，让模型和视图进行必要的交互，即通过视图修改、获取模型中的数据；当模型中的数据变化时，让视图更新显示。

对话框 ：

JDialog类和JFrame都是Window的子类，二者的实例都是底层容器。

JDialog类创建的对话框必须要依赖于某个窗口。

对话框分为无模式和有模式两种。

有模式的对话框：当这个对话框处于激活状态时，只让程序响应对话框内部的事件，而且将堵塞其它线程的执行，用户不能再激活对话框所在程序中的其它窗口，直到该对话框消失不可见。

无模式对话框：当这个对话框处于激活状态时，能再激活其它窗口，也不堵塞其它线程的执行。

消息对话框 :

消息对话框是有模式对话框，进行一个重要的操作动作之前,最好能弹出一个消息对话框。可以用javax.swing包中的JOptionPane类的静态方法:

    public static void showMessageDialog(

                       Component parentComponent,

                       String message,

                       String title,

                       int messageType)

创建一个消息对话框。

输入对话框 :

输入对话框含有供用户输入文本的文本框、一个确认和取消按钮，是有模式对话框 。

可以用javax.swing包中的JOptionPane类的静态方法：

  public static String showInputDialog(Component parentComponent,

                                      Object message,

                                      String title,

                                      int messageType)

  创建一个输入对话框。

确认对话框 :

确认对话框是有模式对话框。

可以用javax.swing包中的JOptionPane类的静态方法:

public static int showConfirmDialog(Component parentComponent,

                                    Object message,

                                    String title,

                                    int optionType)

 得到一个确认对话框。

颜色对话框:

 可以用javax.swing包中的JColorChooser类的静态方法: public static Color showDialog（Component component,        

                                        String title,

                                        Color initialColor）

创建一个有模式的颜色对话框  。

自定义对话框:

创建对话框与创建窗口类似，通过建立JDialog的子类来建立一个对话框类，然后这个类的一个实例，即这个子类创建的一个对象，就是一个对话框。对话框是一个容器，它的默认布局是BorderLayout，对话框可以添加组件，实现与用户的交互操作。

构造对话框的2个常用构造方法

JDialog() 构造一个无标题的初始不可见的对话框，对话框依赖一个默认的不可见的窗口，该窗口由Java运行环境提供。

JDialog(JFrame owner) 构造一个无标题的初始不可见的无模式的对话框，owner是对话框所依赖的窗口，如果owner取null，对话框依赖一个默认的不可见的窗口，该窗口由Java运行环境提供。

树组件与表格组件:

树组件:

1. DefaultMutableTreeNode节点

DefaultMutableTreeNode类的两个常用的构造方法是：

DefaultMutableTreeNode(Object userObject)

DefaultMutableTreeNode(Object userObject,boolean allowChildren)

2．树上的TreeSelectionEvent事件

使用addTreeSelectionListener(TreeSelectionListener listener)方法获得一个监视器。

表格组件:

表格组件以行和列的形式显示数据，允许对表格中的数据进行编辑。表格的模型功能强大、灵活并易于执行。表格是最复杂的组件，对于初学者，这里只介绍默认的表格模型。

JTable有7个构造方法，这里介绍常用的三个。

     JTable() 创建默认的表格模型。

     JTable(int a,int b) 创建a行,b列的默认模型表格

     JTable (Object data[][],Object  columnName[]) 创建默认表格模型对象，并且显示由data指定的二维数组的值，其列名由数组columnName指定。

通过对表格中的数据进行编辑，可以修改表格中二维数组data中对应的数据数据。在表格中输入或修改数据后，需按回车或用鼠标单击表格的单元格确定所输入或修改的结果。当表格需要刷新显示时，让表格调用repaint方法。

按钮绑定到键盘 :

(1) 获取输入映射.   按钮首先调用

   public final InputMap getInputMap(int condition)  

   方法返回一个InputMap对象.

（2）绑定按钮的键盘操作.   步骤（1）返回的输入映射首先调用方法

   public void put(KeyStroke keyStroke,Object actionMapKey)

  将敲击键盘上的某键指定为按钮的键盘操作.

（3）为按钮的键盘操作指定监视器.    按钮调用方法

    public final ActionMap getActionMap()

    返回一个ActionMap对象：

    ActionMap actionmap = button.getActionMap();

    然后，该对象actionmap调用方法：

    public void put(Object key,Action action)

    为按钮的键盘操作指定监视器

打印组件:

步骤如下：

1.获取ToolKit对象

让组件调用getToolkit()方法返回系统提供的Toolkit对象。

2.获得PrintJob对象

Toolkit对象调用getPrintJob()方法返回一个PrintJob对象。

3.获取Graphics对象

PrintJob对象使用getGraphics()方法获得一个Graphics对象。

4.打印组件

步骤3获取的Graphics对象是g，组件调用

paintAll(g)

将打印出该组件及其子组件。如果调用方法：

pain(g)

将打印出该组件本身，但不打印子组件。

 发布GUI程序:

可以使用jar.exe把一些文件压缩成一个JAR文件，来发布我们的应用程序。

生成一个Jar文件的步骤如下：

1．首先用文本编辑器（比如Windows下的记事本）编写一个清单文件 ，扩展名为.mf，如Mymoon.mf 。

2．生成JAR文件

如果目录test下的字节码文件刚好是应用程序需要的全部字节码文件，也可以如下生成JAR文件：

  D:\test\jar cfm Tom.jar Mymoon.mf  *.class

可以将Tom.jar文件复制到任何一个安装了java运行环境的计算机上，只要用鼠标双击该文件就可以运行该java应用程序了

将打印出该组件本身，但不打印子组件。

 发布GUI程序:

可以使用jar.exe把一些文件压缩成一个JAR文件，来发布我们的应用程序。

生成一个Jar文件的步骤如下：

1．首先用文本编辑器（比如Windows下的记事本）编写一个清单文件 ，扩展名为.mf，如Mymoon.mf 。

2．生成JAR文件

如果目录test下的字节码文件刚好是应用程序需要的全部字节码文件，也可以如下生成JAR文件：

  D:\test\jar cfm Tom.jar Mymoon.mf  *.class

可以将Tom.jar文件复制到任何一个安装了java运行环境的计算机上，只要用鼠标双击该文件就可以运行该java应用程序了