Java期末复习总结根据老师复习整理作为参考26页word文档

模块1
1、Java程序分为Java应用程序和Java小程序
2、Java应用程序有且只有一个main（）方法，它是Java应用程序执行的起点和终点，拥有main()方法的类应该加public修饰符，该类为主类。

在该函数中通过系统对象System.out中的方法println()，可以在屏幕上输出字符号串。

3、Applet程序必须有且仅有一个类是Applet的子类。

extends关键字说明welcomApplet是Applet的子类。

该类用public修饰，是主类。

Applet程序中不需要有main()方法。

paint()方法是系统类Applet中已经定义好的成员方法。

它将在WWW所显示的Web页面需要重画时（例如浏览器窗口在屏幕上移动或放大、缩小等）被浏览器自动调用并执行，在子类中paint()方法的代码被重写了，它是多态性的一种表现形式。

使用Grapahics对象g的一个成员方法drawString()，可在指定的位置显示字符串。

在Applet类中，有一下4个方法：
init():创建Applet对象时执行，只能执行一次。

start():当浏览器从图标恢复成窗口或者是返回该主页时执行，可多次执行
stop():当浏览器变成图标或者离开主页时执行，可以多次执行，它的主要功能是停止一些占用系统资源的工作。

destroy():用来释放资源。

4、关键字和标识符
⏹标识符
⏹以字母、下划线“_”、美元符“$”开始
⏹后面跟字母、下划线、美元符和数字
⏹区分大小写
⏹关键字不能用来做标识符，
⏹见名知意
⏹约定
（1）类名：应以大写字母开头，若有多个单词组成，那么其中的每个单词都应该以大学字母开头。

若其中一个单词是字母缩写，那么此字母缩写应全部以大写字母编写。

⏹Student StringBuffer URL （2）方法名：应以小写字母开头，若包含多个单词，那么在第一个单词之后的每个单词都应以大写字母开头，第一个单词通常是动词。

如：
⏹简单数据类型
⏹整数类型：byte，short，int，long
⏹实数类型：float，double
⏹字符类型：char
⏹布尔类型：boolean
⏹复合数据类型包括：
⏹数组
⏹类：class
⏹接口：interface
6、运算符和表达式
⏹运算符
算术运算符：+ - ++ -- * / %
关系运算符：< <= > >= == !=
逻辑运算符：! && ||
位运算符：~ & | ^ << >> >>>
赋值运算符：= += -= *= /= %= &= |= ^= <<= >>= >>>=
条件运算符：?: 分量运算符: .
下标运算符: [] 实例运算符: instanceof
方法调用运算符: () 内存分配运算符: new
强制类型运算符:（类型）
⏹表达式
⏹数字转换成字符串
Double.toString(double)
Float.toString(Float)
Long.toString(Long)
Integer.toString(Integer)
Short.toString(Short)
Byte.toString(Byte)
⏹字符转换成数字
Double.parseDouble(string)
Float.parseFloat(string)
Long.parseLong(string)
Integer.parseInteger(string)
Short.parseShort(string)
Byte.parseByte(string)
7、package声明包语句，必须作为Java中的第一条可执行语句
格式：package 包名;
⏹Java包是由.class文件组成的一个集合。

以后如果要使用包中的类，必须
使用import导入。

⏹import语句引入包必须写在package语句和源程序其它语句之间
ng：Java语言核心包，包含所有的基本语言类，这个包由编译器自动引入。

java.applet：包含所有实现小程序的类。

java.awt：包含抽象窗口工具集中的图形、文本、窗口GUI类。

java.io：包含所有的输入输出类。

java：包含所有实现网络功能的类。

java.util：包含有用的数据类型类。

