上学时候的ＪＡＶＡ笔记

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

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

Java语言最大的优点??可移植性
 
Java 版本
1 J2SE(标准版)中型平台 standard edition
2 J2EE(企业版)大型平台 Enterprise edition
3 J2ME(微型版)嵌入式   Micro Edition

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




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

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



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

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

2 switch
(1)switch (~)括号
(2)switch表达式要能计算出一个char,byte,short,int的值(只能是这四种)
3 while循环 和do-while选还
while 先判断后执行(for 等价于 while循环)
do-while先执行后判断
三、关键字break和continue的区别
1．不带标号 
break中止最内层循环,continue中止最内层循环的本次迭代(循环次数一次是一个迭代)
for (int i=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(~~~)
{
Break layer1
}




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




第五章 使用对象和类编写程序
一，类的uml表示法
 
二，类的定义       [m] 修饰符
[m]  class  classname  extends  superclass_name1, superclass_name1  implements  implements1, 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类）//

五，实例变量/方法<??>类变量/方法
㈠实例变量（instance variable）：[m] 类型名 变量名
类变量（class variable）：    [m] static 类型名 变量名
    a)类变量：描述对象的公有属性，只能有一个副本，
    b)实例变量：描述对象的特有属性，有多个副本，
㈡实例方法：只能在实例创建后使用。[m] 返回型 方法名（参数1 ，参数2....）
  类方法：可在实例创建前后使用。[m] static返回型 方法名（参数1 ，参数2....）
          例如：Math.sqrt();
㈢实例变量/方法的引用   对象名.data/method
  类变量/方法的引用  ① 对象名.data/method
                     ② 类名.data/method     （推荐使用）
㈣实例变量不可能被类方法访问。
   
㈤类成员储存在类的公用内存，
实例成员在每个实例中都有副本。
六. 全局变量和局部变量的比较
1.全局变量（Globle）：实例变量+类变量。
  局部变量（Local）： 方法中定义的变量。
   例如：
       class A
       {
           变量 ??>全局变量
           方法
{
   变量 ??>局部变量
}
}
2.初始化:Globle 有默认初始值。char  “/u0000”, 整型 0 , 浮点型 0.0 , boolean  false
                            类对象变量 null
Local  没有。
3.作用域（变量可以被引用的区域）：
    Globle：整个类；可在任何位置声明，没有顺序关系。
    Local：从声明处开始延续到块尾,要先声明再使用。
4.声明次数：
   Globle：只有一次。Local：在互不嵌套的情况下可以声明多次。
5.同名：a.当Globle与Local同名时，L优先，G隐藏。
        b.若想引用：  类名.变量名；  （类变量）
                      this.变量名。   （实例变量）
七. 关键字 this
 用途1：引用实例变量    实例方法
                         构造方法    
在实例方法或构造方法中访问隐藏的实例变量
例如：class A
      {
        int i = 5;
        void setI(int i) { this.i = i;}
}
     2：this() 语句（可有参数）  Java要求this()语句出现在构造方法中的任何语句之前
        例如：  class Circle
                { 
int radius;
                  circle(int r) { this.radius=r; }
                  circle() { this (5);}
} 
        
八. 类成员的可见性修饰符
  public：任何包中
  defaut（不写）： 本包中 
  private： 本类中??本类中使用，不能继承，不能在子类中访问
  protected： 子类中?? 可以被同一包中的任何类或它的子类访问，即使子类在不同的包中也可以，但不能被继承       
九．字符串
㈠String类   java.lang.String
(1)创建： ①String 变量名=new String("IBM")；
           ②String 变量名="IBM"；
(2)常用方法
    ①比较："= =" 检验两个字符串变量是否引用同一对象(地址)
         equals()检验来那个字符串变量是否引用同一对象(值)
    ②其他：P124-126
㈡StringBuffer类   java.lang.StringBuffer   P126
⑴创建： StringBufer 变量名=new StringBuffer(D)
  StringBuffer类提供三个构造方法    
