南京晓庄Java期末知识点复习

第一章 Java 语言概述

java 面向对象

java 语言的特点：封装、继承、多态性

注释：

单行注释：//

多行注释：/**/

文档注释：/** **/

一个类只能有一个 main 入口方法,一个public方法

关键字：

private	私有的
protected	受保护的
public	公共的
abstract	声明抽象
class	类
extends	继承、扩展
final	最终、不可改变
implements	实现
interface	接口
native	本地
new	新、创建
static	静态
strictfp	严格、精准
synchronized	线程、同步
transicnt	短暂
volatile	易失
break	跳出、中断
continue	继续
return	返回
do	运行
while	循环
if	如果
else	否则
for	循环
instanceof	实例
switch	观察
case	返回观察里的结果
default	默认
try	捕捉异常
catch	处理异常
throw	抛出一个异常对象
throws	声明一个异常可能被抛出
import	引入
package	包
boolean	布尔型
byte	字节型
char	字符型
double	双精度型
float	浮点型
int	整型
long	长整型
short	短整型
null	空
TRUE	真
FALSE	假
super	父类、超类
this	本类
void	无返回值
goto	跳转
const	静态
native	本地

权限修饰符：

private<default<protected<public

第二章 Java 语法基础

标识符

标识符的设定规则：

1.字母(A_Z、az)、特殊符号($、_)和数字(0~9)

2.第 1 个符号不能为数字

3.不能为关键词、true、false、null

4.区分大小写

例：point4、5w、A%、thisPicture、$currentValue、OK、_23b、Y_123、＃length、a＋b、if

解：

5w 以数字开头了

A%包含其他特殊符号

#length 包含其他特殊符号

a+b 包含其他特殊符号

if 为关键字

所以以上几个均不能作为标识符

基本数据类型

变量：

成员变量：方法外部、类的内部定义的变量(全局级变量 private int i=0;或静态变量 private static String name=“lisi”)

局部变量：方法或语句块内部定义的变量

final 变量：final int aFinalVar = 0;

final 变量初始化后不能再改变

变量赋值示例：

int  i = 178;
long l = 8864L;   (8864l)
double d1 = 37.266;    
//其他表示方法：0.12,.12,12.,12.0
double d2 = 37.266D;   (37.266d)
double d3 = 26.77e3; //科学计数法：26.77*10 的三次方
float f = 87.363F; (87.363f) //如果不加 f，系统默认为 double
char c = 'd'; 
boolean b1 = true; 
boolean b2 = false; 

变量类型转换：
boolean 类型不能转换成任何其它数据类型。

⾃动类型转换：容量⼩的类型⾃动转换成容量⼤的数据类型

byte->short->char->int ->long-> float ->double

强制类型转换：容量⼤的类型转换成容量⼩的数据类型时，要加上强制转换符(),不然会出现数据丢失现象

程序示例：

class Test {
	public static void main(String args[]) {
		int a = 257;
		byte b = (byte)a;
		System.out.println("a=" + a);
		System.out.println("b=" + b);
	}
}

结果：

a=257
b=1    //因为 byte 类型的最大值就是 127，257 已经远远超过了 127
       //a 的二进制数为 00000000 00000000 00000001 00000001
       //b 只能显示小于等于 127 的部分，故 b 为          00000001

程序示例：

class Test {
	public static  void main(String args[]) {
		char c1 = ‘A’,  c2;     // A 的 ASCII 值为 65
		int i;
		i = (int) c1 + 1;
		c2 = (char) i;
		System.out.println(c1 + c2);
		System.out.println(c1 + “ ,” +c2); 
	}
}

结果：

131
A,B
/*
i=65+1
c2=B
c1+c2=65+66=131
*/

常量：
程序示例：

class Test {
    public static void main(String args[]) {
	System.out.println(“java\n 语\b 言");
//  \n 换行 \b 退格  
	System.out.println("java\r 语言");
// \r 回车
	System.out.println("java\t 语言");
// \t 制表符
	System.out.println("\\java 语言\\");
// \\表示\
	System.out.println("\'java 语言\'");
// \'两边都一样，表示单引号
	System.out.println("\"java 语言\"");
// \"表示双引号
    }
}

结果：

java
语 言
java
语言
java	语言
\java 语言\
'java 语言'
"java 语言"

运算符

算术运算符：

加法运算符 +  “op1 + op2”
减法运算符 -  “op1 - op2”
乘法运算符 *  “op1 * op2”
除法运算符 /  “op1 / op2”
求模运算符%  “op1 % op2” 计算余数

关系运算符：

大于       >     “op1 > op2”  
大于等于 >=  “op1 >= op2”  
小于       <     “op1 < op2”  
小于等于 <=  “op1 <= op2”  
等于       ==  “op1 == op2”  
不等于    !=   “op1 != op2”
优先级：
(>、>=、<、<=) > (==、!=)
关系运算符低于算术运算符

程序示例：

class Test {
	public static void main(String args[]) {
		int w=25, x=3;
		boolean y = w < x;
		boolean z = w >= w * 2 -x * 9;
		boolean cc = 'b' > 'a';
		System.out.println("w < x = " + y);
		System.out.println("z = " + z);
		System.out.println("cc = " + cc);
	}
}

结果：

w < x = false
z = true  //25≥50-27
cc = true

逻辑运算符：

优先级
(!) > (&&) > (||)//非、与、或 【注意短路】
(!)>算术运算符>关系运算符>(&&) > (||)

位运算符：
一般不考，就不写了哈

条件运算符：

op1 ? op2 : op3
若 op1 为真，则运算结果为 op2，否则为 op3

自增、自减运算：
程序示例：

float x =7, y=15, v1, v2;
v1 = x++;  //先把 x 赋给 v1，x 再加 1
v2 = ++y;  //先把 y+1，再赋给 v2

结果：

x=8    y=16
v1=7  v2=16

程序示例：

int i = 10; 
int n = i++%5;  //先进行 i%5，余数为 0，然后 i+1

结果：

i = 11, n = 0

程序示例：

int i = 10; 
int n = ++i%5;  //跟上面反过来

结果：

i = 11, n = 1

运算符优先级：

闰年判断程序：

条件符合下例两者之一
能被 4 整除，但不能被 100 整除
能被 4 整除，又能被 400 整除
(year%4==0 && year%100!=0) || year%400==0
(year%4!=0) || (year%100==0 && year%400!=0)

语句

选择：

if
else if
else
switch(XX){ //java 特有必须是 byte, char, short, int 类型
              //C 语⾔:字符,int
case 1 : XX ;break;
case 2: XX ;break;
default(可有可⽆): XX break;
}

循环：

