上学时候的ＪＡＶＡ笔记

z前言
C/C++与java比较

C/C++java
全局变量有没有。（在类中定义）
goto语句有没有。
用异常处理机制（try-catch）
指针有，指针运算非常灵活没有指针操作，运算。
用类实现数组
内存管理C：malloc(),free()
C++：new,deletenew（授予处理权限）
数据类型的支持intIBMpc16位
VAX32位int32位java是一致的
类型转换非常灵活严格运行时检查是否兼容
头文件全局变量、函数声明、类的声明没有。（finalstatic）
结构体和联合合有没有
预处理有宏定义没有
字符串字符数组类（字符串类）
预算符重载有没有
多重继承支持不支持（用接口达到多重继承）
布尔型和整型的关系相互转换
1true
0false不允许
％和％＝操作（取余）整数类型整型和浮点型

Java语言最大的优点??可移植性

Java版本
1J2SE(标准版)中型平台standardedition
2J2EE(企业版)大型平台Enterpriseedition
3J2ME(微型版)嵌入式MicroEdition

第一章Java入门
1.Javaapplication基本语法结构
A）程序创建
1.文件扩展名：.java
2.文件名必须与公有类（public）的类名完全相同
3.java程序至少包含一个类
4.可以把两个类放在一个文件中，但一个文件中只能有一个类是公有的。
5.每个javaapplication必须有一个main()方法，他定义了程序从何处开始执行java解释器通过调用main()方法来执行application程序
6.Java源程序分区大小写
B）编译程序
javacxxx.java编译后产生xxx.class文件
一个类对应一个.class文件，原文件中有几个类就对应有几个.class文件
C）程序的执行
javaxxx
2.Javaapplet基本语法结构
a)applet的创建
(1).公有类必须继承java.applet.Apple继承用关键字extends
(2).applet不需要main()方法，因为applet不需要有java解释执行
(3).voidpaint(Graphicsg)是applet显示图形的方法
(4).import是软件中用的重要手段
b)applet执行
(1)浏览器地址拦中输入完全路径
(2)命令提示符输入：appletviewerxxx.html
Java程序错误：（1）编译错误==语法错误
（2）运行时错误
Java按运行环境分为三种
1.javaapplication操作系统
2.applet浏览器
3.servletweb服务器




第二章数据基本类型和基本操作
程序基本数据类型基本操作
硬件内存、寄存器CPU

1．标识符：常量、变量、方法、类、对象
（1）首字母：字母、_、$
（2）不能使用关键字，不能包含运算符
标识符命门规则：P23
2．变量：存储数据（存储区域和操作）
3．常量：用关键字final定义。例如：finalPI=3.14;
4．数据类型1）简单型(1)字符型
(2)数值型整型byteshortintlong（4种）
实型(浮点型)floutdouble
(3)逻辑型truefalse
2）复合型类数组字符串
5．类型的转换java只能允许字符与数值的转换数值<===>字符
两种转换：1强制转换：inti=(int)’a’将a强制转换为整型i
2隐藏转换:精度低－高
a)不同类型转换：数值与字符型（强制转换）
b)同种类型转换数值型内部(1)精度低??>高(隐藏转换)
(2)精度高??>低(强制转换)
例如：Floati=(float)0.0或floati=0.0f高转低需要强制转换
C/C++：ASCII（8位）
Java编码制：Unicode（16位）‘\uxxxx’
6．&&、||条件与/或推荐使用执行效率高符合人的思维
&、|无条件与/或
double?>float?>long?>int?>short?>byte
64326432168
7．编程风格
命名习惯P34



第三章控制语句
一、程序的基本结构的代构件表示


二、注意事项
1if-then-else
(1)if(i=1)布尔表达式应用括号
(2)if嵌套风格
if(){}
elseif(){}
elseif(){}
elseif(){}

2switch
(1)switch(~)括号
(2)switch表达式要能计算出一个char,byte,short,int的值(只能是这四种)
3while循环和do-while选还
while先判断后执行(for等价于while循环)
do-while先执行后判断
三、关键字break和continue的区别
1．不带标号
break中止最内层循环,continue中止最内层循环的本次迭代(循环次数一次是一个迭代)
for(inti=1;i<=5;i++)
{
If(i==3)break;或是continue;
System.out.println(“ok!”);
}
Break执行结果ok!//1
ok!//2
Continue执行结果ok!//1
ok!//2
ok!//4
ok!//5
2．带语句标号
break中止标号标记的循环,continue中止标号标记的循环的本次迭代
layer1:for(~~~)
{
Breaklayer1
}




第四章方法（函数）
引用(调用)：类名.方法名（）；
[m]static返回型方法名（参数1，参数2....）
　{．．．．．．．．；
　　．．．．．．．．；
　　return；
return变量名/表达式
}
参数：定义：形参
调用：实参
参数传递的两种方式：(1)传值（基本数据类型）
(2)传址（复合数据类型：类，数组，字符串）
publicstaticintmax(inta,intb){...}
publicstaticdoublemax(doublea,double,b){...}
定义时：类中的方法
引用时：类名.方法名（）；
调用<值
语句void
区别方法的不同：方法名+参数类表（类型，个数，顺序）
引用方法的两种方式：1）当成值（有返回值）
2）当成语句（无返回值）




第五章使用对象和类编写程序
一，类的uml表示法

二，类的定义[m]修饰符
[m]classclassnameextendssuperclass_name1,superclass_name1implementsimplements1,implements2
{
属性
方法
}
[m]修饰符：
1，可见性修饰符：public所有包中
default（不写）本包中
2，性质修饰符：abstract抽象类??必须被扩展才能生成对象
final终极类??不能被继承扩展
三，对象的声明和创建
1，声明：类名对象名；
简单数据类型名变量名；
2，创建：对象名=new类名();
3，声明+创建：类名对象名=new类名()；
四，构造方法(constructor)
??初始化对象的数据
1，方法名与类名完全相同
2，构造方法可以有多个运行时重载
3，没有返回值类型，连void也没有
4，方法调用：调用时使用new操作符。例如：类名对象名=new类名()；
5，默认构造方法：没有参数
6，不定义任何构造方法，系统会隐含提供一个默认的构造方法
定义了若干个构造方法，系统不会再提供默认的构造方法
7，构造方法的可见性修饰符：public任何包中都可以调用
defaut本包中
private该类不能创建实例（math类）//