㈢StringTokenizer类 (解析字符)   java.util.StringTokenizer    P128
⑵创建 new.
  StringTokenizer st=new StringTokenizer("i am a student")

十．访问器方法     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 类名    例: (a instanceof B)返回布尔值
六、
1对象的初始化－－属性(对象的状态)
1)构造方法：
    a) 实例属性
    b) 类属性
2)定义：
    a）实例属性－－>编译??>插入到构造方法
    b) 类属性－－>编译??>插入到类的初始化方法中。    
    第一次访问类时调用初始化方法：a)new方法 
b)类名.属性/方法
3)初始化模块
① {实例变量  初始化｝
② static｛类变量  初始化｝

2函数调用的绑定方式
method call<??>method body  
方法调用         方法体
A. 先期/静态绑定：执行前(C语言、面向过程语言)
B. 后期/动态绑定：执行时
Java中所有方法都是动态绑定，除了final方法
3 final关键字
① 类： 终极类(不可继承)
② 属性：(变量)＝＝常量(子类可以重定义。在父类中定义常量，可以在子类中重新定义为变量)
③ 方法：子类中不能重新定义和修改 （静态绑定）
4 Object类
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，那么定义的这个方法可以不包含具体的实现
例子：abstract  method（P）;  //{}可以不写
2．抽象类
任何包含抽象方法的类是抽象类，且要显示的声明abstract，但是抽象类可以不包含抽象方法
3．一些规则
（1）抽象类不能实例化   
（2）当抽象类的子类 1 实现部分抽象方法，子类仍是抽象类
                    2 实现全部抽象方法，子类是具体类
（3）static，private，final不能是抽象的。因为这些方法不能被子类覆盖
（4）终极类（final类）不能含抽象方法。
（5）不包含抽象方法的类，也可以声明为抽象类，也不能被实例化。
㈡ 接口（也是一种数据类型）
1、定义：关键字 interface   
interface  接口名  例如：public interface 接口名 {}，产生 接口名.class 的文件
       可以当成一种特殊的类 也不能实例化
2、限制规则
1) 接口不包括任何实现，其中的所有方法都是默认为抽象方法，所有的方法都是实例方法
2) 接口方法默认都是public型的 
3) 接口中不能定义实例变量和静态变量，只允许用static和final声明的变量??静态常量
4) 接口不能实例化，所以接口中不定义构造方法
3、接口的实现
定义：关键字 implement
实现了  所有的，可实例化
      部分，必须显示把自己声明为abstract

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

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




第七章 数组和向量
一、数组
1．声明和创建数组
(1)声明：数据类型 [ ] [ ] [ ] 数组名/数组对象变量
例如：int [ ] [ ]   i;
String [ ]   s;
Circle[ ] [ ] [ ]  c;
(2)创建：数组名 = new 数据类型 [大小][大小]
s=new String[10];
c=new Circle[5][6][7];
(3)声明+创建 
数据类型[ ][ ][ ] 数组名 = new 数据类型 [数组大小]   （推荐使用）
     数据类型  数组名 [ ][ ][ ] = new 数据类型 [大小]