 while (布尔表达式) {
	  循环体；
  }
 do {
	  循环体；
  } while(布尔表达式);
先执行循环体
后判断布尔表达式
循环体至少执行一次
 for (初始化部分;条件判断部分;迭代因子) {
	  循环体；
  }
for each
for(数据类型 别名： 要遍历的元素名称){
  
}
例：
int a[]=new int[]{1,2,3,4,5,6,7};
for(int a1:a){
  System.out.println(a1);
}

程序示例：

import java.io.IOException;
class Test {
	public static void main(String args[]) throws IOException {
	    char c;
	    StringBuffer buffer = new StringBuffer();
        //在进行输入时记得抛出异常
        //StringBuffer 用于字符串连接处理
            System.out.println(“输入一句子以.表示结束”);
	    do {
		    c = (char) System.in.read();
//system.in.read()方法的作用是从键盘读出一个字符，然后返回它的 ASCII 码
//用 System.in.read()时，我们在键盘上按下的任何一个键都会被当做是输入值，
//包括 Enter 键也会被当做是一个值！当我们按下 Enter 的时候，
//实际上发送两个键值：一个回车\t（13），一个是换行\n（10）
		    buffer.append(c);
	    } while (c != ‘.’);
	    System.out.println(“Output =  ” + buffer.toString());
	}
}

结果：

输入一句子以.表示结束
fdsfs.
Output = fdsfs.

程序示例：

//求 0~7 之间任意数的阶乘
import java.io.IOException;
class Test {
	public static void main(String args[]) throws IOException {
	    int i, n, sum=1;
	    System.out.println(“Please input(0~7):”);
        n = System.in.read();
	    n -= 48;  //把读进来的 ASCII 编码，换算成对应的数值
	    for (i = 1; i <= n; i++) 
		  sum *= i;
	    System.out.println(n + “!= ” + sum);
	}
}

结果：

Please input(0~7):
5
5!=120

程序示例：

//如果一个人出生于 1970 年，那么他这一辈子能有几个闰年(以 70 岁为寿命长度)
	int length = 70;
	int firstYear = 1970;
	int year;
	for (int i =0; i < length; i++) {
		year = firstYear + i;		
	     if((year%4==0&&year%100!=0)||year%400==0)
			System.out.println(year);
	}

结果：略略略
程序示例：

//求阶乘之和
import java.io.IOException;
class Test {
	public static void main(String args[]) throws IOException {
	    int n, sum, total=0;
	    System.out.println(“Please input(0~9):”);
           n = System.in.read();
	    n -= 48;
	    for (int j = 1; j <= n; j++) {
		  sum = 1;
		  for (int i = 1; i <=j; i++)
		      sum *= i;
		  total +=sum;
	    }
	    System.out.println(“各阶乘之和为: ” + total);
	}
}

结果：

Please input(0~9):
4
各阶乘之和为: 33

跳转：

将程序的执行跳转到其他部分的语句
break:     跳出(中止)循环
continue: 结束本次循环
return:    方法返回
throw:     抛出异常(Exception)

数组和字符串

创建数组：

声明和创建的联用: int[] a = new int[3];
默认赋初值
整型初值为0           int[] i = new int[3];
实型初值为0.0        float[] f = new float[3];
布尔型初值为false  boolean[] b = new boolean[3];
字符型初值为\u0000(不可见) char[] c = new char[3];

数组的常见操作：

声明数组；
int arr[]
数组初始化；
int [] arr={1,2,3,4}
int [] arr=new int[]{1,2,3,4}
查看数组⻓度；
arr.length;
for each 循环；
for(int a:arr){
  System.out.println(a);
  }
数组拷⻉方法一：
int [] arr2=arr1;
int[] arr2=Arrays.copyOf(arr,arr.length(⾃定义⻓度));
数组拷贝方法二：
int a[] = {2, 4, 6, 8};
int b[];
int[] c = {1, 3, 5, 7, 9};
b = a;
System.arraycopy(a, 1, c, 0, 3);
数组 a: 2 4 6 8
数组 b: 2 4 6 8
数组 c: 4 6 8 7 9

数组排序方法一：
Arrays.sort(arr);//默认升序
数组排序方法二：
int[] array = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 };
        for (int i = array.length; --i >= 0; ) {
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j+1]) {
                    int temp = array[j];  
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
将 int 数组转换为字符串；
Arrays.toString(arr);//可用于输出

多维数组：

方法一: 直接分配空间(new)
例 int a[][] = new int[2][3];
    a[0][0]  a[0][1] a[0][2]
    a[1][0]  a[1][1] a[1][2]
方法二: 从最高维开始，为每一维分配空间
例 int c[][] = new int[2][];
    c[0] = new int[4];
    c[1] = new int[3];
    c[0][0]  c[0][1] c[0][2] c[0][3]
    c[1][0]  c[1][1] c[1][2] 
注: 为数组分配空间需指定维数大小，至少最高维(最左边)大小
方法三：声明数组的同时初始化
例 int a[][] = {{1,2,3}, {3,4,5}};
    a[0][0]=1  a[0][1]=2 a[0][2]=3
    a[1][0]=3  a[1][1]=4 a[1][2]=5
例 String[][] cartoons =
       {
       { "Flint","Fred","Wim","Pebbles","Dino"},
       { "Rub","Barn","Bet", "Bam"},
       { "Jet","Geo","Jane","Elroy","Judy","Rosie", "Astro"},
       { "Sco","Sco",  "Shag", "Velma", "Fred", "Dap" }
       };

程序示例：

class Test {
	public static void main(String args[]) {
		int n=6, indent, i, j;
		int a[][] = new int[n][n];
		a[1][1]=1;
		for (i=2; i<n; i++) {
			a[i][1]=1;a[i][i]=1;
			for(j=1; j<i; j++)
				a[i][j]=a[i-1][j-1]+a[i-1][j];
		}
		indent=25;
		 for (i=1; i<n; i++) {
			for(int k=1; k<=indent; k++)
				System.out.print(" ");
			for(j=1; j<=i; j++)
				System.out.print(a[i][j]+" ");
			System.out.println();
			indent=indent-2;
		}
	}
}  

结果：

纵轴为i, 横轴为j
0   0   0    0   0   0
0   1   0    0	 0   0
0   1   1    0   0   0
0   1   2    1   0   0
0   1   3    3   1   0 
0   1   4    6   4   1

结果：

                         1 
                       1 1 
                     1 2 1 
                   1 3 3 1 
                 1 4 6 4 1 

命令行参数

JAVA应用程序的主方法(程序的入口) 
public static void main (String args[]) {…}
public static void main (String[] args) {…}

程序示例：

class Test {
	public static void main(String[] args) {
//这个void可以改成byte int等
		int len = args.length;  //输入参数的长度
		System.out.println(len);
		for (int i = 0; i < len; i++) 
			System.out.println(args[i]);
	}
}

程序示例：

import java.lang.NumberFormatException;
class Test {
public static void main(String[] args) throws NumberFormatException {
		int sum = 0;
		for (int i = 0; i < args.length; i++) 
			sum = sum + Integer.parseInt(args[i]);
		System.out.println(sum);
	}
}

结果：

1 2
3

输入输出

输⼊
Scanner s=new Scanner(System.in);
s.nextInt()
s.nextLine()    //输入到回车结束
s.nextFloat()
scanner.next()  //当输入到空格结束
输出
System.out.println("XX")

第三章 类

五个基本概念

对象（object）:包含变量和方法

类(class)：对象的一个特定实体

封装性：interface接口

继承性：extends继承

多态性：表现在继承中->方法的重写

表现在用一个类中->方法的重载

1.封装

通过private\default\protected\public

实现数据项和方法的隐藏

实现隐藏隔离、允许外部对类做有限的访问，开发者可以自由地改变类的内部实现

提高了代码的重用性

2.继承

通过extends

代码重用了、通过继承，实现对现实世界更加准确的建模

3.多态

一个对象变量可以指向多种实际类型对象的现象被成为“多态”

三个必要条件：继承、方法的重写、父类引用指向子类对象

多态的好处：

提高了代码的维护性，提高了代码的扩展性

代码示例：

class Shape { 
	void draw() {}
	 void erase() {} 
} 
class Circle extends Shape { 
	void draw() { 
	System.out.println("Circle.draw()"); 
	} 
	void erase() { 
	System.out.println("Circle.erase()"); } 
}
class Square extends Shape {
	void draw() {
		System.out.println("Square.draw()"); 
	}
	void erase() { 
	System.out.println("Square.erase()"); 
 	}
}
class Triangle extends Shape {
	void draw() { 
	System.out.println("Triangle.draw()"); 
 	}
  void erase() { 
	System.out.println("Triangle.erase()");
  }
}

public class Test {
  public static Shape randShape() {
    switch((int)(Math.random() * 3)) {
      //(int)(Math.random() * 3)返回0，1，2随机数
      //Math.random()随机产生一个浮点数
      default:
      case 0: return new Circle();
      case 1: return new Square();
      case 2: return new Triangle();
    }	
  }
  public static void main(String[] args) {
    Shape[] s = new Shape[9];
//先进行实例化，然后再进行调用
   for(int i = 0; i < s.length; i++)
      s[i] = randShape();
   for(int i = 0; i < s.length; i++)
      s[i].draw();
  }
} 

结果：

Circle.draw()
Triangle.draw()
Circle.draw()
Circle.draw()
Circle.draw()
Square.draw()
Triangle.draw()
Square.draw()
Square.draw()

类

类的定义格式

[修饰符] class 类名 [extends ⽗类名] [implements 接⼝名]{
// 类体，包括类的成员变量和成员⽅法
//成员变量
//成员方法
//get,set方法
//自己定义的方法
//无参和全参构造函数
//extends 继承一个
//implements 多个接口
}

程序示例：

class Stu{
//1 属性设为私有
private int age;
//2 ⽅法 get set 你⾃⼰定义的
public void setAge(int age) {
this.age =age;
}
public int getAge() {
return this.age;
}
//我⾃⼰定义的⽅法
public void myPrint() {
System.out.println("nihao");
}
//3 构造函数
public Stu() {
}
public Stu(int age) {
this.age=age;
}
}

类的修饰符：

public: 公共类，可以被其他类所使用
无修饰/默认说明：仅仅能在同一个包中的其他类引用
abstract：宣布该类不能被实例化
final：宣布该类不能有子类

类成员修饰符：

• public
• protected
• private
• 无修饰
• static
• final
  |名称|访问权修饰符|类本身|本包|子类|外部包|
  |:----|:----|:----|:----|:----|:----|
  |公共|public|||||
  |默认|—default|||||
  |保护|protected|||||
  |私有|private|||||

非访问控制修符
静态变量static:
独立于类的对象，可以直接根据类名调用,不用this.
例：
//静态变量
class S {
	static int A = 12, B = 34;
	static void print() { … }
}
class Test {
	public static void main(String args[]) {
	System.out.println(“A=“ + S.A + “ B=“ + S.B);
	S.print();
	}
}
//静态方法
class Test {
    
   	public static void print(int x) {
   		System.out.println(x);
   	}
    
   	public static void main(String args[]) {
		int x = 3;
		print(x);
	}

}

最终变量final
final变量: 定义一个常数，即变量值不能改变
final double AVOGADRO = 6.022e23;
final类: 不能有子类
final方法: 方法不能被重写(overriding)
1 基本类型变量使⽤final修饰了就不可变了
2 对于引⽤类型变量被final修饰了:引⽤变量引⽤不可变，但是引⽤对象的内容可以改变。
public class Test3 {
public static void main(String[] args) {
A a=new A();
a.a=3;
a.a=4;
}
}
final class A {
public int a=3;
}

易失变量volatile
可能同时被多个线程所控制和修改

类成员方法：
访问控制修饰符

公共访问控制符－public ：被所有类访问

默认访问控制符：被同一包中其他类访问

私有访问控制符－ private：被该类自身访问

保护访问控制符－ protected：该类自身、同一个包中的其他类、其他包中的子类访问

私有保护访问控制符－private protected：该类自身、所有子类访问

非访问控制修符

静态方法static：属于类的方法

最终方法final：不能被子类重新定义的方法

抽象方法abstract：只有方法说明，没有具体实现

本地方法native：以其他语言实现方法功能

同步方法synchronized：用于多线程程序中的协调和同步

方法的重载(overloading)/重写(overriding)

方法的重载：方法名相同，但方法的参数不同

public static int abs(int a)

public static long abs(long a)

public static float abs(float a)

public static double abs(double a)

构造方法就是方法的重载

1. 对象的实例化通过构造方法(constructor)来实现
2. 构造方法的名字与类名相同
3. 构造方法没有返回值
4. 构造方法可以有多个，构成方法的重载(overload)

class Qangle {
	int a, h;
	Qangle () {
    		a = 10; h = 20;
	}
	Qangle(int x, int y) {
		a = x; h = y;
	}
	Qangle(Qangle r) {
		a = r.width(); 
		h = r.height();
	}
	int width() { return a;}
	int height() {return h;}
}

方法重写的注意事项：
1.重写的方法必须要跟父类一模一样（包括返回值类型、方法名、参数列表）

2.重写的方法可以用@Override注释来标识

3.子类中重写的方法的访问权限不能低于父类中方法的访问权限

权限修饰符：private<默认（什么都不写)<protected<public