8、循环控制语句
⏹for语句
for(表达式1；表达式2；表达式3){
循环体
For语句一般用于循环次数确定的情况
⏹while语句
while(条件表达式){
循环体
先判断条件是否为真，如果为真就进入循环，如果为假可能一次循环也不执行
⏹do-while语句
do{
循环体
}while(条件表达式);
先执行循环体语句再进行判断，所以至少要执行一次循环
9、break、continue和return
⏹break语句可用于switch多路分支语句和循环语句中，其作用是跳出switch
或强行结束循环。

⏹continue语句只能用于循环语句中，其作用是结束本轮循环开始下一轮循
环。

⏹return语句：return 表达式;
⏹return结束方法的调用，并返回一个确定的值
⏹在一个方法中可以有多个return语句，但每次调用只可能有一个
return语句被执行。

9、Page 21.实现“九九乘法表”
public class Excercise4 {
public static void main(String[] args) {
final int size=9;
for (int x = 0; x<9; x++) {
for (int y = 0; y <x; y++) {
int z=x*y;
if (z<10) System.out.println("");
System.out.println(" "+x+"*"+y+"="+z);
System.out.println();
10.page22.重载构造方法
class OverloadDemo {
void test(){
System.out.println("No parameters");
void test(int a){
System.out.println("a:"+a);
double test(double a){
System.out.println("double a:"+a);
return a*a;
void test(int a,int b){
System.out.println("a and"+a+""+b);
public class Excercise5{
public static void main(String[] args) {
OverloadDemo ob=new OverloadDemo();
double result;
ob.test();
ob.test(10);
ob.test(10,20);
result=ob.test(123.25);
System.out.println("Result of
ob.test(123.25):"+result);
11、数组定义与使用
⏹数组是Java语言中的一种复合数据类型，是通过下标定位的同类型数据
的集合
⏹一个数组中每个元素的数据类型相同
⏹基本类型
⏹对象类型
⏹数组类型
⏹数组要经过声明、分配内存及赋值后才能使用
(1) 数组声明语法：
⏹数组元素类型数组名[];
⏹数组元素类型[] 数组名;
⏹数组元素类型数组名[][];
⏹数组元素类型[][] 数组名;
int score[ ];
char a[ ][ ];
(2) 数组分配内存
⏹数组名=new 数组元素类型[数组元素个数];
score=new int[2];
a=new char[2][3];
(3)数组元素初始化
⏹数组元素的类型是基本类型：可略
⏹数组元素的类型是对象类型：必须调用类的构造方法来初始化
score[ ]={1,2};
a[ ][ ]={{1,2},{3,4},{5,6}};
（4）数组元素的引用：下标
⏹下标从0开始，一个长度为n的数组，其下标范围是0~n-1
⏹下标必须是整形的值，短整型、字节型和字符型的值也可以作为数组的下
标
⏹越界检查
12、static final double random()：随机函数，返回0.0至1.0之间的值
13、String类
⏹String类用于表示Java中的字符串常量，字符串一旦被创建，其值就不能
再被改变，用双引号引起来的一系列字符。

（1）构造方法常用的有：
⏹String ()：新建一个空字符串对象，字符串长度为0。

⏹String (String original)：用一个已经存在的字符串常量创建一个新
String对象，该对象内容与给出的字符串一致。

⏹String (char[] value)：用指定字符数组value来创建一个字符串对象，
字符串对象中的内容为字符数组中的内容。

⏹String (StringBuffer buffer)：利用一个已经存在的StringBuffer对象
来创建一个新的String对象。

（2）访问字符串方法
⏹int length()：获得当前字符串中的字符个数。

⏹char charAt(int index)：获取字符串指定index位置上的字符。

⏹String substring(int beginIndex)：获得从指定处开始到最后的子串。

⏹String substring(int beginIndex,int endIndex)：获得指定范围内的子串。

⏹void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)：将一个字符串
从srcBegin到srcEnd位置子串复制到数组dst中。

⏹int indexOf(int ch)：查找给定的字符ch在字符串中第一次出现的位置。

如
果找不到返回-1。

⏹int lastindexOf(int ch)：查找给定的字符ch在字符串中最后一次出现的位
置。

如果找不到返回-1。

⏹int indexOf(String str)：查找给定的字符串str在字符串中第一次出现的位
置。

如果找不到返回-1。

⏹int lastindexOf(String str)：查找给定的字符串str在字符串中最后一次出现
的位置。

如果找不到返回-1。

（3）修改字符串方法
⏹String contact(String str)：将当前字符串对象与给定的字符串str连
接起来。

⏹String replace(char oldChar,char newChar)：把字符串出现的所有
oldChar字符全部用newChar替换。

⏹String toUpperCase()：将字符串内的所有字符改为大写。

⏹String toLowerCase()：将字符串内的所有字符改为小写。

（4）其它方法
⏹boolean equals(String s)：将当前字符串与指定的s进行比较，如果长度和
内容完全一致就返回true，否则返回false。

⏹boolean equalsIgnoreCase(String s)：将当前字符串与指定的s忽略大小写
比较。

⏹int compareTO(String str)：将当前字符串与指定的str按字典顺序比较大
小，相等返回0，如果该字符串按字典顺序小于参数字符串，返回值小于0，否则大于0。

⏹int compareTOIgnoreCase (String str)：将当前字符串与指定的str按字典顺
序忽略大小写进行比较。

14、StringBuffer类
（1）构造方法
⏹StringBuffer()：创建一个不包含字符且初始容量为16个字符的StringBuffer
对象。

⏹StringBuffer(int capacity)：创建一个不包含字符且初始容量为capacity的
StringBuffer对象。

⏹StringBuffer(String str)：创建一个StringBuffer对象，该对象包含str字符
串。

（2）访问字符串方法
⏹int length()：返回StringBuffer对象当前的字符个数。

⏹int capacity()：不需要另外分配内存的情况下，StringBuffer对象可以存储
的字符个数。

⏹void ensureCapacity(int minCapacity)：允许指定StringBuffer对象的最小容
量。

⏹void setLength(int newLength)：允许指定StringBuffer对象可以增加或减少
的容量。

⏹char charAt(int index)：返回StringBuffer对象中指定位置index上的字符。

（3）修改字符串方法
⏹void setCharAt(int index,char ch)：将StringBuffer对象中指定位置index上
的字符设置为ch。

⏹stringBuffer append(String str)：在已有字符串末尾添加字符串str。

⏹stringBuffer insert(int offset,String str)：在指定位置处插入str。

15、面向对象的三大特征
（1）继承（inheritance）
⏹指新的类可以获得已有类（称为基类或父类）的属性和行为，称新类为已
有类的派生类（或子类）。

⏹有助于解决软件的可重用性问题
⏹程序结构清晰
⏹降低了编码和维护的工作量
2）封装（encapsulation）
⏹信息隐蔽技术
⏹利用抽象数据类型将数据和基于数据的操作封装在一起
⏹将对象的使用者和设计者分开
⏹使用者不必知道行为实现的细节，只须使用设计者的提供的消息来
访问对象。

⏹封装的定义：
⏹清楚的边界，所有对象的内部信息被限定在这个边界内；
⏹接口即对象向外界提供的方法，外界可以通过这些方法与对象进行
交互；
⏹受保护的内部实现，即软件对象功能的实现细节不能从类外访问。

⏹Java语言通过类来实现封装
3）多态（polymorphism）
⏹静态多态（编译时多态）：在编译阶段，具体调用哪个被重载的方法编
译器会根据参数的不同来表态确实调用相应的方法。

⏹方法重载
⏹动态多态（运行时多态）：由于派生类继承了基类所有的属性（私有的
除外），所以派生类对象可以作为基类对象使用。

程序中凡是使用基类对象中的地方，都可以用派生类对象来代替。

一个对象可以通过引用派生类的实例来调用派生类的方法。

⏹方法重写
16、类的定义
（1）定义语法
⏹[修饰符] class 类名[extends 父类名][implements 接口名列表]{
[声明成员变量；]
[声明成员方法；]
①类的修饰符包括：public（公共）private（私有）protected（保护）abstract（抽象）
final（最终类）
⏹一般类只有两种访问权限
⏹public（公共）：可以在不同的包中引用
⏹默认（友好）：只能在同一个包中引用
⏹内部类：一个类可以定义在另一个类的内部
⏹内部类可以有private 和protected权限。

②成员变量的修饰符：public、protected、private 、final（常量）、static（静态）transient(暂时，用于对象存档)、V olatile(易变，用于并发线程共享)
③成员方法的修饰符：public、protected、private
⏹final（方法不能重写）
⏹static（静态）
⏹native (集成其它语言代码)
⏹synchronized(同步，控制多个线程并发访问)
（2）类成员的访问权限
⏹public：在所有包内可见
⏹protected：在同一个包内及其子类（不同包）
⏹缺省：在同包内可见
⏹private protected：在本类及基子类可见
⏹private：仅在本类内可见
（3）对象的定义及使用
⏹对象的定义包括声明、实例化和初始化
⏹类名对象名=new 类名（[参数列表]）；
⏹通过运算符“.”可以实现对成员变量的访问和成员方法的调用。

⏹对象名.变量名;
⏹对象名.方法名;
⏹注意：如果成员变量和成员方法使用static修饰，它们成为静态成员也称
类成员。

⏹静态成员存储于类的存储区，属于整个类而不属于一个具体的类对
象。

⏹同一个类的所有对象所访问的静态成员都是同一个
⏹静态方法只能处理静态变量。

调用静态成员语法是：
⏹类名.静态变量名;
⏹类名.静态方法;
17、Java系统默认，每个类都缺省地具有null 、this与Super三个属性
（1）null表示“空”，代表一个什么也没有的“空”值。

（2）this表示当前对象本身，代表了当前对象的一个引用。

（3）super表示的是当前对象的直接基类，是当前对象的直接基类的引用
18、构造方法的特点：
⏹构造方法名与类名相同；
⏹构造方法不返回任何值，也没有返回类型，即使是void也不行；
⏹每一个类可以显式定义零个或多个构造方法，如果没有显式定义构
造方法，Java会自动提供一个无参构造方法，为类的成员属性赋数
据类型默认值；
⏹构造方法在创建对象时自动执行，一般不能显式地直接调用。

19、继承的特点：
⏹子类不能继承父类中访问权限为private的成员属性和方法。

⏹在Java语言中只允许单继承，
⏹每一个类只能有一个父类
⏹一个类允许同时拥有多个子类
⏹父类:是所有子类的公共成员属性和公共成员方法的集合
⏹子类：是父类的特殊化，是对公共成员属性和成员方法的功能、内
涵方面的扩展和延伸。

⏹单继承形成了一棵继承树
⏹类的继承具有传递性，即子类继承父类的所有非私有成员，也继承父类的
父类类直至祖先的所有非私有成员。

20、接口的定义:接口声明和接口体。

定义格式：[public]interface 接口名[extends 父接口名]{}
extends:一个接口可有多个父接口，用逗号隔开，而一个类只有一个直接父类。

21、不能被实例化的类称为抽象类(abstract)。

用abstract修饰的方法是抽象方
法，所有的抽象方法都必须在抽象类中。

22、page50.计算长方形、圆及三角形的面积
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
abstract class Shape
Color c;
Shape(){}
public abstract float calArea();
public abstract void draw(Graphics g);
class MyCircle extends Shape //圆
Color c;
Point p;
int r;
MyCircle()
p = new Point(50,500);
r = 100;
MyCircle(Point p,int r)
this.p = p;
this.r = r;
public void draw(Graphics g)
c = new Color((float)Math.random(),(float)Math.random(),(float)Math.random());
g.setColor(c); //(Color.blue);
g.drawOval(p.x,p.y,r,r);
g.drawString("圆的面积是："+calArea(),400,100);
public float calArea()
return(float)3.14*r*r;
class MyRectangle extends Shape //三角形
Color c;
int[] xPoints ;
int[] yPoints ;
int nPoints;
MyRectangle()
xPoints = new int[]{20,50,80};
yPoints = new int[]{50,80,120};
nPoints = xPoints.length;
MyRectangle(int[] xPoints,int[] yPoints)
this.xPoints = xPoints;
this.yPoints = yPoints;
this.nPoints = xPoints.length;
private void randomChangePos()
for(int i=0;i<nPoints;i++)
xPoints[i]=(int)(Math.random()*200+50);
for(int i=0;i<nPoints;i++)
yPoints[i]=(int)(Math.random()*200+50);
public void draw(Graphics g)
c = new Color((float)Math.random(),(float)Math.random(),(float)Math.random());
g.setColor(c); //(Color.blue);
g.drawPolygon(xPoints, yPoints, nPoints); //绘制一个由x 和y 坐标数组定义的闭合多边形。

每对(x, y) 坐标定义一个点。

randomChangePos();
g.drawString("三角形的面积是："+calArea(),400,300);
public float calArea()
double a,b,c;
double p;
a=Math.hypot((xPoints[0]-xPoints[1]),(yPoints[0]-yPoints[1]));
b=Math.hypot((xPoints[0]-xPoints[2]),(yPoints[0]-yPoints[2]));
c=Math.hypot((xPoints[1]-xPoints[2]),(yPoints[1]-yPoints[2]));
p=(a+b+c)/2;
return(float)Math.sqrt(p*(p-a)*(p-b)*(p-c));
class MyRect extends Shape //矩形
Color c;
Point p1,p2;
int width,height;
MyRect()
p1 = new Point(80,100);
p2 = new Point(80,225);
width = 200;
height = 300;
MyRect(Point p1,Point p2,int width,int height)
this.p1 = p1;
this.p2 = p2;
this.width = width;
this.height = height;
public void draw(Graphics g)
c = new Color((float)Math.random(),(float)Math.random(),(float)Math.random());
g.setColor(c); //(Color.blue);
g.drawRect(p1.x, p1.y, width, height);
g.drawString("矩形的面积是："+calArea(),400,500);
public float calArea()
return width*height;
public class TestShape extends JFrame implements ActionListener
Shape myTrigle; //用父类Shape来声明三种形状实例变量，因为三角形，矩形，圆是形状的一种。

Shape myRect;
Shape circle;
TestShape()
int x[]= {10,20,30};
int y[]= {100,120,150};
Button btn;
myTrigle = new MyRectangle(x,y);
myRect = new MyRect();
circle = new MyCircle();
btn = new Button("update");
setLayout(new FlowLayout());
add(btn);
btn.addActionListener(this);
setSize(600,600);
setTitle("我的窗口");
setVisible(true);
public void paint(Graphics g)
super.paint(g);//调用父类的paint函数重画背景，及轻量级组件。

myTrigle.draw(g);
myRect.draw(g);
circle.draw(g);
public void actionPerformed(ActionEvent e)
repaint();
public static void main(String arg[])
new TestShape();
23、异常处理的语法结构
try{可能产生异常的代码}
catch(异常类名1 对象名1){处理语句组1}
catch(异常类名2 对象名2) {处理语句组2}
finally{处理语句组n}
无论在try代码段是否发生异常，finally语句都会被执行
模块2
24、向容器中添加组件
所有的容器都可以通过add()方法向容器中添加组件。

▪两种方式添加组件：
用getContentPane()方法获得容器的内容窗格，再对其添加组件。

如：容器.getContentPane().add(组件)
建立一个JPanel或JDesktopPane之类的中间容器，把组件添加到容器中，再用setContentPane( )方法把该容器替换为内容窗格。

如：JPanel ContentPane=new JPanel( );
ContentPane.add(组件);
容器.setContentPane(ContentPane)
25、框架窗口（JFrame）
默认布局管理器是BorderLayout
26、page70.自主学习
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Hello extends JFrame implements
ActionListener{
JTextArea tf;
JButton bt_show,bt_clear,bt_exit;
public Hello(){
super("Hello");
Container c=getContentPane();
bt_show=new JButton("显示");
bt_clear=new JButton("清除");
bt_exit=new JButton("退出");
tf=new JTextArea(5,30);
tf.setEditable(false);
c.setLayout(new FlowLayout());
c.add(bt_show);
c.add(bt_clear);
c.add(bt_exit);
c.add(tf);
bt_show.addActionListener(this);
bt_clear.addActionListener(this);
bt_exit.addActionListener(this);
setSize(350,200);
setLocation(200,200);
setVisible(true);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setDefaultLookAndFeelDecorated(true);
public void actionPerformed(ActionEvent e){
if(e.getSource()==bt_show)
tf.setText("欢迎你学习Java!");
else if(e.getSource()==bt_clear)
tf.setText("");
else
System.exit(0);
public static void main(String[] args) {
Hello fm=new Hello();
27、面板 (JPanel)
28.Java事件的处理步骤为：
选择事件监听器
将事件监听器注册
编写事件处理的程序代码
29、几种常用的事件如下：
ActionEvent：是发生在单击按钮、选中一个复选框或按下Enter等事件时触发，ActionEvent事件的监听器必须实现
ActionListener接口中的actionPerformed()方法。

ItemEvent：是用在具有多个选项的组件上，当每个选项的选择
状态（选中或未选中）发生变化时触发。

如：复选框、单选框、组
合框等
ChangeEvent：是发生在具有数值的组件上。

例如滑动杆、进度条。

WindowEvent：用于处理窗口的所有事件。

30、常用的事件监听器
ActionListener FocusListener ItemListener KeyListener MouseListener MouseMotionListener TextListener WindowListener
31、适配器：用空方法体实现了监听器接口类中的方法
KeyAdapter、MouseAdapter、WindowAdapter
32、page82.自主学习
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
class ComputerFrame extends JFrame implements ActionListener{
JTextField textOne,textTwo,textResult;
JButton giveAnwser;
JLabel inputProblem,operatorlabel,message;
ComputerFrame(String s){
super(s);
setLayout(new FlowLayout());
textOne=new JTextField(4);
textTwo=new JTextField(4);
textResult=new JTextField(4);
operatorlabel=new JLabel("+");
message=new JLabel("你还没有回答呢");
inputProblem=new JLabel("输入被加数和加数");
giveAnwser=new JButton("确认答案");
add(inputProblem);
add(textOne);
add(operatorlabel);
add(textTwo);
add(new Label("="));
add(textResult);
add(giveAnwser);
add(message);
giveAnwser.addActionListener(this);
textResult.addActionListener(this);
setBounds(100,100,350,100);
setVisible(true);
validate();
addWindowListener(new WindowAdapter()
public void windowClosing(WindowEvent e)
System.exit(0);
public void actionPerformed(ActionEvent e){
if(e.getSource()==giveAnwser){
String answer=textResult.getText();
try{
int x=Integer.parseInt(textOne.getText());
int y=Integer.parseInt(textTwo.getText());
int result=Integer.parseInt(answer);
if(result==x+y){
message.setText("恭喜你，回答正确！");
else{
message.setText("回答错误，请重输答案！");
catch(NumberFormatException ex){
message.setText("请输入数字字符");
textResult.requestFocus();
validate();
public class Calculate {
public static void main(String[] args) {
ComputerFrame frame;
frame=new ComputerFrame("简单加法运算");
33、密码框（JPasswordField）标准对话框（JOptionPane）
34、常用布局类型：流式布局管理器（FlowLayout）、边界布局管理器（BorderLayout）、网格布局管理器（GridLayout）、卡片布局管理器（CardLayout）35、page105.应用拓展
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Layout extends JFrame implements ActionListener {
TestCardLayout tc=new TestCardLayout();
JPanel bottom=new JPanel();
JButton b1,b2,b3,b4;
public Layout(){
this.getContentPane().setLayout(new BorderLayout());
b1=new JButton("下一页");
b2=new JButton("前一页");
b3=new JButton("第一页");
b4=new JButton("最后一页");
bottom.add(b1);
bottom.add(b2);
bottom.add(b3);
bottom.add(b4);
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
b4.addActionListener(this);
this.getContentPane().add(tc,"Center");
this.getContentPane().add(bottom,"South");
setSize(420,360);
setVisible(true);
setTitle("布局演示");
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE) ;
public void actionPerformed(ActionEvent e){
if(e.getSource()==b1)
tc.t.next(tc);
else if(e.getSource()==b2)
tc.t.previous(tc);
else if(e.getSource()==b3)
tc.t.first(tc);
else
st(tc);
public static void main(String[] args) {
new Layout();
class TestCardLayout extends JPanel{
CardLayout t=new CardLayout();
TestCardLayout(){
setLayout(t);
add("FlowLayout",new TestFlowLayout());
add("GridLayout",new TestGridLayout());
add("BorderLayout",new TestBorderLayout());
class TestFlowLayout extends JPanel{
JLabel lb1,lb2,lb3,lb4,lb5,lb6; TestFlowLayout(){
setLayout(new FlowLayout());
lb1=new JLabel("1",new ImageIcon("1.jpg"),JLabel.CENTER);
lb2=new JLabel("2",new ImageIcon("2.jpg"),JLabel.CENTER);
lb3=new JLabel("3",new ImageIcon("3.jpg"),JLabel.CENTER);
lb4=new JLabel("4",new ImageIcon("4.jpg"),JLabel.CENTER);
lb5=new JLabel("5",new ImageIcon("5.jpg"),JLabel.CENTER);
lb6=new JLabel("6",new ImageIcon("6.jpg"),JLabel.CENTER);
add(lb1);
add(lb2);
add(lb3);
add(lb4);
add(lb5);
add(lb6);
class TestGridLayout extends JPanel{ JLabel lb1,lb2,lb3,lb4,lb5,lb6;
TestGridLayout(){
setLayout(new GridLayout(3,3));
lb1=new JLabel("1",new
ImageIcon("1.jpg"),JLabel.CENTER);
lb2=new JLabel("2",new
ImageIcon("2.jpg"),JLabel.CENTER);
lb3=new JLabel("3",new
ImageIcon("3.jpg"),JLabel.CENTER);
lb4=new JLabel("4",new
ImageIcon("4.jpg"),JLabel.CENTER);
lb5=new JLabel("5",new
ImageIcon("5.jpg"),JLabel.CENTER);
lb6=new JLabel("6",new
ImageIcon("6.jpg"),JLabel.CENTER);
add(lb1);
add(lb2);
add(lb3);
add(lb4);
add(lb5);
add(lb6);
class TestBorderLayout extends JPanel{
JLabel lb1,lb2,lb3,lb4,lb5,lb6;
TestBorderLayout(){
setLayout(new BorderLayout());
lb1=new JLabel("1",new
ImageIcon("1.jpg"),JLabel.CENTER);
lb2=new JLabel("2",new
ImageIcon("2.jpg"),JLabel.CENTER);
lb3=new JLabel("3",new
ImageIcon("3.jpg"),JLabel.CENTER);
lb4=new JLabel("4",new
ImageIcon("4.jpg"),JLabel.CENTER);
lb5=new JLabel("5",new
ImageIcon("5.jpg"),JLabel.CENTER);
add(lb1,"North");
add(lb2,"West");
add(lb3,"East");
add(lb4,"Center");
add(lb5,"South");
36、菜单栏（JMenuBar）、菜单（JMenu）、工具栏(JToolBar) （知道如何创建）
模块3
37、page187.自主学习
在当前目录的兄弟目录（../newdir）下建立文件test.txt，按注释完成所缺代码。

import java.io.*;
public class CreateNewFile {
public static void main(String args[]) {
File p=new File("../CreateNewFile/newdir");
File f=new File(p,"test.txt");
try{
if(! f.exists())
f.createNewFile();
else
System.out.println("exists");
catch(IOException e){
e.printStackTrace();
38、简单输入/输出流
39、流从结构上可分为字节流和字符流。

字节输入流和输出流的基础是InputStream和OutputStream这两个抽象类。

字符流输入/输出的基础是抽象类Reader和Writer。

40、字符输入流
字符输入流（Reader）是一个抽象类。

其中包含一套字符输入流需要的方法，可以完成最基本的从输入流读入字符的功能。

而真正实现字符输入的功能，则必须根据数据的不同形式，创建一个适当的Reader子类类型的对象来完成。

41、字符输出流
字符输出流（Writer）也是一个抽象类，其中包含一套字符输出流需要的方法，
可以完成最基本的把字符写到输出流的功能。

而真正实现字符输出的功能，则必须根据数据的不同形式，创建一个适当的Writer子类类型的对象来完成。

42．Page194.项目24.随机读/写文件（文件的随机访问）
import java.io.*;
public class RandomIO {
public static void main(String[] args) throws IOException {
RandomAccessFile rf=new RandomAccessFile("rdfile.txt","rw");
rf.writeBoolean(true);
rf.writeInt(65535);
rf.writeChar('R');
rf.writeDouble(12345.678);
rf.seek(1);
System.out.println(rf.readInt());
System.out.println(rf.readChar());
System.out.println(rf.readDouble());
rf.seek(0);
System.out.println(rf.readBoolean());
43．Page199.项目25：读/写学生对象数据
技术要点：首先将有着特殊结构的对象进行序列化，然后通过流进行传输，写到文件，或从文件读取并输出到屏幕。

//ObjectOutTest.java
import java.io.*;
//学生类定义
//只有实现Serializable接口的类从能被序列化
class Student implements Serializable{
private String name;
private int age;
public Student(String name,int age){
=name;
this.age=age;
public void greeting(){
System.out.println("hello,my name is"+name);
public class ObjectOutTest {
public static void main(String[] args) {
ObjectOutputStream oos=null;
try{
oos=new ObjectOutputStream(new
FileOutputStream("student.txt"));
Student s1=new Student("Jerry",24);
Student s2=new Student("Andy",33);
oos.writeObject(s1);
oos.writeObject(s2);
catch(Exception e){
e.printStackTrace();
finally{
if(oos!=null)
try{
oos.close();
catch(Exception e){
e.printStackTrace();
//ObjectInTest.java
import java.io.*;
public class ObjectInTest {
public static void main(String[] args) {
ObjectInputStream ois=null;//定义对象输入流
Student s=null;
try{
//通过对象输入流从文件student.txt中读取对象
ois=new ObjectInputStream(new
FileInputStream("student.txt"));
System.out.println("------------------------------");
s=(Student)ois.readObject();
System.out.println(s);//显示序列化的对象
s.greeting(); //调用对象方法来显示对象
System.out.println("------------------------------");
s=(Student)ois.readObject();
System.out.println(s);
s.greeting();
catch(Exception e){
e.printStackTrace();
finally{
if(ois!=null)
try{
ois.close();
catch(Exception e){
e.printStackTrace();
44、对象流
对象流是能够通过输入输出对象的流，串行化的对象通过对象流写到文件或传输到其他地方
ObjectOutputSteam的write()把一个对象序列化并写到流（如FileOutputStream）中，
然后用ObjectInputStream的read()方法从流中读取数据并进行重组。

模块4
45、线程的生命周期
46、要实现线程必须要覆盖run()方法。

实现一个线程的两种方式：
①一种方法是将类声明为Thread的子类，重写Thread类的run()方法
②另一种是声明实现Runnable接口的类，然后实现run()方法
47、互斥的概念（给对象加锁的特性）：某个线程在使用资源时给资源上锁，别的线程不能使用资源，使用完后再解锁，别的线程才可以使用资源。

如果要形象地理解什么对象的锁，可以简单地认为锁是每个对象都有一份授权书，哪个线程获得授权书，哪个线程就拥有使用这个对象中代码的权利。

●Java语言提供两个关键字volatile和synchronized来实现给特定的资源上锁
的功能
volatile适用于控制简单的基本变量
synchronized适用于控制一段代码
synchronized关键字的作用：不允许“某些”线程同时执行到一段代码里。

“某些”由synchronized()的括号中的对象决定
volatile关键字修饰的变量的特性是：对该变量的写操作都会绕过高速缓存而直接写入主内存，而对该变量的读取也都会绕过高速缓存直接取自主内存。

48、线程的协作一般都是由wait()和notify()方法或者是notifyAll()方法来实现的。

49、page247.项目31.在Applet中显示图像
import java.awt.*;
import java.applet.*;
import java.awt.*;
public class ShowPic extends Applet {
int width,height;
public void init(){
public void paint(Graphics g){
Image img=getImage(getCodeBase(),"04.jpg");
width=img.getWidth(this);
height=img.getHeight(this);
g.drawImage(img,10,10,width/2,height/2,this);
插入到html中的代码;
<applet code="ShowPic.class" width="600" height="600">
50、Java Applet是一种特殊的Java程序，一般是嵌入到网页中在浏览器中运
行，准确地说是将编译好的字节码文件放到WEB文件中运行。

●使用AWT包中的Graphics类中的各种方法可以绘制图形
●使用Font类中的方法可以实现字体的控制
●使用Color类中的方法可以实现颜色的控制
模块5
51、Socket 套接字
⏹IP地址
⏹端口号
51、DNS
正向名称解析：InetAddress类中的getHostAddress()方法可以实现这个功能。

反向名称解析：InetAddress类中的getHostName()方法可以实现这个功能。

52、page263.自主学习
获取本机规范机器名、判断当前地址是否是回环地址，并获取本机名称和IP地址import java.*;
public class NetInfoStudy {
public static void main(String[] args) {
new NetInfoStudy().display();
public void display(){
try{
//创建InetAddress类对象
InetAddress address=InetAddress.getLocalHost();
address.getCanonicalHostName();//获得本季规范机器名
address.isLoopbackAddress();//判断是否是回环地址
address.getHostName();//获取本机名称
address.getHostAddress();//获取本机IP
catch(Exception e){
e.printStackTrace();
53、page269.项目36：TCP服务器端程序
技术要点：
⏹创建ServerSocket和Socket类的对象，定义输入、输出流，用于从Socket
中获取输入输出流对象；并在一个特殊的端口监听客户请求。

⏹调用ServerSocket实例对象的accept()方法，启动监听，随时获取客户端的
请求；并为客户端返回Socket类的对象实例。

⏹建立输入/输出流
⏹运用流对象获取从客户端发送的消息，并向客户端发送消息；
☐注意数据的读取与发送可采用不同类型的流对象
⏹关闭客户端流和客户对应的Socket
⏹转2或关闭ServerSocket
⏹关闭服务器套接字
import java.io.*;
import java.*;
public class Server_TCP {
ServerSocket svrSkt=null;//服务器套接字
Socket cltSkt=null;//客户端套接字
DataInputStream input=null;//输入流，来自客户端
PrintStream output=null;//输出流，指向客户端
public Server_TCP(int port){
System.out.println("服务器代理正在监听，端口："+port);
try{
svrSkt=new ServerSocket(port);//开始监听
catch(IOException e){
System.out.println("监听端口"+port+"失败");
try{
cltSkt=svrSkt.accept();//接收连接请求
catch(IOException e){
System.out.println("连接失败");
try{
//获得输入流
input=new
DataInputStream(cltSkt.getInputStream());
//获得输出流
output=new PrintStream(cltSkt.getOutputStream());
catch(IOException e){}
output.println("From Server:Welcome………");
public String getRequest(){ //获得从客户端发送的信息
String frmClt=null;
try{
frmClt=input.readLine();
System.out.println(frmClt);
catch(Exception e){
System.out.println("无法读取端口......");
System.exit(0);
return frmClt;
public void sendResponse(String message){//向客户端发送信息
try{
output.println(message);
catch(Exception e){。