五，实例变量/方法<??>类变量/方法
㈠实例变量（instancevariable）：[m]类型名变量名
类变量（classvariable）：[m]static类型名变量名
a)类变量：描述对象的公有属性，只能有一个副本，
b)实例变量：描述对象的特有属性，有多个副本，
㈡实例方法：只能在实例创建后使用。[m]返回型方法名（参数1，参数2....）
类方法：可在实例创建前后使用。[m]static返回型方法名（参数1，参数2....）
例如：Math.sqrt();
㈢实例变量/方法的引用对象名.data/method
类变量/方法的引用①对象名.data/method
②类名.data/method（推荐使用）
㈣实例变量不可能被类方法访问。

㈤类成员储存在类的公用内存，
实例成员在每个实例中都有副本。
六.全局变量和局部变量的比较
1.全局变量（Globle）：实例变量+类变量。
局部变量（Local）：方法中定义的变量。
例如：
classA
{
变量??>全局变量
方法
{
变量??>局部变量
}
}
2.初始化:Globle有默认初始值。char“\u0000”,整型0,浮点型0.0,booleanfalse
类对象变量null
Local没有。
3.作用域（变量可以被引用的区域）：
Globle：整个类；可在任何位置声明，没有顺序关系。
Local：从声明处开始延续到块尾,要先声明再使用。
4.声明次数：
Globle：只有一次。Local：在互不嵌套的情况下可以声明多次。
5.同名：a.当Globle与Local同名时，L优先，G隐藏。
b.若想引用：类名.变量名；（类变量）
this.变量名。（实例变量）
七.关键字this
用途1：引用实例变量实例方法
构造方法
在实例方法或构造方法中访问隐藏的实例变量
例如：classA
{
inti=5;
voidsetI(inti){this.i=i;}
}
2：this()语句（可有参数）Java要求this()语句出现在构造方法中的任何语句之前
例如：classCircle
{
intradius;
circle(intr){this.radius=r;}
circle(){this(5);}
}

八.类成员的可见性修饰符
public：任何包中
defaut（不写）：本包中
private：本类中??本类中使用，不能继承，不能在子类中访问
protected：子类中??可以被同一包中的任何类或它的子类访问，即使子类在不同的包中也可以，但不能被继承
九．字符串
㈠String类java.lang.String
(1)创建：①String变量名=newString("IBM")；
②String变量名="IBM"；
(2)常用方法
①比较："=="检验两个字符串变量是否引用同一对象(地址)
equals()检验来那个字符串变量是否引用同一对象(值)
②其他：P124-126
㈡StringBuffer类java.lang.StringBufferP126
⑴创建：StringBufer变量名=newStringBuffer(D)
StringBuffer类提供三个构造方法
㈢StringTokenizer类(解析字符)java.util.StringTokenizerP128
⑵创建new.
StringTokenizerst=newStringTokenizer("iamastudent")

十．访问器方法P103
①读取方法(getter)②设置方法(setter)
十一．垃圾回收P97




第六章类的继承性　
类：继承??重用性，
多态－－扩展性
一、子类extends父类－－扩展：子类的属性和方法：增加新的，修改父类的
1．父子类属性同名：父类隐藏
子类引用父类：实例变量：a)super.data　
b)((父类/祖类)this).data
c)((父类/祖类)对象名).data
类变量：a)上面三种　
c)父类/祖类.data
2．父子类方法相同（同名，同参）
　实例方法：子类覆盖父类，子类中所有方法都可以引用父类??支持多态性
子类引用父类：super.method();
　类方法：子类隐藏父类（能找到）
子类引用父类：a)super.method();
b)((父/祖)this).method();
c)((父/祖)对象名).method();
d)父类/祖类.method();（比较好的引用方法）
3．所有属性和方法可以用super引用
4．父类属性和父类方法都可以用类名引用。
注意：子类向上转型为父类后，父类的所有成员都可见（除实例方法），子类所有成员都隐藏（除实例方法）
二、父类与子类的兼容性
多态性：运行时选择执行代码段的特性
父类和子类之间的类型转换
1父=子总可以进行,不需要类型转换
2子=(子)父可进行但运行时会检察
父类变量持有：正确子类型正常执行
不相关的类型,会抛出一个class+Exception
3不相关的任何类型间不能进行类型转换
一般能容纳具体。把具体对象当作一般对象处理
父类对象变量持有子类对象变量
多态性实现了“接口和实现的分离”(music.java)
1.父类对象变量＝子类对象变量
??当子类向上转型后，子类中所属性和方法都隐藏（除实例方法），父类中所有属性和方法都可见（除实例方法）
2.方法的形参是父类，则可将子类对象作为实形来传递
总结：1）父＝子　
2）子＝（子）父
三、关键字this和super
1).this
a)this.data
b)this(参数)构造方法中第一条语句
2).super
A.super.data/method()；
B.super(参数)构造方法中第一条语句
四、继承关系中的构造方法调用链
前提：子类对象创建前，必先创建父类对象（先有父，再有子）
①不显示调用：系统隐含调用父类的默认构造方法（等价于在子类构造方法插入super()；)
②显示调用：明确给出构造方法中第一条语句super(参数)；
3方法覆盖(父子类之间)override、方法重载(同名不同参)overload
五、运算符instanceof??确保对象是类的实例
对象名instanceof类名例:(ainstanceofB)返回布尔值
六、
1对象的初始化－－属性(对象的状态)
1)构造方法：
a)实例属性
b)类属性
2)定义：
a）实例属性－－>编译??>插入到构造方法
b)类属性－－>编译??>插入到类的初始化方法中。
第一次访问类时调用初始化方法：a)new方法
b)类名.属性/方法
3)初始化模块
①{实例变量初始化｝
②static｛类变量初始化｝

2函数调用的绑定方式
methodcall<??>methodbody
方法调用方法体
A.先期/静态绑定：执行前(C语言、面向过程语言)
B.后期/动态绑定：执行时
Java中所有方法都是动态绑定，除了final方法
3final关键字
①类：终极类(不可继承)
②属性：(变量)＝＝常量(子类可以重定义。在父类中定义常量，可以在子类中重新定义为变量)
③方法：子类中不能重新定义和修改（静态绑定）
4Object类
Java中的每个类都源自java.long.Object类
1)equals()方法:：Object中的equals()方法等价于‘＝＝’
　其子类中要覆盖，使其判断内容相等
2)toString()方法：子类覆盖，使其代表对象的有意义的串.
七、重复运用class的两种方式
1.继承（Inheritance）
新的class接受了既有（已经存在的）的属性和方法，并可以对之扩展，
类之间的关系是is-a（是一个）