类的封装

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，⽽是通过该类提供getter setter的⽅法来 对隐藏的信息进⾏操作和访问

封装的实现步骤

（1）修改属性的可⻅性设为（private）

（2）创建getter/setter⽅法（⽤于属性的读写）（通过这两种⽅法对数据进⾏获取和设定，对象通过

调⽤这两种发⽅法实现对数据的读写）

（3）在getter/setter⽅法中加⼊属性控制语句（对属性值的合法性进⾏判断

就是get和set

类的继承

类的继承格式

class ⽗类 {
}
class ⼦类 extends ⽗类 {
}
子类的构造方法必须要对父类的构造方法进行调用,不管以任何形式,
否则编译出错，加个super()
子类可重新定义父类中已有的静态变量(static)
子类可重新定义父类中已有的实例变量

类成员访问修饰符与继承的关系
私有的(private)类成员不能被子类继承

公共的(public)和保护性的(protected)类成员能被子类继承，且子类和父类可以属于不同的包

无修饰的父类成员，仅在本包中才能被子类继承

构造函数不是类成员，所以不被继承

final/private方法不能被重写或隐藏

子类对象与父类对象
Classroom c = new MMClassroom();
(等价于)
MMClassroom c1 = new MMClassroom();
Classroom c = c1;

抽象类

• 抽象方法: 仅仅申明了方法，但未实现
• 有访问修饰词
• 返回值类型
• 方法名
• 参数列表
• 无方法体
  仅仅抽象类可以包含抽象方法

抽象类型的方法不能有方法体，也就是说不能有大括号，只能在子类里面被实现

抽象方法不能实例化

子类继承抽象类时，必须重写抽象方法，否则仍为抽象类

程序示例：

//抽象类
abstract class Graphics {
	abstract void parameter();
	abstract void area();
}
//子类
class Rectangle extends Graphics {
	double h, w;
	Rectangle (double u, double v) {
		h = u; w = v;
	}
	void parameter() {
		System.out.println(h + “ “ + w);
	}
	void area() { System.out.println(h*w); }
}
//子类
class Circle extends Graphics {
	double r; String c;
	Circle (double u, String v) {
		r = u; c = v;
	}
	void parameter() {
		System.out.println(r + “ “ + c); }
	void area() {
          System.out.println(Math.PI*r*r); }
}
//实例化
Rectangle rec = new Rectangle(1.0, 2.0);
Circle cir = new Circle(3.0, “Red”);
Graphics[] g = {rec, cir};
for (int i = 0; i < g.length; i++) {
    g[i].parameter();
    g[i].area();
}

接口

接口是对abstract类的进一步扩展

接口中的方法都是未实现的(类似于抽象方法)，目的是在实现接口的类之间建立一种协议

接口中的变量都是常量

定义：

[public] interface 接口名 {
	成员变量;
	方法声明;
 }
public: 无任何访问限制
无修饰: 仅限于本包中
接口变量默认都是“public static final”

 class 类名 implements 接口1, 接口2 …… {
	… … …
 }

程序示例：

//接口
interface Figure {
  double half=0.5,pi=3.14159;
  void parameter();
  void area();
}
//方法
class Triangle implements Figure {
  double b, h;
  Triangle (double u, double v) {
	b = u; h = v;
  }
  public void parameter() {
	System.out.println(b + “ “ + h);
  }
  public void area()
  {  System.out.println(half*h*b); }
}
//方法
class Circle implements Figure {
 double x, y, r;
 Circle(double u, double v, double m)
 { x=u; y=v; r=m; }
 public void parameter() 
 { System.out.println(x+“ “+y+“ “+r); }
 public void area()
 {  System.out.println(pi*r*r); }
}	
//实现
Triangle t  = new Triangle(2, 3);
Circle     c = new Circle(4, 5, 6);
Figure[] f  = {t, c};
for (int i =0; i < f.length; i++) {
	f[i].parameter();
	f[i].area();
}

接口还可以继承其他接口

interface DC {
	int add(int x, int y);
}
interface DB extends DC {
	int sub(int x, int y);
}
interface DA extends DB {
	int mul(int x, int y);
}
//到时候只要引用DA接口就可以使用所有接口的方法了

接口和抽象的区别：
接口要被子类实现implements，抽象类要被子类继承extends

接口中的变量权威公共静态常量public static，而抽象类中可有普通变量

接口中全为方法的声明，抽象类中可以有方法的实现

接口中不可以有构造函数，抽象类中可以有构造函数

接口可多实现，而抽象类必须被单继承

接口中方法全为抽象方法，而抽象类中也可由非抽象方法

关键字

**this关键字：**this指当前对象

应用：

调用变量：this.x=i; this.y=j;

对同一个对象执行多次方法调用：return this;

在一个构造函数中调用另一个构造函数：this(“tulip”, 10);

注意：

this只能在类重的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this

原因：static方法在类加载时就已经存在了，但是对象是在创建时才在内存中生成

super关键字：super关键字主要存在于子类方法中，用于指向子类对象中的父类对象；可以访问父类的属性、函数及构造函数

1.⼦⽗类存在着同名的成员（包括变量和⽅法）时，在⼦类中默认是访问⼦类的成员，可以通过super关键字指定访问⽗类的成员；

2.默认会先调⽤⽗类⽆参的构造⽅法，可以通过super关键字指定调⽤⽗类的构造⽅法。

常用的工具类

object类

Object类是所有类的⽗类,⾥⾯有很多⽅法

clone getClass toString equals hashCode notify notifyAll wait

finalize

1.getClass⽅法

public final Class getClass()

获取运⾏时类型,返回值为Class对象
2.hashCode⽅法

public int hashCode()

返回该对象的哈希码值，是为了提⾼哈希表的性能（HashTable）
3.equals⽅法

public boolean equals(Object obj)

判断两个对象是否相等，在Object源码中equals就是使⽤==去判断，所以在Object中equals是等价于 ==的，但是在String及某些类对equals进⾏了重写，实现不同的⽐较。
4.clone⽅法

protected Object clone() throws CloneNotSupportedException

此⽅法只实现了⼀个浅层拷⻉,对于基本类型字段成功拷⻉,但是如果是嵌套对象,只做了赋值,也就是只把 地址拷⻉了,所以没有成功拷⻉,需要⾃⼰重写clone⽅法进⾏深度拷⻉。
5.toString⽅法

public String toString()

返回⼀个String字符串,⽤于描述当前对象的信息,可以重写返回对⾃⼰有⽤的信息，默认返回的是当前对象的类名+hashCode的16进制数字。
6.wait⽅法