Circle [ ]  c = new Circle[5];
double [ ]  mylist = new double[5]; 
2.    初始化及处理
数组的大小：arrayObject.length 指定      c.length  、 mylist.length
例如： Circle [ ] c;
       c = new Circle [5]；
       c.length=5;  初始化：for(int i=0;i<c.leagth;i++)
                          c[i] = new Circle[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={new Circle(1),new Circle(2),new Circle(3)}；
5、数组复制的3种方法  P182页
用循环语句复制数组的没一个元素。
For (int i = 0; I < Array1.length; i++)
  Array2[i] =Array1[i];
使用Object 类的clone方法
Int[] arry1=(int[])arry2.clone();
使用 System类中的静态方法arraycopy
    Arraycopy(array1, 1 pos, array2, 2pos,length);
二、将基本数据类型处理为对象  P186页
1、包装类
三、向量类   P197

复习
包装类

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

Java 图形类库
1容器（Container） JFrame  (有且只有一个)框架??Application 
JPanel   面板??Application / Applet
JApplet   Applet
2组件（Component） JButton、JTextField、JTextArea、JcomboBox等
3辅助类           Color、Font、FontMetrics、Dimension、LayoutManager、等
一、JFrame（框架类）  在包import.javax.swing 中
1 创建：  import  javax.Swing.*
JFrame frame = new JFrame（）；
2 设置大小
setSize（宽,高）；
3 使可见
show();          //显示框架方式1（在最前方）
setVisible(true);   //显示框架方式2
4 setDefaultClose_Operation（JFrame.EXIT_ON_CLOSE）
告诉应用程序，框架关闭时程序结束。
dispose();    //关闭窗口，并回收用于创建窗口的任何资源
5指定位置
setLocation（x,y）?? (x, y)左上角坐标
6向框架中添加组件
只能在内容窗格上添加组件（ContentPane）
获取内容窗格：getContentPane（）；
Container cp = getContentpane();
cp.add(new JButton(“ok”);
getContertPane().add(new JButton(“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的更小容器，用于组织组件的更小容器，面板不可见。
JPanel p= new JPanel(); 
p.add(new JButton(“ok”));
p.add(new JPanel());
对比：JFrame和JPanel
  ⑴
 
⑵给JFrame添加组件到内容窗格
  给JPanel直接添加到面板上
⑶JFrame中画图用paint（）方法
  JPanel中画图用排paintComponent（）方法
四、在面板上画图
1、方法：创建一个JPanel的子类，并覆盖paintComponent（）方法
Public void paintComponent(Graphics g)
2、Graphics 类 （绘图） java.awt.Graphics
3、显示字符串：g.drawString(s, x, y);
绘制几何图形drawLine(); 绘制几何图形的方法  P221
  显示图像 drawImage(Image);
4、比较：  在框架和面板上绘图
   ⑴在框架中绘图  
        ①产生一个JFrame的子类
②覆盖 public void paint(Graphics g)
   ⑵在面板中绘图
①产生一个JPanel的子类
②覆盖public void paintComponent(Graphic g)
  注意：以上要先调用父类的相应方法来清除视区??清除以前画的
  JFrame     super.paint(g)
  JPanel     super.paintComponent(g)
五、个比较常用的辅助类 P205页
1、color类 java.awt.Color
自调制： Color c= new Color(R,G,B)
(0~255)
Component类中的方法：设置颜色
SetBackgroud(c)；??背景色。SteForeground(c)；??前景色
Graphics中设置颜色方法setColor (c)
2、Font类 ??设置字体
Font f= new Font (name,style,size)
setFont（f）；
3、FontMetrics类  P217页
??帮助计算字符/字符串的高度和宽度
Graphics中设置字体方法getFontMetrics(f) 
FontMetrics fm = getFontMetrics (f)
fm.getAscent ();
fm.stringWidth (“hello”);
4 ToolKit 类(它对象有许多和本地窗口打交道的方法)
Toolkit kit= Toolkit.getDefaultToolkit ();
Dimension d= kit.getScreenSize ();
d.width 、d.height
Image img=Kit.getImage (“xxx.gif”)
六、事件驱动的程序设计
GUI   程序驱动??过程顺序
        事件驱动??激活事件
用户通过GUI与程序交互，事件驱动着程序的执行
1、事件(Event) 引发者   ①外部人
                   ②底层系统软件
程序发生了某些事情的信号
内部表达事件：用事件类的一个实例（对象）来表达该事件，这个事件对象包含与事件有关的一切属性。 
java.util.EventObject 类?? 一切事件的父类  P231页
2、源对象(source Object)
??在其上发生事件的组件
注意：一个组件上发生某个事件，那么这个组件的任何子类也能发生同类事件
3 事件的处理机制
监听器(Listener)：是一个关心事件的对象并对特定事件做出相应处理
注册：调用源对象的方法(addXListener()）声明某对象为监听器
JButton jbtok=new JButton(“ok”);
jbtok.addActionListener(监听器对象)；
Java 为每种GUI事件类型提供了一个监听接口 P237页

Class 监听器 implements ActionListener
{
Public void actionPerformed(ActionEvent e)
{
响应事件的处理代码
}
}
 
具体用户行为、源对象、事件类型、监听接口、监听方法：   P231页8-27? P232页8-28










一．JApplet类中的常用方法
1．Init（）：装载applet时调用
创建新线程  new Thread
  装载图像
  设置用户界面组件
  从HTML网页中获取参数  
2．start()：init()完成后，再次访问包含applet的网页时，（第一次，和在跳回来）
方法中的主要功能：所有方法HTML页的主要操作
3．stop()：离开网页时，或包含applet的web页不可见时（窗口最小化）
4．destroy()：当浏览器退出时或apple被销毁前
二．在不支持java的浏览器中运行applet
1 要安装java plug-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文件中声明<param name=X value=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环境中运行appletviewer XXX.java
Timer timer = new Timer(时间间隔，监听器);
timer.start();
timer.stop();


boolean suspended
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 可不捕，这类程序常有
异常机制的目的：
??不会减少必要的错误处理的工作量，
它的优点是使程序更容易阅读??通过把所有的异常处理都集中到一个局部位置，使主控制流程免受干扰
2 Java异常处理操作
(1)声明异常??可能抛出的异常一定要先声明
Public void method() throws IOException
{
方法体 目的：告诉编译器在执行方法的过程中可能出现的错误
} 
可不声明： RuntimeException
           Error
(2)抛出异常
< 1.系统
  2.程序本身?throw new IOException()
方法内部只能抛出下列异常
1、声明的
2、Error 、RuntimeException
3、以上的子类
(3)捕获异常
??当调用一个显示声明异常的方法时,必须用try-catch 块括该方法
try 
{
method();
}  catch(IOException ex)
{
处理代码
} catch{ RuntimeException ex}……     无限添加（如果需要）

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

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

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



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

2．Locale类   
?? java.util.Locale
（1）创建  new  Locale (String  language , string country)
           new  Locale ("zh" , "CN")
           new  Locale ("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操作界面上所有组件
 2 actionPerformed( )方法只有一个，产生该事件的源对象都有多个

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

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



十三章 多线程
引言：任意时刻可以有多条语句在执行(多CPU)
好处：程序的执行效率高
缺点：进程管理占用系统负荷
线程：就是一个对象，可运行的对象。
对象的类   <实现Runnable接口
扩展 实现了Runnable接口的类.(Thread类)
1 创建线程的方法1??扩展Thread类(java.lang.中)
步骤、（1）定义一个Thread类的扩展类
     （2）覆盖public void run( )方法  //run( )是告知系统如何执行线程
     （3）创建对象(用构造方法)
     （4）调用该对象的start()方法，将该线程启动（注意不能直接调用run()方法）
start()方法引起run的调用
2创建线程的方法2??实现Runnable接口
步骤、（1）定义一个实现Runnable接口的类
     （2）实现public void run()方法
     （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方法便无法再被调用，直到第一个方法执行完毕并解除锁定为止。
③类锁：当调用任何synchronized static方法时，类便被锁定，该类的所有synchronized static方法便无法再被调用，直到第一个方法执行完毕并解除锁定为止。
④同步区块：synchronized block 
synchronized(对象名 / this){data++}
Object O=new Object( )；
线程组
用途：具有类似功能线程需作为一个整体操作
（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（Universal Resource Locate）
描述internet 上的资源位置    { 本地：目录
                               internet：URL
java.net.URL 类用于处理url
applet的安全限制   1 不允许读取用户计算机上的文件系统
   P16             2 不允许运行用户计算机上的程序
                   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(URL url);
                                                  （URL url,String filename）;
（2）Application： java.applet.Applet类中的静态方法
                                      Applet.newAudioClip(URL url);
2 播放 AudioClip实例的{ play()
                         loop()
                         stop()
三．java.awt.Image类
1 装载（获得Image实例）
 （1）applet：java.applet.Applet类中的getImage(URL url)
                                              （URL url,String filename）
（2）application：使用ImageIcon类中getImage（）
                            ImageIcon imageIcon = new ImageIcon (url)
                            imageIcon.getImage();
2 显示 
 （1）将一个标签用作图像的显示区域
          JLabel jll= new JLabel（imageIcon）
 （2）java.awt.Graphic类drawImage（） P425页
参数指定    图像    左上角坐标    背景色    按比例缩放    观察者
    img    x , y     bycolor    width/height    ImageObserver（接口）
imageUpdate()
Java中所有GUI组件都是ImageObserver的实例

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



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

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

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

11 控制台文本I/O
System { in 从键盘读入
         out 数据结果显示
         err 错误显示
static PrintStream out,err;
       InputStream in;
       评价 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（Java DataBase Connectivity）
1 JDBC是一组由Java类和接口组成的API其设计目的是以平台独立的方式实现application和applet对不同类型的数据库进行访问
2 JDBC能完成的3个事
{ ①与一个数据建立连接
②向数据库发送SQL语句
③处理数据库返回结果
3 JDBC的体系结构
 
4 驱动程序的4种类型
（1）JDBC-ODBC桥  将对JDBC的调用转化为对ODBC的调用
 
（2）native API 将对JDBC调用转化为数据库客户端的调用
 
（3）JDBC-Net Driver
 
（4）纯Java Driver 将对JDBC的调用转换为对数据库协议的调用
 
5 JDBC API的组成 java.sql.*
（1）驱动程序管理器（DriverManager）
     用来加载驱动程序
（2）连接（Connection）
     封装了应用程序与数据库的连接信息
（3）驱动程序（Driver）
     将应用程序的JDBC API 调用映射为对数据库的操作
（4）语句（Statement）
     用来在数据库中执行一条SQL语句
（5）结果集（Result set）
负责保存检查返回的数据




文档注释 javadoc -d doc javadocDemo.java
1．如何插入注释
/**自由文本（可加入html修饰符）*/
javadoc 1，包
       2，public 类接口
       3，public 和protected 的方法和属性
2．类注释
直接放在class的定义前
3．方法注释
必须紧靠在它所描述的方法前
@Para Variable description
@return description
@throws class description
4．字段注释
5．通用注释方法
①专用描述类
@author name
@version test
②描述所以（类，属性，方法都适用）
@since text 引入此特性版本
@deprecated text 废除此特性版本
@see link  1.package class # feature label
                2.<a href=”… 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文件中的第一条非注释语句
package xxx.xxx.xxx. ……
3．如何创建与包结构对应的目录
(1)手工建 
(2)javac ?d 包的根目录名 xxx.java
  javac ?d c:/
  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
 
Package com.java;
(2)依赖关系Dependency
 1.关系对象出现在局域变量或者方法的参量里
2 关系类的静态方法被调用
(3)Association 关联关系
 关系对象出现在实例变量中
(4)Aggregation 聚集关系
 
(5)Composition组合关系
 
(6)Generalization 泛化（继承）关系
 Extends
(7)Realization实现关系
 Implement































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


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

14．多线程   public void run (){}
15. 打开一个图象文件的方法  8章  tookit
                           14章  applet,application
16． File f = new File(“/”,”a.au”),
     DataIputStream  d  = new  DataIputStream(System.in)
     OutIputStreamWriter  o  = new  OutIputStreamWriter (System.out)
     RandomAccessFile  r = new RandomAccessFile(“out.log”)
17.重载 覆盖

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

辨析：