2.组合（composition）
在新类中产生既有类的对象，作为属性类间关系是has-a（有一个）


3.面向对象（MVC模式）

八、类的抽象
㈠关键字Abstract(类方法)
1．抽象方法
如果方法的声明中用到了修饰符abstract，那么定义的这个方法可以不包含具体的实现
例子：abstractmethod（P）;//{}可以不写
2．抽象类
任何包含抽象方法的类是抽象类，且要显示的声明abstract，但是抽象类可以不包含抽象方法
3．一些规则
（1）抽象类不能实例化
（2）当抽象类的子类1实现部分抽象方法，子类仍是抽象类
2实现全部抽象方法，子类是具体类
（3）static，private，final不能是抽象的。因为这些方法不能被子类覆盖
（4）终极类（final类）不能含抽象方法。
（5）不包含抽象方法的类，也可以声明为抽象类，也不能被实例化。
㈡接口（也是一种数据类型）
1、定义：关键字interface
interface接口名例如：publicinterface接口名{}，产生接口名.class的文件
可以当成一种特殊的类也不能实例化
2、限制规则
1)接口不包括任何实现，其中的所有方法都是默认为抽象方法，所有的方法都是实例方法
2)接口方法默认都是public型的
3)接口中不能定义实例变量和静态变量，只允许用static和final声明的变量??静态常量
4)接口不能实例化，所以接口中不定义构造方法
3、接口的实现
定义：关键字implement
实现了所有的，可实例化
部分，必须显示把自己声明为abstract

4、接口的使用
实现了接口的类可看成接口的实例

5、多接口的实现
一个类只能有一个父类，但可实现任意多接口
implements接口，接口，……
这时，只意味这必须实现这些接口中的所有抽象方法
6、接口的扩展（extends）
1像类有之类一样，接口也可以有子接口
2子接口继承了父接口中的所有抽象方法和静态常量，同时还可以定义新的
3接口的extends从句中可以包含多个超接口（父接口）
interfaceIextendsI1,I2,I3,I4…
7、标记接口(markerinterface)
空接口(没有任何方法)
当一个类实现了接口，那么这个类的一个实例也是这个接口的一个有效实例
标记接口正是利用这项技术提供额外的信息
例如：Cloneable接口
总结
接口：多重继承
属性:静态常量
方法:都是抽象方法，无构造方法
抽象类：单继承
属性:无限制（与其它类一样）
方法:可以有具体方法，必须有构造方法
OO（面向对象）设计原则
1.开闭原则(open/closedprinciple)OCP
定义:一个模块在：扩展性方面应该是开放的
修改性方面应该是封闭的
实现:在设计软件是,要有意识地使用接口进行封装
2．Liskov替换原则
定义:指子类可以替换父类,出现在父类能出现的任何地方.
实现:设计时将父类设计为抽象类(或接口)，让子类继承抽象类(或实现接口)其他类只与父类协作交互，运行时子类会替换父类,这样的系统有较好的可扩展性




第七章数组和向量
一、数组
1．声明和创建数组
(1)声明：数据类型[][][]数组名/数组对象变量
例如：int[][]i;
String[]s;
Circle[][][]c;
(2)创建：数组名=new数据类型[大小][大小]
s=newString[10];
c=newCircle[5][6][7];
(3)声明+创建
数据类型[][][]数组名=new数据类型[数组大小]（推荐使用）
数据类型数组名[][][]=new数据类型[大小]
Circle[]c=newCircle[5];
double[]mylist=newdouble[5];
2.初始化及处理
数组的大小：arrayObject.length指定c.length、mylist.length
例如：Circle[]c;
c=newCircle[5]；
c.length=5;初始化：for(inti=0;i<c.leagth;i++)
c[i]=newCircle[i];
创建后有默认值：
整型：0
实型:0.0
字符型:\u0000
boolean型：false
类类型：null
引用：
数据名[下标值][下标值]。
数组中的元素
下标值范围：0.....（数组名.length-1)
4、声明+创建+初始化：
数据类型[]数组名={值]1，值2，值3.....}；
例如：double[]d={1.0,2.0,3.0,4.0,5.0}；
Cilcle[]c={newCircle(1),newCircle(2),newCircle(3)}；
5、数组复制的3种方法P182页
用循环语句复制数组的没一个元素。
For(inti=0;I<Array1.length;i++)
Array2[i]=Array1[i];
使用Object类的clone方法
Int[]arry1=(int[])arry2.clone();
使用System类中的静态方法arraycopy
Arraycopy(array1,1pos,array2,2pos,length);
二、将基本数据类型处理为对象P186页
1、包装类
三、向量类P197

复习
包装类