public final void wait() throws InterruptedException
public final void wait(long timeout) throws InterruptedException
public final void wait(long timeout, int nanos) throws InterruptedException

多线程时⽤到的⽅法，作⽤是让当前线程进⼊等待状态，同时也会让当前线程释放它所持有的锁。直到其他
线程调⽤此对象的 notify() ⽅法或 notifyAll() ⽅法，当前线程被唤醒

7.notify⽅法

public final void notify()

多线程时⽤到的⽅法，唤醒该对象等待的某个线程
8.notifyAll⽅法

public final void notifyAll()

多线程时⽤到的⽅法，唤醒该对象等待的所有线程
9.finalize

protected void finalize() throws Throwable

对象在被GC释放之前⼀定会调⽤finalize⽅法，对象被释放前最后的挣扎,因为⽆法确定该⽅法什么时候被调⽤，很少使⽤。
System类

静态变量

public static final InputStream in (标准输入流)

public static final PrintStream out (标准输出流)

public static final PrintStream err (标准错误输出流)

静态方法

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

arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：从指
定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。
src：源数组
srcPos：源数组的起始位置
dest：⽬标数组
destPos：⽬标数组的起始位置
length：要复制的数组元素的个数
//示例
int[] srcArr={10,51,22,31,56};
//把srcArr这个数组的元素拷⻉到destArr数组
int[] destArr=new int[4];
System.arraycopy(srcArr, 1, destArr, 0, 4);

public static void exit(int status)

//退出虚拟机
System.exit(1);

public static void gc()

//运⾏垃圾回收器

public static long currentTimeMillis()
程序示例：

//获取当前时间，返回以毫秒为单位的当前时间	
public static void main(String args[]) {
		long start = System.currentTimeMillis();
		… … … …
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	} 

Math类

Math.abs(-10) // 绝对值
*Math.sqrt(X)//计算平⽅根
Math.cbrt(X)//计算⽴⽅根
*Math.pow(a, b)//计算a的b次⽅
Math.max( 1,2 );//计算最⼤值
*Math.min( 3,4 );//计算最⼩值
Math.ceil(X) 接近此数的⼤的整数的值 3.1->4
Math.floor(X) 接近此数的⼩的整数的值 3.1->3
Math.random() [0,1)
Math.round(X) round 四舍五⼊，float时返回int值，double时返回long值

String类

string类是不可以变序列

String不变的性质是因为每次都从String 池⾥⾯取，如果有则直接⽤，否则创建新的放⼊

String str1 = “HelloWorld”;
Sting str2 = new String();
str2="HelloWorld"
String str3 = new String(“HelloWorld”);

String s = new String();

char c[] = {‘a’, ‘b’, ‘c’};
String s = new String(c);

char c[] = {‘语’, ‘言’};
String s = new String(c);

byte b[] = {97, 98, 99};
String s = new String(b);

String s = “abc”;

String s = “语言”;

判断字符串相等的方法

public boolean equals(Object anObject) 
判断是否是同一个对象，是->ture；
然后anObject是否为一个字符串对象，否->false；判断是否内容相同

public boolean equalsIgnoreCase(String anotherString) 
         判断逻辑与equals相同，仅仅在判断内容上不考虑大小写

public int compareTo(Object o)              
      若o不是字符串对象，则抛错；若是则调用下面的函数

public int compareTo(String anotherString) 
判断两个字符串的内容是否相同，是->0；否->不等于0的整数

public int compareToIgnoreCase(String str)  
基本功能同上，仅仅在判断时不考虑大小写

程序示例：

String s1 = "java语言";
String s2 = "JavA语言";
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.compareTo(s2));
System.out.println(s1.compareToIgnoreCase(s2));
运行结果：
false  true  32  0

程序示例：

          String s1 = new String("java");
		  String s2 = new String("java");
		  System.out.println(s1 == s2);
		  System.out.println(s1.equals(s2));
		  System.out.println(s1.compareTo(s2));

		  String s3 = "java";
		  String s4 = "java";
		  System.out.println(s3 == s4);
		  System.out.println(s3.equals(s4));
		  System.out.println(s3.compareTo(s4));
		  
		  System.out.println(s2 == s4);
		  System.out.println(s2.equals(s4));
		  System.out.println(s2.compareTo(s4));

		  System.out.println(s2.intern() == s4);

结果：

false
true
0

true
true
0

false
true
0

true

public int length()          
         字符串的长度，即包含多少个字符

获取特定子串(substring)和字符

public String substring(int beginIndex) 
public String substring(int beginIndex, int endIndex) 
beginIndex: 起始索引位置(包含)
endIndex:    结束索引位置(不包含)
public char charAt(int index) 

程序示例：

String s1 = "java语言";
String s2 = "JavA语言";
System.out.println(s1.length());
System.out.println(s2.length());
System.out.println(s1.substring(0, 4));
System.out.println(s1.substring(4));
System.out.println(s2.substring(0, 4));
System.out.println(s2.substring(4));
System.out.println(s1.charAt(0));
运行结果：
6
6
java
语言
JavA
语言
j

字符串前缀(prefix)/后缀(suffix)的判断

public boolean startsWith(String prefix)        
         判断字符串是否以一特定的字符串开头
public boolean startsWith(String prefix, int toffset)
public boolean endsWith(String suffix)                   判断字符串是否以一特定的字符串开头
程序示例：
System.out.println("java语言".startsWith("java"));
System.out.println("java语言".startsWith("ava", 1));
//从1这个索引开始对比
System.out.println("java语言".endsWith("语言"));

查询特定字符/字符串的位置

public int indexOf(int ch) 
该字符在字符串中第一次出现位置的索引值；否则返回-1
//从前往后比
public int indexOf(int ch, int fromIndex) 
public int indexOf(String str) 
public int indexOf(String str, int fromIndex) 
//从后往前比
public int lastIndexOf(int ch) 
public int lastIndexOf(int ch, int fromIndex) 
public int lastIndexOf(String str) 
public int lastIndexOf(String str, int fromIndex)

程序示例：

String s = “java语言”;
System.out.println(s.indexOf(‘a’));
System.out.println(s.indexOf(‘a’, 2));
System.out.println(s.indexOf(“a”));
System.out.println(s.indexOf(“语言”));
System.out.println(s.lastIndexOf(‘a’));
System.out.println(s.lastIndexOf(‘v’, 1));
//包括这个1
System.out.println(s.lastIndexOf(“语言”));
System.out.println(s.lastIndexOf(“v”, 2));
结果：
运行结果：
1
3
1
4
3
-1
4
2

字符串转变为数组

public byte[] getBytes()      
        将字符串转变为一个字节数组
public byte[] getBytes(String charsetName) throws 
UnsupportedEncodingException     
按特定的字符编码格式将字符串转变为一个字节数组
public char[] toCharArray()  
    将字符串转变为一个字符数组

程序示例：

中文Windows操作系统: 默认字符集 GB2312
其他系统: 默认字符集 ISO-8859-1
String s = "java语言";
char[] c = s.toCharArray();
System.out.println(c.length);
byte[] b = s.getBytes();
System.out.println(b.length);
b = s.getBytes("ISO8859-1");
System.out.println(b.length);
运行结果：
6

8

6

字符串

public String[] split(String regex) 
根据给定正则表达式的匹配拆分此字符串。

其他方法

public String concat(String str)   连接字符串
"cares".concat("s")  ->   returns "caress" 
public String replace(char oldChar, char newChar)    
在字符串中进行字符替换   
"JonL".replace('q', 'x') -> returns "JonL" (no change)
public String trim() 将字符串头尾的空格字符删除
public String toLowerCase()  字符串中字符转为小写
public String toUpperCase()  字符串中字符转为大写

一些静态方法

public static String valueOf(boolean b) 
public static String valueOf(char c) 
public static String valueOf(int i) 
public static String valueOf(long l) 
public static String valueOf(float f) 
public static String valueOf(double d) 
返回给定data type类型x参数的字符串表示形式。

StringBuffer类
一个可变(mutable)/动态的字符序列

构造方法

public StringBuffer()
public StringBuffer(String str)

主要方法

添加(append)和插入(insert, 指定位置)
public StringBuffer append(boolean b) 
public StringBuffer insert(int offset, boolean b) 
boolean, char, char[], double, float, int, long, String
转换为字符串 - public String toString()

程序示例：

String s = "java语言";
StringBuffer buffer = new StringBuffer(s);
buffer.append(“easy”);
buffer.insert(6, “ is “);
s = buffer.toString();
System.out.println(s);
运行结果：
java语言 is easy.

字符串的连接运算(Concatenation)

“java”和“语言”
String s = “java” + “语言”;
String s = “java”.concat(“语言”);
StringBuffer buffer = new StringBuffer(“java”); 
buffer.append(“语言”);                                
String s = buffer.toString();

StringTokenizer类
将一个字符串按特定的要求切分开

One String ->more Tokens

构造方法
public StringTokenizer(String str)  
按默认的分隔符将字符串分割– 四个字符“ \t\n\r\f”
public StringTokenizer(String str, String delim) 
按指定的分割符将字符串分割
方法
public boolean hasMoreTokens() 判断是否有token
public String nextToken()           得到下一个token

程序示例：

String s = "this is a test";
StringTokenizer st = new StringTokenizer(s);
while (st.hasMoreTokens()) {
	System.out.println(st.nextToken());
}
运行结果:
this
is 
a
test
String s = "this:is:a:test”;
StringTokenizer st = new StringTokenizer(s, “:”);
while (st.hasMoreTokens()) {
	System.out.println(st.nextToken());
}
运行结果:
this
is 
a
test

Runtime类（看起来不重要先不管了）

public Process exec(String command) throws IOException
Executes the specified string command in a separate process.
public Process exec(String[] cmdarray) throws IOException
Executes the specified command and arguments in a separate process. 

包装类
基本数据类型: byte, short, int, long, float, double, boolean, char

对应的包装类: Byte, Short, Integer, Long, Float, Double, Boolean, Character

作用

包装类对象中包含有一个对应基本类型的值

提供有基本类型和字符串(String)之间的转换函数

定义有一些常数和方法

程序示例：

int i = 123;
String s1 = Integer.toString(i);
String s2 = Integer.toString(i, 10);
//10表示十进制
String s3 = Integer.toString(i, 2);
String s4 = Integer.toString(i, 8);
String s5 = Integer.toString(i, 16);
String s6 = Integer.toBinaryString(i);
String s7 = Integer.toHexString(i);
String s8 = Integer.toOctalString(i);
结果：
123
123
1111011
173
7b
1111011
7b
173

//整型数据Integer转换为基本数据类型int
h   = Integer.parseInt(getParameter(“size”));

第四章 Applet及其应用

Java程序的两种基本形式

Java Application(应用程序)，可独立运行

Java Applet(小程序)，嵌入在浏览器中运行

Applet类的主要方法

程序示例：

import java.applet.Applet;
import java.awt.*;

public class Exam extends Applet {
	public void init( ) {		//初始化Applet程序
		………//在Applet程序第一次加载时调用，仅执行一次
	}
	public void start( ) {		//启动Applet线程
		………//重启时也被调用(reload或返回)
	}
	public void paint(Graphics g) {	//绘制输出显示信息
		………//被自动调用(启动后/窗口改变/repaint()调用)
	}
	public void stop( ) {		//暂停线程
		………
	}
	public void destroy( ) {  //释放系统资源，结束线程
		………
	}
}

applet与html

超文本标记语言(HTML)
<Html>和</Html>
Html文件开始和结束的标记
<Head>和</Head>
WWW浏览器窗口标题内容的标记
<Body>和</Body>
Html文件在浏览器窗口中显示内容的标记
<Applet>和</Applet>
嵌入到Html文件中Applet程序的标记
<Applet code=“字节码文件(*.class)” width=宽度值  height=高度值>
</Applet>
参数
<Param name=参数名称  value=参数值>

applet应用

java.awt.Font类
public Font(String name, int style int size)
设置文本的字体(包括字型和字号)

java.awt.Color类
public Color(int r, int g, int b)
public Color(float r1, float g1, float b1)
控制颜色，Color类已包含13个颜色常量

public void drawString(String s, int x, int y)
绘制字符串

public void drawString(char c[], int offset, int number int x, int y)
绘制字符

public void drawString(byte b[], int offset, int number int x, int y)
绘制字节

void drawLine(int x1, int y1, int x2, int y2)
画直线

void drawRect(int x, int y, int width, int height)
void fillRect(int x, int y, int width, int height)
void clearRect(int x, int y, int width, int height)
void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
void draw3DRect(int x, int y, int width, int height, boolean b)
void fill3DRect(int x, int y, int width, int height, boolean b)
画矩形

void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)
void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)
void drawOval(int x, int y, int width, int height)
void fillOval(int x, int y, int width, int height)
画圆弧和椭圆

public void drawPolygon(int xPoints[], int yPoints[], int Points)
public void fillPolygon(int xPoints[], int yPoints[], int Points)
public void drawPolygon(Polygon p)
public void fillPolygon(Polygon p)
Polygon类构造方法
Polygon()
Polygon(int xPoints[], int yPoints[], int numberOfPoints)
画多边形

java.awt.Image类
int getHeight(ImageObserver observer)
int getWidth(ImageObserver observer)
图像高度和宽度
Image getImage(URL url, String name)
获取图像信息方法
drawImage(Image img, int x, int y, ImageObserver observer)
drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)
显示图像的操作

drawImage()
Thread.sleep()方法
repaint()
创建Image类的对象数组

public void play(URL url)
public AudioClip getAudio(URL url)
play()方法/loop()方法/stop()方法
播放声音

程序示例：

import java.applet.Applet;
import java.awt.*;
public class Exam4_4 extends Applet {
	public void paint(Graphics g) {
		Font font1, font2, font3;
		font1 = new Font(“Serif”, Font.BOLD, 20);
		font2 = new Font(“Monospaced”, Font.BOLD+Font.ITALIC, 24);
		font3 = new Font(“SansSerif”, Font.PLAIN, 16);
		g.setFont(font1);
		g.drawString(“Serif 20 point BOLD”, 30, 20);
		g.setFont(font2);
		g.drawString(“Monospaced 24 point BOLD + ITALIC”, 30, 80);
		g.setFont(font3);
		g.drawString(“SansSerif 16 point PLAIN”, 30, 50);
		int size = font2.getSize();
		int style = font1.getStyle();
		String name = font2.getName();
		String str = name + “ “ + style + “ “ + size;
		g.drawString(str, 30, 110);
	}
}

程序示例：

//读取图片并显示
import java.applet.Applet;
import java.awt.*;
public class Exam4_13 extends Applet {
	public void paint(Graphics g) {
		Image pic;
		pic = getImage(getDocumentBase(), “edonkey.jpg”);
//getDocumentBase()获取文件的基本路径+edonkey.jpg
		int x0 = 10, y0 = 30;
		int w = pic.getWidth(this);		
		int h = pic.getHeight(this);
		g.drawImage(pic, x0, y0, w/8, h/8, this);
		g.drawImage(pic, x0+150, y0, w/12, h/12, this);
		g.drawImage(pic, x0+150, y0+100, w/15, h/15, this);
		g.drawImage(pic, x0+250, y0+30, (int)(w*0.1), (int)(h*0.2), this);
	}
}

第五章 图形用户界面设计

基本控制组件

一些特定的Java类

java.awt包

javax.swing包

容器组件(Container): 可包含其他组件

顶层容器: Applet, Dialog, Frame, Window

一般用途容器: Panel, ScrollPane

特定用途容器: InternalFrame

非容器组件: 必须要包含在容器中

Button, Checkbox, Scrollbar, Choice, Canvas

AWT组件：

Swing组件：

java.awt.Component

    |-java.awt.Container

          |-java.awt.Window

                |-java.awt.Frame

                      |-javax.swing.JFrame

java.awt.Component

    |-java.awt.Container

          |-javax.swing.JComponent

		|-JComboBox, JFileChooser, JInternalFrame

		   JLabel, JList, JMenuBar, JOptionPane, JPanel

		   JPopupMenu, JProgressBar,  JScrollBar

		   JScrollPane, JSeparator, JSlider, JSpinner

		   JSplitPane, JTabbedPane, JTable

		   JTextComponent, JToolBar, JTree等

Swing组件介绍：

使用步骤:

创建基本控制组件类的对象，指定对象属性；

将组件对象加入到制定容器的适当位置(布局设计)；

创建事件对象的监听者。

按钮

Swing组件(javax.swing.*)

public Button()            //创建按钮
public Button(String label)  
//常用方法
public String getLabel()    //返回按钮的值  
public void setLabel(String label)//设置按钮的值
public void setActionCommand(String s)  //就是给一个JButton设置一个属性的字符串值
public String getActionCommand(String s)
例如：
JButton btnShow = new JButton(); 
btnShow.setActionCommand("show"); 
当这个按钮被点击的时候,你就可以用 
ActionEvent 的 getActionCommand().equals("show") 
事件响应
java.awt.event.ActionListener(接口)
void actionPerformed(ActionEvent e)

标签

public Label()        //创建标签
public Label(String s)
public Label(String s, int alignment)
//常用方法
public String getText()
public void setText(String s)
public void setAlignment(int alignment)//标签之间的对齐方式或空隙大小
//事件响应
不引发事件

文本框

//TextComponent类的子类
public TextField()  //创建文本框
public TextField(int size)
public TextField(String s)
public TextField(String s, int size)
//常用方法
public void setText(String s)
public String getText()
public void setEchochar(char c)  //设置回显字符
public void setEditable(boolean b)//设置文本是否可以编辑
//事件响应
java.awt.event.TextListener(接口)
java.awt.event.ActionListener(接口)
textValueChanged(TextEvent e)//事件