数据类型<简单型8（1+1+4+2）
复合型String数组在自定义类接口抽象类
变量<基本变量intI
对象型
Students=newseudent();
“李明”,18.newCollege()
父类和子类之间的类型转换
1父=子总可以进行,不需要类型转换
2子=(子)父可进行但运行时会检察
父类变量持有<正确子类型正常执行
不相关的类型,会抛出一个class+Exception
3不相关的任何类型间不能进行类型转换
Students=newstudent();
collegStudentcs=newcollegStudent
s=cs;
父=子
Schoolstudentcs2=(Schoolstudent)s
子=(子)父
第八章图形程序设计入门
引言
AWT（AbstractWindowsToolkit）抽象窗口工具集
Swing（组件）优点：1更丰富更漂亮
2平台依赖少，bug少
3观感一致，依于平台的绘图方法
注：Swing组件不能取代AWT的全部类，辅助类保持不变

Java图形类库
1容器（Container）JFrame(有且只有一个)框架??Application
JPanel面板??Application/Applet
JAppletApplet
2组件（Component）JButton、JTextField、JTextArea、JcomboBox等
3辅助类Color、Font、FontMetrics、Dimension、LayoutManager、等
一、JFrame（框架类）在包import.javax.swing中
1创建：importjavax.Swing.*
JFrameframe=newJFrame（）；
2设置大小
setSize（宽,高）；
3使可见
show();//显示框架方式1（在最前方）
setVisible(true);//显示框架方式2
4setDefaultClose_Operation（JFrame.EXIT_ON_CLOSE）
告诉应用程序，框架关闭时程序结束。
dispose();//关闭窗口，并回收用于创建窗口的任何资源
5指定位置
setLocation（x,y）??(x,y)左上角坐标
6向框架中添加组件
只能在内容窗格上添加组件（ContentPane）
获取内容窗格：getContentPane（）；
Containercp=getContentpane();
cp.add(newJButton(“ok”);
getContertPane().add(newJButton(“concel”);
二、布局管理器(容器类)
??辅助容器类??映射布局策略?>实际显示
1不用布局管理器
容器（1）setLayout（null）；//不用布局管理器
组件（2）setBound（x,y,width,height）；//组件放在那个点
容器(3)add（Component）
评价：使用源编码的象素尺寸来安排组件的办法，缺少灵活性
2使用布局管理器
(1)FlowLayout(3个构造方法)
①指定对齐方式（左中右），水平/垂直的间距
②按照组件添加的顺序从左向右排列，一排满后再排另一排
③add（Component）
(2)GridLayout(3个构造方法)
①指定行数列数水平/垂直间距
②按照添加顺序从左向右，按照指定的行数列数，以网格的形式排列
③行数列数的指定规则
1）行数＝0列数＝value(一个值)，列数固定行数动态分布
2）行数＝value列数＝0行数固定列数动态分布
3）行数＝value列数＝value行数固定列数动态分布
(3)BorderLayout(2个构造方法)
①指定水平/垂直间距
②按东/西/南/北/中指定区域放置
③add(Component.index)书上213
三、JPanel
使用单一的容器很难达到预期的视觉效果
面板是放置Component的更小容器，用于组织组件的更小容器，面板不可见。
JPanelp=newJPanel();
p.add(newJButton(“ok”));
p.add(newJPanel());
对比：JFrame和JPanel
⑴

⑵给JFrame添加组件到内容窗格
给JPanel直接添加到面板上
⑶JFrame中画图用paint（）方法
JPanel中画图用排paintComponent（）方法
四、在面板上画图
1、方法：创建一个JPanel的子类，并覆盖paintComponent（）方法
PublicvoidpaintComponent(Graphicsg)
2、Graphics类（绘图）java.awt.Graphics
3、显示字符串：g.drawString(s,x,y);
绘制几何图形drawLine();绘制几何图形的方法P221
显示图像drawImage(Image);
4、比较：在框架和面板上绘图
⑴在框架中绘图
①产生一个JFrame的子类
②覆盖publicvoidpaint(Graphicsg)
⑵在面板中绘图
①产生一个JPanel的子类
②覆盖publicvoidpaintComponent(Graphicg)
注意：以上要先调用父类的相应方法来清除视区??清除以前画的
JFramesuper.paint(g)
JPanelsuper.paintComponent(g)
五、个比较常用的辅助类P205页
1、color类java.awt.Color
自调制：Colorc=newColor(R,G,B)
(0~255)
Component类中的方法：设置颜色
SetBackgroud(c)；??背景色。SteForeground(c)；??前景色
Graphics中设置颜色方法setColor(c)
2、Font类??设置字体
Fontf=newFont(name,style,size)
setFont（f）；
3、FontMetrics类P217页
??帮助计算字符/字符串的高度和宽度
Graphics中设置字体方法getFontMetrics(f)
FontMetricsfm=getFontMetrics(f)
fm.getAscent();
fm.stringWidth(“hello”);
4ToolKit类(它对象有许多和本地窗口打交道的方法)
Toolkitkit=Toolkit.getDefaultToolkit();
Dimensiond=kit.getScreenSize();
d.width、d.height
Imageimg=Kit.getImage(“xxx.gif”)
六、事件驱动的程序设计
GUI程序驱动??过程顺序
事件驱动??激活事件
用户通过GUI与程序交互，事件驱动着程序的执行
1、事件(Event)引发者①外部人
②底层系统软件
程序发生了某些事情的信号
内部表达事件：用事件类的一个实例（对象）来表达该事件，这个事件对象包含与事件有关的一切属性。
java.util.EventObject类??一切事件的父类P231页
2、源对象(sourceObject)
??在其上发生事件的组件
注意：一个组件上发生某个事件，那么这个组件的任何子类也能发生同类事件
3事件的处理机制
监听器(Listener)：是一个关心事件的对象并对特定事件做出相应处理
注册：调用源对象的方法(addXListener()）声明某对象为监听器
JButtonjbtok=newJButton(“ok”);
jbtok.addActionListener(监听器对象)；
Java为每种GUI事件类型提供了一个监听接口P237页

Class监听器implementsActionListener
{
PublicvoidactionPerformed(ActionEvente)
{
响应事件的处理代码
}
}

具体用户行为、源对象、事件类型、监听接口、监听方法：P231页8-27?P232页8-28










一．JApplet类中的常用方法
1．Init（）：装载applet时调用
创建新线程newThread
装载图像
设置用户界面组件
从HTML网页中获取参数
2．start()：init()完成后，再次访问包含applet的网页时，（第一次，和在跳回来）
方法中的主要功能：所有方法HTML页的主要操作
3．stop()：离开网页时，或包含applet的web页不可见时（窗口最小化）
4．destroy()：当浏览器退出时或apple被销毁前
二．在不支持java的浏览器中运行applet
1要安装javaplug-in
2将带有<applet>标记的HTML文件转成带有<object>标记的HTML文件
三．HTML中的<applet>可以控制applet
（1）code：指apple文件名
（2）codebase：指定applet的目录名
（3）width/height：指定applet的区域大小
（4）vspace/hspace：指定applet周围的空白边界大小
（5）align：指定applet在浏览器中的对齐方式
四．从HTML文件向applet传递参数的方法
步骤：1在html文件中声明<paramname=Xvalue=20>
2在Japplet的init()方法中使用getParameter(“praname”)返回指定的参数值

五．applet与Application之间的转换
JApplet与JFrame
共同点：1都是Container的子类
2都是向内容窗格加组件
3用户组件、布局管理器、事件处理机制，都相同
不同点：1运行环境不同applet?web浏览器
Application?Java解释器
2执行时的安全级别：applet?执行受限制
Application?没有任何限制
转换的方法：
（1）applet?>Application的步骤
①废弃HTML文件，HTML文件中的参数可从命令行获得
②从JFrame或其子类派生出一个主类（含main()方法的类）
③用init()和start()方法中的代码编写新主类构造方法（将init（）和start（）方法中的代码考入到构造方法中）
④添加一个main（）方法{a获取参数b设大小c显示}
（2）Application->applet的步骤
①制作一个HTML文件带有<applet>标签若需要从命令行取参数可从getParameter()
②从JApplet或其子类派生一个主类
③用init（）方法代替构造方法
④删除main()方法(不删，执行时忽略)
（3）如何编写一个程序既能用Application运行又能够在applet运行（为applet添加main()方法）
理论意义淡化二者的差别
现实意义水陆两栖
类的特点：1.主类是JApplet的扩展类
2.有init(),start()没有构造方法
3.所有的文章都在main()方法中
总的来说：为Applet添加main()方法
具体步骤：①创建一个JFrame的实例
②创建一个该applet的实例
③把applet添加到JFrame的内容窗格中
④调用applet的init()方法和start()方法
⑤设置JFrame的大小、尺寸，显示
（4）使用appletviewer执行applet而不需要另外创建HTML文件的方法。
appletviewer能从一个文件中取出<applet>标签，并忽略其余内容。
作法:将<applet>标签以注释的形式加入到java源文件中。
在DOS环境中运行appletviewerXXX.java
Timertimer=newTimer(时间间隔，监听器);
timer.start();
timer.stop();


booleansuspended
Run()
{
while(suspended)
wait();
}
init()thread.start()
start()suspended=false;
stop()suspended=true;
destroy()thread=null;












十一异常处理
程序中有3种错误：1）编译错误
2）逻辑错误??设计错误
3）运行时错误
GUI设计事件(表达)可忽略
异常处理异常(表达)不可忽略

1异常的内部表达P345图
根类：java.lang.Throwable
两个子类：1）Error类内部的系统错误不能捕捉
2）Exception类由程序和外部环境引起的
RuntimeException可不捕，这类程序常有
异常机制的目的：
??不会减少必要的错误处理的工作量，
它的优点是使程序更容易阅读??通过把所有的异常处理都集中到一个局部位置，使主控制流程免受干扰
2Java异常处理操作
(1)声明异常??可能抛出的异常一定要先声明
Publicvoidmethod()throwsIOException
{
方法体目的：告诉编译器在执行方法的过程中可能出现的错误
}
可不声明：RuntimeException
Error
(2)抛出异常
<1.系统
2.程序本身?thrownewIOException()
方法内部只能抛出下列异常
1、声明的
2、Error、RuntimeException
3、以上的子类
(3)捕获异常
??当调用一个显示声明异常的方法时,必须用try-catch块括该方法
try
{
method();
}catch(IOExceptionex)
{
处理代码
}catch{RuntimeExceptionex}……无限添加（如果需要）

3．执行情况分析
(1)没出现异常跳过Catch子句
(2)出现略过其余语句，转向catch快寻找匹配的处理
<有：执行相应处理，不再管其余catch（第一个匹配的处理）
没有：退出该方法，将异常传给调用该方法的方法

4执行情况分析
(1)没出现异常:跳过catch子句
(2)出现:略过其余语句,转向catch块,寻找匹配的处理,当有多个catch,它找到第一个匹配后就执行,后不执行以后所有catch语句.catch顺序先子后父.
A.有:执行相应处理,
B.没有匹配的catch时就跳出try和catch所在的块.将异常传给调用该方法的方法

5重新抛出异常
当一个方法中出现异常时，如果不捕获就会立即退出。如果想在退出前执行一些处理，而让上一层执行异常处理，则在做完退出处理后，重新抛出异常
6finally子语
希望不论异常是否出现，是否被捕获都执行某些代码
try{}catch(Exceptionex){}finally{可被执行的语句}
7使用注意事项
(1)异常处理不能代替简单测试
(2)不要过分细化异常(目标是:将正常代码与异常处理代码分开)
(3)不要压制异常
(4)不要羞于传递异常



第十二章国际化
本章概括：（表面）??格式、显示、界面
InternationalizatioN??I18N
1．引言
Java支持国际化的主要特征
(1)Unicode：支持多语言字符
(2)Locale类：类封装有关地区特征的信息
(3)ResourceBundle类：将地区特征有关的信息从程序中分离出来

2．Locale类
??java.util.Locale
（1）创建newLocale(Stringlanguage,stringcountry)
newLocale("zh","CN")
newLocale("en","US")
（2）常用属性：P367
（3）常用方法：P368

3．资源簇ResourceBundle类(抽象类)
目的：将程序中地区敏感的代码与不敏感的代码分离
资源簇：就是提供地区特定信息的一个java类文件或文本文件
(1)将资源存放在ResourceBundle类及其子类的扩展类中，java.util.listResourcebundle，扩展类必须实现getContents()方法，并返回一个二维数组，且数组的第一列必须是String型的以作为key(键).
value(值）//相对来讲
优点：访问速度快。
(2)将资源方在文本文件中①必须建一个扩展名为(.properties)的文本文件
②Value必须是String型
优点：修改方便
(3)资源的操作方法
1为了从资源簇中获取值需要用静态方法getBundle(BaseName或Locale)，来创建一个ResourceBundle的实例。BaseName?BaseName_language_country
2用getObject()实例方法，获取对应键的值。例如getObject（”ok”）

(1)对于源对象注册监听器
jcb.addActionLister()
(2)实现监听器接口
<1操作界面上所有组件
2actionPerformed()方法只有一个，产生该事件的源对象都有多个

4处理数字的格式化问题
(1)java.text.NumberFormat类(抽象类)
①获得实例(对象)
(4个静态工厂方法P381页第二行)
②用实例方法format()格式化数字
(2)java.text.DecimalFormat类??是具体类，是NumberFormat的子类
①获得实例
<1）newDecimalFormat(指定Locale)
2)使用NumberFormat类的4个静态工厂方法获得实例后，强制类型转换为DecimalFormat
DecimalFormatdf=(DecimalFormat)NumberFormat.getInstance()
②指定格式importjava.util.*
实例方法applyPattern(“格式化”);
③格式化数字
实例方法format()

5处理日期格式化问题
(1)java.text.DateFormat（抽象类）
①获得实例
(4个静态工厂方法{getInstance()})P369
②用实例方法格式化format()格式日期
(2)java.text.SimpleDateFormat类具体类.DateFormat的子类
①获得实例
newSimpleDateFormat(“格式串”);
②用实例方法format()格式日期
(3)java.util.Date类(具体类)
①获得实例newDate()
②获得时间getTime()//返回的是毫秒数是数字而且是从1970年1月1日0点0分到现在经过多少毫秒
toString()//返回当前时间
(4)java.util.calendar类(抽象类)
①获得实例
静态工厂方法:getInstance(Locale)
指定时区Localezhcn
(5)java.util.TimeZone类(抽象类)
静态工厂方法：getDefault()



十三章多线程
引言：任意时刻可以有多条语句在执行(多CPU)
好处：程序的执行效率高
缺点：进程管理占用系统负荷
线程：就是一个对象，可运行的对象。
对象的类<实现Runnable接口
扩展实现了Runnable接口的类.(Thread类)
1创建线程的方法1??扩展Thread类(java.lang.中)
步骤、（1）定义一个Thread类的扩展类
（2）覆盖publicvoidrun()方法//run()是告知系统如何执行线程
（3）创建对象(用构造方法)
（4）调用该对象的start()方法，将该线程启动（注意不能直接调用run()方法）
start()方法引起run的调用
2创建线程的方法2??实现Runnable接口
步骤、（1）定义一个实现Runnable接口的类
（2）实现publicvoidrun()方法
（3）将该类的对象作为Thread类构造方法的参数，创建一个线程实例
（4）调用该对象的start()方法启动线程
3线程的状态

4控制线程状态的常用方法
（1）start()：启动线程，引起run()方法的调用，(创建线程不自启动)
（2）sleep(Long)：将线程暂停参数指定的毫秒数，(不释放对象锁)
（3）Wait(Long)：将线程挂起制定的毫秒数，(释放对象锁)
Wait()：将线程挂起，直到当调用notify()或notifyAll()时
(这两个方法只能在Synchronized函数中或同步块中使用)
（4）notify()：唤起一个线程
（5）yield()：只希望让其他正在等待的线程有机会执行，且在没有其他线程等待时立即重新执行。
（6）join（）方法：如果一个线程需要等待另一个线程消亡后再继续运行，则可调用希望其消亡的那个线程的join（）方法。
（7）isAlive()判断线程是否处于运行状态
（8）setPriority()设置线程的优先级
另外：Java2不赞成使用stop(),suspend(),resume(),destroy()
原因：它们不释放线程所取得对象锁
5线程编程的4种方式
同步：多个线程间的协调，按照协调方式的不同，线程程序的难度可分为4个等级
（1）不相关的线程??最简单
指执行不同功能的线程之间没有交互关系例子：Drinks.java
（2）相关但无需同步的线程
指一组线程作用于同一数据结构的不同部分，或只读同一数据机构。线程间不需要同步。例子：TestPrime.java
（3）互斥的线程
指一组线程需要操作同一数据结构时，为避免数据结构的不确定性，这些线程必须相互等待以免修改同一数据
说明：java中线程的互斥时建立在类（对象）数据的基础上的，java中的每个对象都又自己的Lock标志，可以用作同步。
对象锁机制：每个线程在改变某个对象之前必须首先获得该对象的锁，且在每一时刻只会有一个线程能够锁住该对象
（先获锁，再访问，一次只有一个线程能获得锁）
①获锁<得到??代码执行
被另一个线程占用（没得到）??挂起直到锁被释放
②对象锁：当调用任何synchronized方法时，对象便被锁定，该对象的所有synchronized方法便无法再被调用，直到第一个方法执行完毕并解除锁定为止。
③类锁：当调用任何synchronizedstatic方法时，类便被锁定，该类的所有synchronizedstatic方法便无法再被调用，直到第一个方法执行完毕并解除锁定为止。
④同步区块：synchronizedblock
synchronized(对象名/this){data++}
ObjectO=newObject()；
线程组
用途：具有类似功能线程需作为一个整体操作
（4）交互的互斥线程
指在线程交互传递数据时，当一个线程等待其他线程提供数据，但数据尚未就绪时，他将因等待数据而暂停执行。这就是典型的wait/notify线程同步问题

每一个java对象都有一个等待线程列表
（1）当线程调用了一个对象的wait（）方法时，系统就把这个线程加到该对象的等待线程列表上，并暂停这个线程。
（2）当另一个线程调用同一个对象的notify()/notifyAll()方法时，该对象会唤醒等待该对象的线程，并允许它继续运行
wait/notify同步机制最常见的用途是解决生产者/消费者问题
（1）生产者线程模板
while(buffer_full)
{wait();}
ptofuvr_data();
notify();
（2）消费者线程模板
while(no_data)
{wait();}
consume_data();
notify();
（3）主程序
main()
newProducer().start();
newConumer().start();



第十四章多媒体
多媒体??开发常有音频和图像的程序{①装载
②播放/显示
一．URL（UniversalResourceLocate）
描述internet上的资源位置{本地：目录
internet：URL
java.net.URL类用于处理url
applet的安全限制1不允许读取用户计算机上的文件系统
P162不允许运行用户计算机上的程序
3不允许建立用户计算机和其他计算机连接（网络连接）
获得url：
①applet中：
{java.applet.applet类中{getCodeBase()返回applet所在目录(url)
getDocumentBase()返回HTML文件所在目录（url）
②Application中：
java.lang.Class类中{getResource(filename);
调用任意对象的getClass()获得Class的实例
二．java.applet.AudioClip接口
1装载(获得AudioClip实例的方法)
（1）applet：java.applet.Applet类中的getAudioClip(URLurl);
（URLurl,Stringfilename）;
（2）Application：java.applet.Applet类中的静态方法
Applet.newAudioClip(URLurl);
2播放AudioClip实例的{play()
loop()
stop()
三．java.awt.Image类
1装载（获得Image实例）
（1）applet：java.applet.Applet类中的getImage(URLurl)
（URLurl,Stringfilename）
（2）application：使用ImageIcon类中getImage（）
ImageIconimageIcon=newImageIcon(url)
imageIcon.getImage();
2显示
（1）将一个标签用作图像的显示区域
JLabeljll=newJLabel（imageIcon）
（2）java.awt.Graphic类drawImage（）P425页
参数指定图像左上角坐标背景色按比例缩放观察者
imgx,ybycolorwidth/heightImageObserver（接口）
imageUpdate()
Java中所有GUI组件都是ImageObserver的实例

mediaTracker
1创建new
2注册addImage(img，id)
3控制<checkID（id）
waitForID(id)
waitForAll（）



第十五章文件的输入输出
一引言
1Java中所有的I/O(各种数据源)都是数据流的形式进行处理的
2Java中数据流是一个对象（类）包含一些读写数据的方法，以及一些辅助方法，关闭、刷新、统计
3数据流按读写单位来分
{字节（byte）8个
字符（character）16个
4大部分数据流对象都是单向的
RandomAcessFile类是双向的
二输入InputStream/Reader(抽象类)字节/字符
intread();intread();0-255
intread(byte[]b);intread(char[]c);
三输出OutputStream/Writer（抽象类）字节/字符
Voidwrite（byteb）voidwrite（charc）
Voidwrite(byte[]b)voidwrite(char[]c)
四磁盘文件的读写
1file类处理文件名和路径名string的包装类（Wrapper）
2使用{（1）创建一个file对象
FileF=newFile(“in.dat”)
(“c:\\book\\in.dat”)
（2）常用方法exists（）、getName（）、getPath（）、getParent（）
2使用文件数据流进行行读写
<FileInputStream/FileOutStream
FileReader/FileWriter
（1）创建文件数据流
Stringfilename(String）
（Filefile）
（2）读写方法read()、write（）
五过滤器流为了某种谜底的过滤字节或字符数据流
程序<??filter<??FileInputStream<??File
程序??>Filter??>FileWrite??>File
为了读取整数浮点数字符串需要一个过滤器事包装输入输出流
（抽象类）FilterInputStream/FilterOutputStream用于处理基本数据类型。常使用它们的子类
1DataInputStream/DataOutputStream
以机器无关的方式读/写Java的基本数据类型数据
（1）创建一个包装原始数据流的过滤器
newDataInputStream(InputStreamis);
newDataOutputStream(OutputStreamOS);
（2）常用方法P445
2PrintStream/PrintWriter
3缓冲数据流??（过滤器）
??采用减少读写次数的办法，加快输入输出的速度，使用字节数组或字符数据，作为高速缓冲(cache)
BufferedInputStream/BufferedOutPutStream（字节）
BufferedReader/BufferedWriter（字符）
使用{（1）创建new（InputStreamis）
（InputStreamis，intbufferSize）
（2）常用方法：readline()整行读取
例子：ViewFile.java

复习
InputStream/OutPutStreamFileInputStream/FileOutputStrea
(共用方法)
IO<抽象数据源磁盘文件数据源
Reader/WriterFileReader/FileWriter
1读取基本数据类型
DataInputStream/DataOutputStream
2输出文本格式
printStream，printWriter
3整块读写
BuffedInputStream/BuffedOutputStream
BuffedReader/BuffedWriter

六文件对话框
Java提供了显示对话框的javax.swing.JFileChooser类使得用户可以在对话框漫游文件系统
常用属性：P453

11控制台文本I/O
System{in从键盘读入
out数据结果显示
err错误显示
staticPrintStreamout,err;
InputStreamin;
评价Java缺少基本的终端输入方法，如果要执行交互式I/O,Java认定通过GUI进行。
解决方法：Java没有立即读取用户输入的单个字符的方法。Java从终端读取字符的唯一方式是当入户按下回车键后,一次性读取一行
解决具体步骤：
（1）在System.in上包装InputStreamReader类
??使能够这个Reader类的基础在包装其它Reader类
（2）在InputStreamReader类的基础上包装BufferedReader类该类中的readline（）方法将读取整行数据
（3）在读入的字符串上包装java.util.StringToKeizer类该类中netToKen（）依次抽取ToKen
（4）调用基本类型的包装类中parseXXX方法，抽取期望的数据类型
八对象数据流
（只要一个对象实现了Serializable接口或者Externaalizable接口）
I：ObjectInputStream
O：ObjectOutputStream
读：readObject（）
写：writeObject（）


JDBC（JavaDataBaseConnectivity）
1JDBC是一组由Java类和接口组成的API其设计目的是以平台独立的方式实现application和applet对不同类型的数据库进行访问
2JDBC能完成的3个事
{①与一个数据建立连接
②向数据库发送SQL语句
③处理数据库返回结果
3JDBC的体系结构

4驱动程序的4种类型
（1）JDBC-ODBC桥将对JDBC的调用转化为对ODBC的调用

（2）nativeAPI将对JDBC调用转化为数据库客户端的调用

（3）JDBC-NetDriver

（4）纯JavaDriver将对JDBC的调用转换为对数据库协议的调用

5JDBCAPI的组成java.sql.*
（1）驱动程序管理器（DriverManager）
用来加载驱动程序
（2）连接（Connection）
封装了应用程序与数据库的连接信息
（3）驱动程序（Driver）
将应用程序的JDBCAPI调用映射为对数据库的操作
（4）语句（Statement）
用来在数据库中执行一条SQL语句
（5）结果集（Resultset）
负责保存检查返回的数据




文档注释javadoc-ddocjavadocDemo.java
1．如何插入注释
/**自由文本（可加入html修饰符）*/
javadoc1，包
2，public类接口
3，public和protected的方法和属性
2．类注释
直接放在class的定义前
3．方法注释
必须紧靠在它所描述的方法前
@ParaVariabledescription
@returndescription
@throwsclassdescription
4．字段注释
5．通用注释方法
①专用描述类
@authorname
@versiontest
②描述所以（类，属性，方法都适用）
@sincetext引入此特性版本
@deprecatedtext废除此特性版本
@seelink1.packageclass#featurelabel
2.<ahref=”…url…”>lable</a>
3文本
@link可在注释的任何地方插入
6．包的注释
7如何提取javadoc?d存放目录*.java








附录H包
包java.applet.Applte红色部分是包名
1．包是解决名称的唯一性
(1)包有层次关系,可以嵌套
(2)java设计者建议用所在单位的internet域名来命名
例:neusoft.edu.cn为cn.edu.neusoft
(3)Java要求包名与文件系统的目录结构一致
2．设置环境变量classpath指定起始目录
1)包=目录,类=文件.class
2)如何告诉编译器一个类属于那个包
源程序.java文件中的第一条非注释语句
packagexxx.xxx.xxx.……
3．如何创建与包结构对应的目录
(1)手工建
(2)javac?d包的根目录名xxx.java
javac?dc:\
javac?d.xxx.java其中：“．”代表classpath的路径
例如：javac?d.Applet.java
4．JVM寻找类的方法
自动查找(1)$JavaHome/jre/lib/ext目录（保留）
(用户)(2)$JavaHome/jre/class目录(用户)
(3)环境变量classpath所设置的目录
5．导入improt
没有package指定说明，默认包==当前目录
import包名A<可用：引用另一包中的类,省略包名
可不用：引用另一包中的类,都必须加上包名











UML图标及其Java实现
(1)Package

Packagecom.java;
(2)依赖关系Dependency
1.关系对象出现在局域变量或者方法的参量里
2关系类的静态方法被调用
(3)Association关联关系
关系对象出现在实例变量中
(4)Aggregation聚集关系

(5)Composition组合关系

(6)Generalization泛化（继承）关系
Extends
(7)Realization实现关系
Implement































实用角度看Java
第1篇
一．章引言??入门<packageXXX
ImportXXXX
类定义
二．基本变量（8种）??操作内存变量的传递都是值传递
三．控制语句??控制CPU
四．方法??模块化思想
第2篇
五．类??面向对象的基础封装
六．类的继承（接口，抽象类）多态
七．数组，向量
第3篇C/S
八．容器、布局管理器、事件处理基础
九．组件
十．鼠标事件、键盘事件、Applet、GridBugLayout
第4篇
十一．异常处理??思想（捕获）
十二．国际化（日期、数字、界面文本）资源簇
十三．多线程<1．声明、创建
2．线程状态
3．常用方法
4．四种线程编程方式
十四．多媒体音频、图象
AppletApplication
十五．抽象I/O/磁盘文件I/O/过滤器
十六．SevereSocket、Socket


考试角度看Java
1．程序结构
2．字符串和数组的定义与声明
3．构造方法的重载调用形式
4．父子类之间的转换强制类型转换
5．覆盖可见性可以变宽，不能窄化。Throw变窄
6．内部类，m.java
7．super();不能放在main()中
8．InstanceofaInstanceof接口
9．
10．背景色setBackground(Color.whrite)
11．4个布局管理器怎么指定位置
12．setEnabled(false)按纽
13．整形变量??>char
字符串??>10进制整数
Char??>字符串

14．多线程publicvoidrun(){}
15.打开一个图象文件的方法8章tookit
14章applet,application
16．Filef=newFile(“/”,”a.au”),
DataIputStreamd=newDataIputStream(System.in)
OutIputStreamWritero=newOutIputStreamWriter(System.out)
RandomAccessFiler=newRandomAccessFile(“out.log”)
17.重载覆盖

编程
II18velcome.java
13章，互次SynPressureDemo1，2，3
钟表

辨析：