文本区

//TextComponent类的子类
public TextArea()  //创建文本区
public TextArea(String s)
public TextArea(int rows, int columns)
public TextArea(String s, int rows, int columns)
public TextArea(String s, int rows, int columns, int scrollbars)
//常用方法
public void append(String s)
public void insert(String s, int index)
pubilc void replaceRange(String s, int start, int end)
//事件响应，跟上面一样
java.awt.event.TextListener(接口)
void textValueChanged(TextEvent e)

复选框

public Checkbox()  //创建复选框
public Checkbox(String s)
public TextField(String s, boolean state)
//常用方法
public boolean getState()
public void setState(boolean b)
public void setLabel(String s)
public String getLabel()
//事件响应
java.awt.event.ItemListener(接口)
void itemStateChanged(ItemEvent e)

单选按钮组

//创建单选按钮组
public Checkbox(String label, boolean state, CheckboxGroup group)
public Checkbox(String label, CheckboxGroup group, boolean state)
//常用方法和响应事件与复选框相同

列表

public List() //创建列表
public List(int n)
public List(int n, boolean b)
//常用方法
public void add(String s)
public void add(String s, int n)
public void remove(int n)
public void removeAll()
public int getSelectedIndex()
public String getSelectedItem()
//事件响应
java.awt.event.ItemListener(接口)
java.awt.event.ActionListener(接口)

下拉列表

public Choice() //创建下拉列表
//常用方法
public int getSelectedIndex()
public String getSelectedItem()
public void select(int index)
public void select(String item)
public void add(String s)
public void add(String s, int index)
public void remove(int index)
public void remove(String item)
public void removeAll()
//事件响应
java.awt.event.ItemListener(接口)
itemStateChanged(ItemEvent e)//事件

滚动条

//创建滚动条
public Scrollbar(int orientation, int value, int visible, int minimum, int maximum)
//常用方法
public void setUnitIncrement(int n)
//设置拖曳滚动轴时，滚动轴刻度一次的变化量
public void setBlockIncrement(int n)
//设置当鼠标在滚动轴列上按一下是，滚动轴一次所跳的区块大小
public int getUnitIncrement()
public int getBlockIncrement()
public int getValue()
//事件响应
java.awt.event.AdjustmentListener(接口)
void adjustmentValueChanged(AdjustmentEvent e)

菜单

java.awt.MenuBar类
MenuBar()
setMenuBar(菜单对象)
java.awt.Menu类
java.awt.MenuItem类
java.awt.CheckboxMenuItem类
java.awt.PopupMenu类

程序示例：

import java.awt.*;
import java.awt.event.*;
public class Exam5_19 extends Frame implements ActionListener, ItemListener {
	TextField text;
	public Exam5_19() {
		super(“我的菜单窗口”);
		setSize(300, 200);
	}
	public void init() {
		MenuBar myB = new MenuBar();
		setMenuBar(myB);
		Menu m1 = new Menu(“文件”);
		m1.add(new MenuItem(“打开”));
		MenuItem m11 = new MenuItem(“保存”);
		m11.setEnabled(false);
		m1.add(m11);
		m1.addSeparator();
		m1.add(“退出”);
		m1.addActionListener(this);
		myB.add(m1);
		Menu m2 = new Menu(“编辑”);
		m2.add(“复制”);
		Menu m21 = new Menu(“颜色”);
		m21.add(“前景色”);
		m21.add(“背景色”);
		m21.addActionListener(this);
		m2.add(m21);
		m2.addSeparator();
//其作用就是在菜单(menu)中填加的菜单项(munuItem)之间产生一个分割线
		CheckboxMenuItem mycmi = new CheckboxMenuItem(“全选”);
		mycmi.addItemListener(this);
		m2.add(mycmi);
		m2.addActionListener(this);
		myB.add(m2);

		Menu m3 = new Menu(“帮助”);	
		m3.add(“关于”);
		m3.addActionListener(this);
		myB.setHelpMenu(m3);
		
		text = new TextField();
		add(“South”, text);
	}
	public static void main(String args[]) {
		Exam5_19 myMenu = new Exam5_19();
		myMenu.init();
		myMenu.setVisible(true);
	}
	public void itemStateChanged(ItemEvent e) {
		text.setText(“状态改变”);		
	}
	public void actionPerformed(ActionEvent e) {
		text.setText(e.getActionCommand());
		if (e.getActionCommand() == “退出”)
		     System.exit(0);
	}
}

结果：

对话框

java.awt.FileDialog类
Dialog类的子类
构造方法
FileDialog(Frame f)
FileDialog(Frame f, String s)
FileDialog(Frame f, String s, int m)
常用方法
getDirectory()
setDirectory()
setFile()

画布

public Canvas() //创建画布
//常用方法
public void setSize()
public void paint(Graphics g)
//事件响应
java.awt.event.MouseMotionListener(接口)
java.awt.event.MouseListener(接口)
java.awt.event.KeyListener(接口)  //键盘监听
//键盘监听事件
KeyEvent
keyPressed方法：按下键时调用
keyTyped方法：释放键时调用
keyRealesed方法：按下键后调用

程序示例：

//文本框和标签
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class Exam5_4 extends Applet implements ActionListener{
	Label lab1, lab2, lab3;
	TextField text1, text2, text3;
	String str;  int i;  float f;
	public void init() {
		lab1 = new Label(“输入整形数: ”);        add(lab1);
		text1 = new TextField(“0”, 30);
		text1.addActionListener(this);	       add(text1);
		lab2 = new Label(“输入浮点数: ”);        add(lab2);
		text2 = new TextField(“0.0”, 30);
		text2.addActionListener(this);	       add(text2);
		lab3 = new Label(“输入字符串: ”);        add(lab3);
		text3 = new TextField(“0.0”, 30);
		text3.addActionListener(this);	       add(text3);
	}
	public void actionPerformed(ActionEvent e) {
		i = Integer.parseInt(text1.getText());
		f = (Float.valueOf(text2.getText())).floatValue();
		str = text3.getText();
		repaint();
	}
	public void paint(Graphics g) {
		g.drawString(“整形数=” + i, 20, 120);
		g.drawString(“浮点数=” + f, 20, 150);
		g.drawString(“字符串=” + str, 20, 180);
	}
}

结果：

程序示例：

//下拉列表
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class Exam5_8 extends Applet implements ItemListener {
	Choice cho; 	TextField text;
	public void init() {
		text = new TextField(10);
		cho = new Choice();
		cho.add(“red”);		
		cho.add(“yellow”);
		cho.add(“green”);
		cho.add(“blue”);
		add(cho);
		add(text);
		cho.addItemListener(this);
	}
	public void itemStateChanged(ItemEvent e) {
		if(e.getItemSelectable() == cho) {
		       String s = cho.getSelectedItem();	
		       text.setText(s);	
		}
	}
}

AWT程序示例：

import java.awt.*;     
import java.awt.event.*;   
public class HelloWorldAWT {
   public static void main(String[] args) {
       Frame f = new Frame("AWT1");
       Label label = new Label("Hello!");
       f.add(label);
       f.addWindowListener(new WindowAdapter() {
    	     public void windowClosing(WindowEvent e)
          { 	System.exit(0); }
	  });
       f.setSize(200, 200);  f.setVisible(true);
    }    
}

结果：

Swing程序示例：

import javax.swing.*;   
import java.awt.event.*;     
public class HelloWorldSwing {
   public static void main(String[] args) {
     JFrame f = new  JFrame(“Swing1");
     JLabel label = new JLabel("Hello!");
     f.getContentPane().add(label);
//用getContentPane()方法获得JFrame的内容面板，再对其加入组件
     f.addWindowListener(new WindowAdapter() {
    	     public void windowClosing(WindowEvent e) 
		{ System.exit(0); }
	});
     f.setSize(200, 200); f.setVisible(true);
    }
}

结果：

布局设计

六种布局管理器(Layout Manager)

两种简单布局
java.awt.FlowLayout       (JDK 1.0)
//流式布局，就是一直加在后面
java.awt.GridLayout       (JDK 1.0)
//表格布局，可以设置几行几列
两种特定用途布局
java.awt.BorderLayout   (JDK 1.0)
//边框布局，管理器将窗口分为 5 个区域：North、South、East、West 和 Center
java.awt.CardLayout       (JDK 1.0)
//卡片布局，两个或多个组件共享相同的显示空间，在不同的时间显示不同的组件
两种灵活布局
java.awt.GridBagLayout (JDK 1.0)
//网格布局
//最精细、最灵活的布局管理
//将空间划分为由行和列组成的网格单元，每个单元放一个组件，
//网格单元大小可以不同(宽度和高度)
javax.swing.BoxLayout //盒布局管理器，哪里都可以放

程序示例：

//流式布局
import java.awt.*;
import javax.swing.*;
public class FlowWindow extends JFrame {
    public FlowWindow() {
        Container contentPane = getContentPane();
        contentPane.setLayout(new FlowLayout());
        contentPane.add(new JButton("Button 1"));
        contentPane.add(new JButton("2"));
        contentPane.add(new JButton("Button 3"));
        contentPane.add(new JButton("Long-Named Button 4"));
        contentPane.add(new JButton("Button 5"));
    }
    public static void main(String args[]) {
        FlowWindow win = new FlowWindow();
        win.setTitle("FlowLayout"); 
          win.pack();  //调整窗口的大小，使其适应组件的大小和布局
         win.setVisible(true);//目的是使控件可以显示出来,如果该控件已经被显示出来，那么该方法是控件显示在窗口的最前方
    }
}

结果：

程序示例：

//表格布局
import java.awt.*;
import javax.swing.*;
public class GridWindow extends JFrame {
    public GridWindow() {
        Container contentPane = getContentPane();
        contentPane.setLayout(new GridLayout(0,2));
        contentPane.add(new JButton("Button 1"));
        contentPane.add(new JButton("2"));
        contentPane.add(new JButton("Button 3"));
        contentPane.add(new JButton("Long-Named Button 4"));
        contentPane.add(new JButton("Button 5"));
    }
    public static void main(String args[]) {
        GridWindow win = new GridWindow();
        win.setTitle("FlowLayout"); win.pack();  win.setVisible(true);
    }
}

结果：

程序示例：

//边框布局
Container contentPane = getContentPane();
//contentPane.setLayout(new BorderLayout()); 
contentPane.add(new JButton("Button 1 (NORTH)"), 						BorderLayout.NORTH);
contentPane.add(new JButton("2 (CENTER)"), 
					BorderLayout.CENTER);
contentPane.add(new JButton("Button 3 (WEST)"),
					BorderLayout.WEST);
contentPane.add(new JButton("Long-Named Button 4 (SOUTH)"),
					BorderLayout.SOUTH);
contentPane.add(new JButton("Button 5 (EAST)"), 
					BorderLayout.EAST);

结果：

卡片布局：

网格布局：

程序示例：

//多个容器嵌套
JPanel jpv = new JPanel();
jpv.setLayout(new BoxLayout(jpv, BoxLayout.Y_AXIS));
for(int i = 0; i < 5; i++)
	jpv.add(new JButton("" + i));
JPanel jph = new JPanel();
jph.setLayout(new BoxLayout(jph, BoxLayout.X_AXIS));
for(int i = 0; i < 5; i++)
      jph.add(new JButton("" + i));
Container cp = getContentPane();
cp.add(BorderLayout.EAST, jpv);
cp.add(BorderLayout.SOUTH, jph);

结果：
jpv

jph

容器

//常用方法
添加组件:  add()
getComponent(int x, int y)  //获取制定的组件
getComponent(int index)

remove(Component c)  //从容器中移出组件
remove(int index)
removeAll()

设置容器布局: setLayout()

常用方法
getTitle()
setTitle(String s)
setVisible(boolean b)
setBounds(int a, int b, int width, int height)
setBackground(Color c)
pack()
setSize(int width, int height)
dispose()
add()
remove()

事件处理

实现(implements)事件监听接口(interface)产生一个监听器对象(Listener)

监听谁? 将该监听器对象注册到组件对象中

编写事件响应方法

程序示例：

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Beeper extends JApplet implements ActionListener {
      JButton button;
      public void init() {
          button = new JButton("Click Me");
          getContentPane().add(button, BorderLayout.CENTER);
          button.addActionListener(this);
      }
      public void actionPerformed(ActionEvent e) {
          System.out.println(“Click me once”);
      }
}

事件监听分类

用户单击一个按钮，按回车键  
在文本字段中输入时，或选择菜单项时 
ActionListener  
interface java.awt.event.ActionListener
public void actionPerformed(ActionEvent e)

用户关闭一个框架(主窗口)	          
WindowListener  
interface java.awt.event.WindowListener
public void windowOpened(WindowEvent e)
public void windowClosing(WindowEvent e)
public void windowClosed(WindowEvent e)
public void windowIconified(WindowEvent e)
public void windowDeiconified(WindowEvent e)
public void windowActivated(WindowEvent e)
public void windowDeactivated(WindowEvent e)

用户关闭一帧(主窗口)用户按下鼠标按钮  
当光标停留在组件上时 	          
MouseListener 
interface java.awt.event.MouseListener
public void mouseClicked(MouseEvent e)
public void mousePressed(MouseEvent e)
public void mouseReleased(MouseEvent e)
public void mouseEntered(MouseEvent e)
public void mouseExited(MouseEvent e)
 
用户将鼠标移动到组件上          
MouseMotionListener 
interface java.awt.event.MouseMotionListener
public void mouseDragged(MouseEvent e)
表或列表选择更改在组件上按下鼠标按钮然后拖动时调用
public void mouseMoved(MouseEvent e)
当鼠标光标移到组件上但没有按下按钮时调用 
 
组件可以			          
ComponentListener  
组件变为可见组件获得键盘焦点                          
FocusListener  
表或列表选择更改                            
ListSelectionListener

程序示例：

//单个监听
public class MouseEventDemo ...  implements MouseListener {
        ...
        //Register for mouse events on blankArea(TextArea) and applet
        blankArea.addMouseListener(this);
	   …
    }
    public void mousePressed(MouseEvent e) 
    { saySomething("Mouse pressed; # of clicks: “ + e.getClickCount(), e); }
    public void mouseReleased(MouseEvent e) 
    { saySomething("Mouse released; # of clicks: "+ e.getClickCount(), e); }
    public void mouseEntered(MouseEvent e) 
    { saySomething("Mouse entered", e); }
    public void mouseExited(MouseEvent e) 
    { saySomething("Mouse exited", e); }
    public void mouseClicked(MouseEvent e) 
    { saySomething("Mouse clicked (# of clicks: “ + e.getClickCount() + ")", e); }
    void saySomething(String eventDescription, MouseEvent e) 
    { textArea.append(eventDescription + " detected on “ +
        e.getComponent().getClass().getName() + "." + newline); }
}

//多个监听
public class MultiListener ... implements ActionListener {
        ...
        button1.addActionListener(this);
        button2.addActionListener(this);
        button2.addActionListener(new Eavesdropper(bottomTextArea));
    }
    public void actionPerformed(ActionEvent e) 
    { topTextArea.append(e.getActionCommand() + newline); 
    //这个两个按钮都会执行
  }
}
class Eavesdropper implements ActionListener {
    ...
//这个只有button2会执行
    public void actionPerformed(ActionEvent e) 
    { myTextArea.append(e.getActionCommand() + newline); }
}

结果：

第六章 异常处理

异常的类别：

异常类的方法
构造方法
public Exception()
public Exception(String s)
常用方法
public String toString()
public String getMessage()
public void printStackTrace()

程序示例try catch：

public static boolean catchFinallyTest1() {
try {
  int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
  System.out.println("i vaule is : " + i);
  return true; // Exception 已经抛出，没有获得被执⾏的机会
} catch (Exception e) {
  System.out.println(" -- Exception --");
  return catchMethod(); // Exception 抛出，执⾏你捕获到异常后返回的内容
}finally{
  finallyMethod(); // Exception 抛出之后,finally内的⽅法也会执⾏,除了⼀种情况:
}
}
finally语句块不执⾏情况:(⼀般程序员都认为finally⼀定会执⾏,因为英⽂意思为 最终的)
1 System.exit(0)，它表示退出当前Java虚拟机
2 当线程为守护线程,如果主线程死亡,finally不执⾏ (守护线程是个服务线程, 准确的来说是服
务其他的线程,当⾮守护线程停⽌,守护线程才会停⽌
线程名.setDaemon(true) 可以设置当前线程为守护线程

程序示例throws:

throws是⽅法可能抛出异常的声明。(⽤在声明⽅法时，表示该⽅法可能要抛出异常)
public void doA(int a) throws Exception1,Exception3{
......
}
----------------------------------------------------------
2 throw是语句 (抛异常的语句)
try{
......
}catch(Exception1 e){
throw e;
//或者throw new Exception1();
}

第七章 线程

线程创建的两种方式

“Subclassing Thread and Overriding run” ->继承java.lang.Thread类, 重写run()方法

“Implementing the Runnable Interface” ->实现java.lang.Runnable接口

Runnable接口的唯一方法

public void run()

程序示例：

//继承Thread类，重写该类的run()⽅法
class MyThread extends Thread {
  private int i = 0;
  @Override
  public void run() {
    for (i = 0; i < 100; i++) {
    System.out.println(Thread.currentThread().getName() + " " + i);
  }
 }
 
public class ThreadTest {

public static void main(String[] args) {
 for (int i = 0; i < 100; i++) {
 System.out.println(Thread.currentThread().getName() + " " + i);
 if (i == 30) {
 Thread myThread1 = new MyThread(); // 创建⼀个新的线程
myThread1 此线程进⼊新建状态
 Thread myThread2 = new MyThread(); // 创建⼀个新的线程
myThread2 此线程进⼊新建状态
 myThread1.start(); // 调⽤start()⽅法使得
线程进⼊就绪状态
myThread2.start(); // 调⽤start()⽅法使得
线程进⼊就绪状态
 }
 }
 }

如上所示，继承Thread类，通过重写run()⽅法定义了⼀个新的线程类MyThread，其中run()⽅法的⽅法体代表了线程需要完成的任务，称之为线程执⾏体。当创建此线程类对象时⼀个新的线程得以创建，并进 ⼊到线程新建状态。通过调⽤线程对象引⽤的start()⽅法，使得该线程进⼊到就绪状态，此时此线程并不 ⼀定会⻢上得以执⾏，这取决于CPU调度时机。
程序示例：

//Runnable接口
class MyRunnable implements Runnable {
  private int i = 0; 
  @Override
  public void run() {
    for (i = 0; i < 100; i++) {
      System.out.println(Thread.currentThread().getName() + " " + i); 
      }
      }
}
public class ThreadTest {

public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
 System.out.println(Thread.currentThread().getName() + " " + i);
if (i == 30) {
Runnable myRunnable = new MyRunnable(); // 创建⼀个Runnable实现类的对象
Thread thread1 = new Thread(myRunnable); // 将myRunnable作为
Thread target创建新的线程
Thread thread2 = new Thread(myRunnable);
thread1.start(); // 调⽤start()⽅法使得线程进⼊就绪状态
thread2.start();
 }
}
 }
}      

进程同步

public class CubbyHole {
    private int contents;
    private boolean available = false;
    public synchronized int get() {
        while (available == false) {
            try {
                wait(); //打开锁，等候Producer填值
            } catch (InterruptedException e) {
  需要记得异常处理
}
        }
        available = false;  
        notifyAll();    
        return contents;
    }
    public synchronized void put(int value) {
        while (available == true) {
            try {
               wait(); //打开锁，等候Consumer取值
            } catch (InterruptedException e) { }
        }
        contents = value; 
        available = true;
        notifyAll();
    }
}

sleep()⽅法 :sleep()使当前线程进⼊阻塞状态，在指定时间内不会执⾏。⾃动苏醒

wait()⽅法: 不会主动苏醒，需要另外的线程调⽤notify()/notifyAll()⽅法唤醒。

t.join()⽅法只会使主线程(或者说调⽤t.join()的线程)进⼊等待池并等待t线程执⾏完毕后才会被唤

醒

interrupt()的作⽤是中断本线程。

notify和notifyAll来唤醒在某些条件下等待的线程

sleep()⽅法和wait()⽅法

相同点：⼀旦执⾏⽅法以后，都会使得当前的进程进⼊阻塞状态。

不同点：

1.⽅法声明⽅式不同，sleep()⽅法在Thread类中声明，wait()⽅法在Object类中声明。

2.调⽤的条件不同，sleep可以在任何需要的场景下调⽤，wait必须使⽤在同步代码块或者同步⽅法

中。

3.是否释放锁，sleep不会释放，wait会释放

第八章 集合

java.util.Arrays类
排序(sorting)
搜索(searching)
填充(filling)

java.util.Set 类
public boolean add(Object o)
public boolean remove(Object o)
public boolean contains(Object o)
public int size()
public boolean containsAll(Collection c)
public boolean addAll(Collection c)
public boolean removeAll(Collection c)
public boolean retainAll(Collection c)

程序示例：

import java.util.*;
public class SetDemo1 {
    public static void main(String args[]) {
        Set s = new HashSet();
        for (int i=0; i<args.length; i++)
            if (!s.add(args[i]))
                System.out.println("Duplicate: "+args[i]);
        System.out.println(s.size()+" distinct words: "+s);
    }
}
结果：
D:\java FindDups1 i came i saw i left
Duplicate: i
Duplicate: i
4 distinct words: [came, left, saw, i]

 Iterator i = s.iterator();
          while (i.hasNext()) 
               System.out.println(i.next());
java.util.Iterator
迭代器(interface)

java.util.List 接口
public void add(int index, Object element)
public Object remove(int index)
public boolean contains(Object o)
public int indexOf(Object o)
public boolean addAll(Collection c)
public boolean removeAll(Collection c)
public boolean containsAll(Collection c)
public boolean retainAll(Collection c)

import java.util.*;
public class ListDemo1 {
    public static void main(String args[]) {
        List list = new ArrayList();
        for (int i = 1; i <= 10; i++)
            list.add(i + " * " + i + " = " + i * i);
        Iterator iter = list.iterator();
        while (iter.hasNext())
            System.out.println(iter.next());
    }
}
结果：
1 * 1 = 1
2 * 2 = 4
3 * 3 = 9
4 * 4 = 16
5 * 5 = 25
6 * 6 = 36
7 * 7 = 49
8 * 8 = 64
9 * 9 = 81
10 * 10 = 100

public interface Map {
    //基本操作
    Object put(Object key, Object value);
    Object get(Object key);
    Object remove(Object key);
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    int size();
    boolean isEmpty();

    // 批量操作
    void putAll(Map t);
    void clear();

    // Collection Views
    public Set keySet();
    public Collection values();
    public Set entrySet();
}

public interface Entry {
        Object getKey();
        Object getValue();
        Object setValue(Object value);
}

import java.util.*;
public class MapDemo2 {
    public static void main(String args[]) {
          Map m = new HashMap();
          m.put(”Mary”, ”123-4567”);
          m.put(”Larry”, ”234-5678”);
          m.put(”Mary”, ”456-7890”);
          Iterator iter = m.entrySet().iterator();
          while (iter.hasNext()) {
                Map.Entry e = (Map.Entry)iter.next();
                System.out.println(e.getKey() + ” ” + e.getValue());
          }
    }
}

第九章 文件输入输出

读/写流的一般流程

读(Reading)

open a stream //打开读出流

while more information //判断

read information        //读

close the stream //关闭流

写(Writing)

open a stream //打开写入流

while more information //判断

write information       //写

close the stream //关闭流

两种流的定义(读取信息的基本数据单位)

字节流(byte stream): 一个字节(8-bit)一个字节读/写

字符流(character stream):一个字符一个字符读/写(具有特定字符编码的数据)

j a v a 语 言

6A 61 76 61 D3 EF D1 D4

以字节流的方式读: 读8次，8个字节

以字符流的方式读: 读6次，6个字符

I/O类型	所用到的类	描述
文件	FileReader/FileWriter（字符） FileInputStream/FileOutputStream	文件流(读/写文件)
缓冲	BufferedReader/BufferedWriter BufferedInputStream BufferedOutputStream	提高读/写效率
打印	PrintWriter PrintStream (System.out.println())
内存	CharArrayReader/CharArrayWriter ByteArrayInputStream ByteArrayOutputStream StringReader/StringWriter StringBufferInputStream	读/写内存

I/O类型	所用到的类	描述
字节流和字符流的转换	InputStreamReader OutputStreamWriter	将InputStream中读入的字节转为字符/将字符转为字节写入OutputStream
管道 pipe	PipedReader/PipedWriter PipedInputStream/PipedOutputStream	文件流(读/写文件)
连接 Concatenation	SequenceInputStream	多个输入流连接为一个输入流
对象串行化	ObjectInputStream ObjectOutputStream	Object Serialization

I/O类型	所用到的类	描述
基本数据转化	DataInputStream DataOutputStream	JAVA基本数据类型的读/写
计数	LineNumberReader LineNumberInputStream	读操作时记录行数
Peeking Ahead	PushbackReader PushbackInputStream	可回退缓存 (pushback buffer)
过滤	FilterReader/FilterWriter FilterInputStream/FilterOutputStream	在读/写操作时对数据进行过滤

程序示例：

//字节流
import java.io.*;
public class CopyBytes {
    public static void main(String[] args) throws IOException {
        File inputFile              = new File(“original.txt");
        File outputFile            = new File(“result.txt");
        FileInputStream in      = new FileInputStream(inputFile);
        FileOutputStream out  = new FileOutputStream(outputFile);
        int c;
        while ((c = in.read()) != -1)
           out.write(c);
        in.close();
        out.close();
    }
}

程序示例：

//字符流
import java.io.*;
public class Copy {
    public static void main(String[] args) throws IOException {
        File inputFile   = new File(“original.txt");
        File outputFile = new File(“result.txt");
        FileReader in   = new FileReader(inputFile);
        FileWriter out  = new FileWriter(outputFile);
        int c;
        while ((c = in.read()) != -1)
           out.write(c);
        in.close();
        out.close();
    }