Java学习笔记2

目录

• Java语言简介
  • 常用命令
  • 包装器类
• 2 数据类型
• 3 运算符和表达式
• 4 流程控制
• 5 Java的继承、多态、高级类特性和数组
  • 5.2 继承与多态
    • 5.3.3 枚举类型
    • 5.3.4 抽象类
    • 5.3.5 接口
      • 接口与抽象类的区别
      • 接口的声明
      • 接口的实现
      • 接口作为类型的使用
      • 接口与abstract类的比较
    • 5.4 内部类
    • 5.5 数组
      • 5.5.1 一维数组
      • 5.5.2 二维数组
        • 数组的复制
• 6 异常和断言
  • 6.1 异常概述
  • 6.2 异常的处理
    • 抛出异常
    • 自定义异常
    • finally语句
  • 6.3 断言
• 7 输入输出及文件操作
  • 7.1 流的概念
    • 标准的I/O流
  • 7.2 文件
    • 目录
    • 随机文件流
  • 7.3 字节流
    • InputStream
    • OutputStream
    • 数据流
    • 文件流
      • FileInputStream
      • FileOutputStream
    • 内存的读写
      • ByteArrayInputStream
      • ByteArrayOutputStream
  • 字符流
    • FileReader
    • FileWriter
    • 缓冲流
      • BufferedReader
      • BufferedWriter
    • Scanner类
  • 7.5 对象流
    • ObjectInputStream和ObjectOutputStream类
      • 可串行化
  • 7.6 过滤流
    • 字符过滤流
  • 7.7 管道
  • 7.8 不同流的速度比较
  • Java I/O流的其它应用
• 8 线程
  • 8.1 线程的概念
    • 线程模型
  • 8.2 线程的创建
    • 通过继承Thread类构造线程
    • 通过实现Runnable接口构造线程
  • 8.3 线程的调度与控制
    • 线程的优先级
    • 线程的基本控制
      • sleep()
      • yield()
      • join()
      • interrupt()
      • currentThread()
      • isAlive()
      • suspend()和resume()
  • 8.4 线程的同步
    • 2 对象锁及其操作
    • 3 线程间的交互
      • wait()
      • notify()
  • 8.5 线程的状态
    • Newborn
    • Runnable
    • Running
    • Blocked
    • Dead
  • 8.6 线程相关的其他类与方法
    • 8.6.1 支持线程的类
    • 8.6.2 线程组
    • 8.6.3 Thread类的其他方法
• 9 编写图形用户界面
  • 9.1 用AWT编写GUI
    • 9.1.1 基本的GUI类
      • Component类
      • Container类
    • 9.1.2 常用容器
      • Frame 窗口
      • Panel
    • 9.1.3 布局管理器 LayoutManager
      • FlowLayout
      • BorderLayout
      • GridLayout
      • CardLayout
    • 容器的嵌套
    • Button Event 处理步骤
      • ActionListener
    • 事件类
    • 事件监听器
    • AWT事件及其相应的监听器接口
      • ActionEvent事件
      • Window事件
      • ComponentEvent事件
      • ContainerEvent事件
      • FocusEvent事件
      • ItemEvent事件
      • TextEvent事件
      • KeyEvent事件
      • MouseEvent
        • MouseListener
        • MouseMotionListener
    • 9.2.4 事件适配器类
      • 适配器类 Adapter
      • 内部类
      • 匿名类
  • 9.3 AWT组件库
    • 常用的基本组件
      • CheckBox 复选框
      • 复选框组
      • 下拉式菜单（choice）
      • 画布
      • 单行文本输入区（TextField）
      • 文本输入区（TextAera）
      • 列表
      • Dialog
      • FileDialog
      • MenuItem
      • Menu
      • MenuBar
      • Color
      • Font
  • 9.4 用Swing编写GUI
    • Swing概述
    • Swing的特性
  • 9.5 Swing组件和容器
    • 组件的分类
    • 使用Swing组件的基本规则
    • 各种容器面板
      • 根面板
      • 分层面板
      • JPanel
      • JScrollPane
      • JSplitPane
      • JTabbedPane
      • JToolBar
      • JInternalFrame
    • 各种组件
      • JButton
      • JCheckBox
      • JRadioButton
      • JComboBox
      • JProgresBar
      • JTable
      • JTree
      • JOptionPane类
    • 4. 布局管理器
      • 事件处理
• 10 Applet
  • 与Application的关系
  • Applet工作原理
  • Applet的生命周期
  • 9.2 Applet的类层次结构
  • 9.3 Applet类API
  • 10.2 Applet的编写
    • 在HTML中applet标记的使用
    • 使用标记参数向Applet传递信息
      • 获取参数步骤
  • 10.3 Applet与GUI
    • 1. Applet中的事件处理
    • 2. 基于AWT组件的Applet用户界面
    • 3. 基于Swing组件的Applet用户界面
    • 4. JApplet添加构件方法
      • 方法1
      • 方法2
  • 10.4 Applet的多媒体支持
  • 10.5 Applet与工作环境的通信
• 11 集合与泛型
  • 11.1 集合的概念
    • 集合类的特点
    • 集合体系结构
    • 集合分类
      • Set
      • List
      • Map
    • 简单集合类
      • Vector
      • ArrayList
  • 11.2 泛型
    • 泛型类
    • 泛型接口

Java语言简介

• 源程序，字节码程序
• .class文件
• 垃圾回收 机制
  Java运行环境 JRE
• Java SE(J2SE)
• EE ME
• JVM 加载、校验、执行

常用命令

• Javac：编译器

• java:

• 反汇编：javap

• 可读性第一，效率第二

• Java application

• Java applet

• netbeans IDE

• NULL 不是关键字

• finally 是关键字

• $开头为合法标志符

• 基本数据类型

命令	作用	备注
成员变量	可以不初始化
局部变量	必须初始化

包装器类

• Java每种数据类型都有一个包装器类，对于xxx类：

  • valueOf(String str):返回指定String值的xxx对象
  • xxxValue：返回xxx对象

• byte、char、short数据之间的运算结果是int

• 自增符不能用于表达式

• 定义成员方法的语法格式：
  权限修饰符 返回值类型 方法名（参数类型 参数名）{

  }

2 数据类型

3 运算符和表达式

4 流程控制

5 Java的继承、多态、高级类特性和数组

5.2 继承与多态

Food mlt = new MaLaTang();

• 声明类型 Food
• 实际类型 MaLaTang
• 调用的方法在子类和父类中都有，那么最终的方法调用以实际类型为准
• 如果声明类型与实际类型不一样，且调用的方法是实际方法独有的，那么该方法不能调用。

5.3.3 枚举类型

public enum Season
{
a,b,c,d;
}

5.3.4 抽象类

abstract class A

• 抽象类不可以实例化对象
• 抽象类必须被继承，与final类相反
• 可以定义一个统一的编程接口LLLL
• 抽象类定义所有子类共用的抽象方法，实现细节由子类完成
• 抽象类可以继承抽象类，普通类可以继承抽象类；抽象类可以继承普通类；
• 普通类可以继承接口，
• 接口可以继承接口（通过extends），但不可以继承抽象类

5.3.5 接口

• Java不支持多继承

接口与抽象类的区别

• 抽象类中可以有具体方法，接口必须全部为抽象方法
• 抽象类中的方法可以使用多种修饰符来修饰，接口中的方法必须通public abstract来修饰
• 抽象类中的属性可以使用多种修饰符来修饰，接口中���方法必须通public static final来修饰

接口的声明

• [修饰符] interface In1 [extends 父接口名]
• 接口只能包含常量定义和抽象方法定义
• 接口体内只包含常量定义和抽象方法定义两部分。

接口的实现

• class A implements In1, In2
• 0 or all: 所有方法都要实现
• 接口中声明方法可省略public和abstract，但在实现的时候，要有public修饰

接口作为类型的使用

接口与abstract类的比较

• 接口中只能有常量，只能有abstract方法

5.4 内部类

• 内部类不能声明静态变量和静态方法
• 外部类可以用内部类声明对象
• 声明方法：直接声明、new
• 内部类不能与外部类同名
• 内部类可以作为其他类的成员

5.5 数组

• 数据类型相同
• 数组是引用类型，java中的数组属于对象的成员变量

5.5.1 一维数组

• 声明+初始化

int[] Arr = new int[100] //默认的元素全部为0
int[] Arr = {1,2,3}

5.5.2 二维数组

• 二维数组每一行的长度可以不一样

//从高维向低维依次进行空间分配
int [][] c = new int[3][];
c[0] = new int[4];
c[1] = new int[5];
c[2] = new int[6];

数组的复制

• java.lang.System类提供了静态方法arraycopy()

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

6 异常和断言

6.1 异常概述

• Throwable直接继承自object，所有异常必须是Throwable类的实例或其子类
• Throwable派生Error和Exception类
• Exception派生RuntimeException
• Throwable的常用方法：
  • getMessage()
  • getStackTrace() //返回堆栈跟踪情况
  • printStackTrace() // 打印堆栈的标准错误流
  • fillStackTrace()
  • toString() //返回简单描述
• throw一个异常：生成一个异常对象并把它提交给运行时系统的过程
• catch一个异常：运行时系统从生成异常的方法开始回溯，直到找到包含相应异常处理的方法

6.2 异常的处理

try{
  ...//被监视的代码段
}
catch(异常类型 e){ ... //异常处理语句}
catch(){}
finally{} //最终处理

• 异常总是在方法内产生

抛出异常

• 一个方法可以声明抛出多个异常
• 若一个方法产生了异常，而不处理异常，则可以在方法声明时，用throws抛出异常，传递给其调用者或更高一级的调用者，直到被捕获。

doSomething() throws IOException{...}
method1() throws IOException{...}
method2() throws IOException{...}
public Static main(){
  try{
    method2();
  }catch(IOExcetption e){...}
}

自定义异常

class 自定义异常名 extends Exception{
 ...
}

throw new 异常类名();

程序会在throw语句处立即终止，转向try...catch寻找异常处理方法，不再执行throw之后的语句

finally语句

• finally语句总是在return之前执行

6.3 断言

assert (布尔表达式)
assert (布尔表达式):"表达式"

• 布尔表达式为假则抛出AssertionError，在第二种形式中，表达式会作为参数传进AssertionError的构造方法中以消息字符串

• 断言主要用于程序开发和测试阶段

• 对某个包或类打开断言java -ea:com.mydx.mylib...

• 对某个包或类关闭断言java -da:com.mydx.mylib...

• 系统级打开断言-esa

• 系统级关闭断言-dsa

7 输入输出及文件操作

7.1 流的概念

• java.io和java.lang处理输入输出

标准的I/O流

• 键盘：stdin

• 监视器：stdout

• stdin和stdout均被封装在System类的类变量in和out中

• 每当main方法被执行，就自动生成下述三个类的对象：

  • System.in: extends InputStream
  • System.out: extends PrintStream
  • System.err: extends PrintStream

• java.io包有字节流和字符流

• 字节流extends InputStream或OutputStream

• 字符流extends Reader和Writer

7.2 文件

• File是io包中的非流类
• 目录也作为文件对象处理
• File的构造方法

File(String filename);
File(String directoryPath, String filename);
File(File f, String filename)；

try{f.createNewFile();}
catch(Exception){...}

• 常用方法

* f.delete() //文件删除
* public String getName() //获取文件名
* public long lastModified() //获取文件最后被修改时间
* public boolean canRead()  //判断是否可读
* public boolean canWrite() //判断文件是否可写
* public boolean isDirectory() //判断是否为目录

目录

• 创建目录： public boolean mkdir()

File f = new File("f:\\java");
f.mkdir();

• 列出目录中的文件

public String[] list()
public String[] list(FilenameFilter obj)
public File[] listFile()
public File[] listFile(FilenameFilter obj)

随机文件流

• RandomAccessFile类可同时完成读和写

public class RandomAccessFile extends Object implements DataInput, DataOutput

• DataInput方法：readBoolean()、readInt()、readLine()

• DataOutput方法： writeChar()、writeDouble()、write()

• RandomAccessFile类仅限操作文件，不能访问其他IO设备（网络、内存映像）

• RandomAccessFile类有个文件指针,刚打开文件时，文件指针指向开头，可以移动文件指针到新的位置，以此位置开始读写操作。

• RandomAccessFile常用方法

byte readByte() //读取一个字节
double readDouble()
int readInt()

String readLine()
void write(byte b[])
void writeDouble(double v)
void seek(long pos) // 将指针指向pos指定的位置
void close()
void length()
long getFilePointer()
void setLength(long newLength)

• RandomAccessFile常用方法都会抛出IOException异常，需要放入try...catch结构中

• 创建随机文件流

File f = new File("file.txt")
new RandomAccessFile(f, "rw");
new RandomAccessFile("file.txt", "w");

raf1.write(name.getBytes()); //将String类型的name变为字节数组
raf1.writeInt(age);
raf1.close;

7.3 字节流

• 字节流extends InputStream或OutputStream，两个都是抽象类
• InputStream和OutputStream的所有方法在出错的时候都会抛出IOException异常

InputStream

• 常用方法

read()
skip() //跳过指定数量的字节不读
available() //返回流中可用字节数
mark() // 在流中的当前位置做一个标记
reset() //返回上一个标记位置
markSupport()
close()

• read()的三种用法，若返回值为-1，表明流结束

int read()
int read(byte b[])
int read(byte b[], int off, int len)  //从输入流中读取长度为len的数据，写入数组b中从索引off开始的位置，并返回读取的字节数

OutputStream

• 常用方法

void write(int b)
void write(byte b[])
void write(byte b[], int off, int len)
void flush() // 刷空输出流，并将缓冲区中的数据强制送出
void close()

数据流

• 数据流类可处理字节和字节数组，还可以实现对文件不同数据类型(int、float、Boolean)的读写

• DataInputStream和DataOutputStream分别实现了接口DataInput和DataOutput

• 常用方法：

readInt()
writeInt()
readByte()
writeByte()
readBoolean()
readChar()
readLine()

• 构造方法：

DataInputStream(InputStream in)
DataOutputStream(OutputStream out)

文件流

FileInputStream

• 构造方法：

FileInputStream f0 = new FileInputStream("/a.txt");

File f = new File("/a.txt");
FileInputStream f1 = new FileInputStream(f);

FileOutputStream

FileOutputStream(String filepath, boolean append) //附加还是覆盖

• FileOutputStream类的对象创建不依赖于文件是否存在，没有就创建
• FileNotFoundException异常：无法创建、打开时抛出
• 利用数据流向文件中写数据

int[] myArr = {1,2,3}
DataOutputStream doc = new DataOutputStream(new FileOutputStream("ints.dat"))
for ()
  dos.writeInt(myArray[i]) 

内存的读写

ByteArrayInputStream

• 构造方法

ByteArrayInputStream(byte [] buf)
ByteArrayInputStream(byte b[], int off, int len)

• 自有方法

public byte[] toByteArray()
public int size() //返回缓冲区大小

ByteArrayOutputStream

字符流

FileReader

FileWriter

• FileWriter打开一个只读文件，引发IOException

缓冲流

• BufferedReader和BufferedWriter类

BufferedReader

• 构造方法

BufferedReader(Reader in)

BufferedWriter

• 构造方法

BuffeiwedWriter(Writer out, int bufSize)

Scanner类

• java.lang包的System类有in和out

Scanner reader = new Scanner(System.in)

之后调用reader的各种方法，实现读取用户在命令行输入的各种数据

7.5 对象流

ObjectInputStream和ObjectOutputStream类

• 构造方法

  ObjectInputStream(InputStream in)
  

• 实现了接口ObjectXput，是XputStream的子类
• 通常用FileXputStream对象作为参数创建ObjectXputStream对象，之后用readObject()/writeObject()方法
• readObject()返回类型为Object

可串行化

• java中，只有可串行化的对象才能通过对象流进行传输
• 只有实现了Serializable接口的类才能被串行化
• Serializable接口不包含任何方法

7.6 过滤流

字符过滤流

• 其他过滤流都是FilterReader/FilterWriter的子类
• FilterReader/FilterWriter都被定义为abstract，但它们没有抽象方法。abstract的作用是强制二者不能被实例化，必须被继承，

7.7 管道

• 连接方法：
  • 构造
  • connect

7.8 不同流的速度比较

• 内存映射>缓冲>文件>RandomAccessFile

Java I/O流的其它应用

8 线程

8.1 线程的概念

• 进程是程序的一次动态执行过程
• 标准线程是由指令指针（PC），线程ID，寄存器集合和堆栈组成
• 线程间的数据可以共享

线程模型

• 三个部分组成：虚拟cpu、code、Data
• 虚拟cpu封装在java.lang.Thread类中

8.2 线程的创建

• 以下两种方法都要使用Java.lang中的Thread类及其方法：
  • 由Thread类派生子类
  • 实现Runnable接口
  • 生成一个Thread对象，就产生了一个线程，对该对象进行操作，就操作了该线程
• Thread类本身只是线程的虚拟CPU，线程所执行的代码是通过方法Run()来完成的
• Run()方法称为线程体，当一个线程被建立并初始化以后，Java的运行时系统就会调用run()方法。

通过继承Thread类构造线程

class testThread extends Thread{
  public testThread (){
    super(str); //调用父类的构造方法为线程对象命名
  }
  public void run(){
    for (int i=0; i<3; i++){
      System.out.println( getName()+"在运行");  //将值输出显示在console窗口中
      try {
        sleep(1000);
        System.out.println( getName()+"在休眠");
      } catch(InterruptedException e){}  
    }
    System.out.println( getName()+"已结束")
  }
}
class Thread1{
  public static void main(String args[]){
    testThread t1 = new testThread("Thread1");
    testThread t2 = new testThread("Thread2");
    t1.start();
    t2.start();
  }
}

通过实现Runnable接口构造线程

• 一个类已经扩展了Frame和Applet，由于单继承性，这样的类就不能再继承Thread，可以通过实现Runnable接口构造线程

class class1 implements Runnable
{
  someMethod{
    //以实现了Runnable接口的类创建的对象 为参数 来创建Thread对象
    Thread threadobj = new Thread(new class1())
    threadobj.start()
  }
  public void run(){
    ...
  }
}
public static void main(String args[]){
  Thread threadobj = new Thread( new class1);
  threadobj.start();
}

• run()方法的返回值类型应为void
• Java.util包有一个Date类，实例化Date对象可得到当前事件

8.3 线程的调度与控制

线程的优先级

• Thread类有三个关优先级的静态常量

  • MIN_PRIORITY=1
  • MAX_PRIORITY=10
  • NORM_PRIORITY=5

• 新线程会继承创建它的父类的优先级

• 线程具有普通优先级

• setPriority()修改优先级

线程的基本控制

sleep()

• sleep()会抛出InterruptedException，必须捕获

yield()

• 将执行的权利交给其他优先级相同的线程
• 若队列中没有其他线程，则继续执行

join()

• 使当前的线程等待，直到t结束为止
• 当前线程调用t.join()，则当前线程等待线程t结束后继续执行
• join(long millis)：调用t.join()，当前线程等待线程t结束或最多等待millis毫秒

interrupt()

currentThread()

isAlive()

• 如果线程已被启动且未被终止，那么isAlive()返回true，但无法判断是处于可运行还是等待状态
• 如果返回false，则线程是新创建或已被终止

suspend()和resume()

• 易造成死锁

8.4 线程的同步

2 对象锁及其操作

• 实现对象互斥锁：synchronized：用于方法或代码段
• 一个对象中所有synchronized方法都共享一把锁
• 声明方法：

synchronized returnType methodName([paraList]){}

synchronized (this) {}

• 如果synchronized用在类声明中，则表明该类中的所有方法都是synchronized

3 线程间的交互

• wait()、notify()/notifyAll()都是Object类的final方法，被所有类继承，不可被改写
• 三者只能在被声明为synchronized的方法或代码段中使用

wait()

• 让当前线程释放其所持有的“对象互斥锁”，进入wait队列

notify()

• 唤醒一个或所有正在等待队列中等待的线程，并将他们移入等待同一个“对象互斥锁”队列
• notify后，当前线程不会马上释放锁，要等到当前线程被synchronized修饰的代码执行完，才会释放锁

8.5 线程的状态

• Newborn 之后一定是 Runnable
• Running 之前一定是 Runnable
• Dead之前一定是Running

Newborn

• 创建一个新线程后，该线程为New状态，系统不为它分配资源
• 该状态只能调用start()或stop()，否则抛出IllegalThreadStateException
• 调用start()后，该线程参与运行调度

Runnable

• New -> start() -> 系统分配资源 -> run() -> Runnable
• Running -> yield() -> Runnable
• Running -> sleep()/t.join 结束 -> Runnable
• Running -> 调用wait()，被notify()/Allnotify()唤醒（注意不能是sleep()，且必须被唤醒） -> Runnable
• Blocked -> 输入输出结束 -> Runnable

Running

• Runnable -> 获取CPU -> Running

Blocked

• Running -> Blocked
  • 线程调用sleep()、join()、wait()
  • 线程中使用synchronized来请求对象的锁而未获得
  • 线程进行输入输出

Dead

• Running -> run()正常结束 -> Dead
• stop()

8.6 线程相关的其他类与方法

8.6.1 支持线程的类

• java.lang.Thread
• java.lang.Runnable
• java.lang.Object
• java.lang.ThreadGroup
• java.lang.ThreadDeath

8.6.2 线程组

• 线程组在线程创建时设置，不可改变
• 使一组线程作为一个对象进行统一处理与维护

8.6.3 Thread类的其他方法

public final void setName(String name)
public final String getName()
public static int activeCount()
public final ThreadGroup getThreadGroup() //返回该线程所属的线程组
public final void setDaemon() //设置守护线程
public String toString() //返回该线程的字符串表示形式
public static int enumerate(Thread[] tarry)

9 编写图形用户界面

• AWT：abstract window toolkit 抽象窗口工具包
• AWT可用于Java的Application和Applet
• Swing组件：建立在AWT之上

9.1 用AWT编写GUI

• 创建图形界面的基础包：java.awt

9.1.1 基本的GUI类

Component类

• 基本方法

setName
getName //获取标题
paint
repaint
update
setFont
setForeground
setSize
setLocation
setEnable
isEnable
setVisible

• 常用组件
  • Button
  • CheckBox
  • Choice
  • Label
  • Canvas

Container类

• Container类是Component类的子类

• 用来表示各种GUI组件的容器

• 主要方法

  • 管理组件

add()
remove()

• 布局管理

setLayout()

9.1.2 常用容器

Frame 窗口

• 包含标题、菜单、文本区和按钮的图形窗口
• Frame extends Window
• Window extends Container

Panel

• 透明容器，没有标题和边框
• 不能作为最外层的容器单独存在
• 面板可以享有自己的布局管理器
• 可以使用一个布局管理器组合不同的面板，并放于一个Frame或Applet或其他面板中

9.1.3 布局管理器 LayoutManager

• 在不同的操作系统中，Java构件外观可能不同，JVM获取不同操作系统的标准按钮。布局管理器可以管理版面布局

• 可以使用实现了LayoutManager接口的布局类来设置组件的布局方式。

• 布局管理器都实现了LayoutManager接口

• 使用布局管理器后，无法绕过它设置组件的大小、位置（调用setLocation()、setSize()等）,若要自己设置，则需取消该容器的布局管理器（setLayout(null)）

• 不同的容器有不同的默认布局管理器

• FlowLayout是Pane和Applet的默认布局管理器

• BorderLayout是Window、Dialog和Frame的默认布局管理器

FlowLayout

• 自动调用组件的getPreferedSize()方法
  • 容器改变大小后，各组件大小不变，相对位置变化
• 添加组件：add()
• 若原容器不使用FlowLayout，而要修改为使用FlowLayout：

setLayout(new FlowLayout())

• setLayout是Container的方法

BorderLayout

• 东西南北
• 容器改变大小后，相对位置变化，组件大小改变：南北组件高度不变，东西组件宽度不变
• 添加组件方法

add("West", new Button("West"));
add(new Button("West"), BorderLayout.SOUT);

GridLayout

• 要在网格单元中放多个组件要先在此网格单元中放容器

CardLayout

• 使用CardLayout布局时，调用add(字符串，组件)将组件加入容器
• 显示组件：

show(容器名， 字符串)
first(容器名)
last(容器名)
previous()
next()

容器的嵌套

public class TestPanel extends Frame{
    Panel p1;
    TextArea ta;
    TextField tf;
    Button bt;
    Label lb;
    public TestPanel{
      super("容器嵌套")；
      p1 = new Panel();
      p1.setBackground(Color.gray);
      ta = new TextArea();
      tf = new TextField("textfieldtext");
      bt = new Button("buttonton");
      lb = new Label("labelabel")
      p1.add(bt);
      p1.add(ta);
      p1.add(tf);
      p1.add(bt);
      p1.add(lb);
      add(p1,"East");
      setVisible(true);
      setSize(360,240);
    }
}

## 9.2 AWT事件处理模型
* 三类对象：Event、Event Source、Event Handler
  
* Button类的方法

```java
public void setLabee(String label)
public void addActionListener(ActionListener l)
public void removeActionListener(ActionListener l)

Button Event 处理步骤

• 通知JVM类要监督和处理一个动作事件
• 激活按钮
• 实现一个方法处理事件

ActionListener

• java.awt.event包的一个接口

• 只有一个方法

public interface ActionListener extends EventListener{
public abstract void actionPerformed(ActionEvent e)
}

• 关键步骤：

public class EventFrame extends Frame{
  private Button quit = new Button("Quit")
  public EventFrame(){
    ...
    setLayout(new FlowLayout());
    add(quit);
    //quit是事件源，产生事件而不处理事件，ActionListener处理事件
    ...
    quit.addActionListener(new ButtonHandler());
    //注册按钮给监听者
    }
}
//指定按键之后的行动
class ButtonHandler implements ActionListener{
  public void actionPerformed(ActionEvent e){
    System.exit(0);
  }
}

• 把按钮对象注册给实现了监听器接口的对象

事件类

• 所有事件都放在包java.awt.event中
• java.util.EventObject是所有事件类的父类，有两个主要方法：

getSource() //获取事件源
toString() //返回事件对象名的字符串

• java.awt.event中常见的事件类：
  • 低级事件
    • ComponentEvent
    • FocusEvent
    • KeyEvent
    • MouseEvent
    • WindowEvent
  • 高级事件
    • ActionEvent
    • AdjustmentEvent
    • ItemEvent
    • TextEvent

事件监听器

• 事件监听器在java.awt.event包中，被定义为接口
• 事件监听器与事件要对应起来
• 常见的事件监听器
  • ActionListener
  • AdjustmentListener
  • ComponentListener
  • 鼠标事件的监听器
    • MouseListener
    • MousMotionListener

AWT事件及其相应的监听器接口

ActionEvent事件

• 触发时机
  • 单击按钮
  • 点击菜单项
  • 文本框中按回车
• 事件监听接口：ActionListener
  • 用匿名类创建接口对象：

    ActionListener listener = new ActionListener(){
      public void  actionPerformed(ActionEvent event){
        ...
      }
    }
    

• 接口方法：actionPerformed(ActionEvent e)
• 组件注册该事件的方法：addActionListener()

Window事件

• WindowListener接口方法：
  • windowActivated(WindowEvent e)
  • windowClosed(WindowEvent e)
  • windowDeiconified(WinowEvent e) 从最小化恢复为普通窗口
  • windowIconified(WindowEvent e) 窗口变为最小化图标
• 接口适配器类
  • 当接口方法不止一个时，只实现其中一部分
  • WindowAdapter

ComponentEvent事件

• 触发时机
  • 组件移动

ContainerEvent事件

FocusEvent事件

ItemEvent事件

• 触发时机
  • 改变复选框中选中状态
• 接口方法

TextEvent事件

• 触发时机
  • TextField中按下Return键
• 接口方法：textValueChanged(TextEvent e )

KeyEvent事件

• KeyEvent方法：
  • char getKeyChar()
  • int getKerCode()
• 接口方法：
  • keyPressed(KeyEvent e)
  • keyReleased(KeyEvent e)
  • keyTyped(KeyEvent e)

MouseEvent

MouseListener

MouseMotionListener

• 接口方法：
  • mouseMoved(MouseEvent e)
  • mouseDragged(MouseEvent e)

9.2.4 事件适配器类

适配器类 Adapter

• Adapter可以作为事件监听器的父类

内部类

• 内部类对象可以访问外部类的成员方法和变量，包括私有成员
• 内部类、匿名类编程易于实现事件监听器
• 内部类便于编写事件驱动程序

匿名类

• 用于“次抛”
• 构造方法

someMethod( new ClassType([constructorInputList]){类体} )

• 以接口名作为构造方法名称，创建的就是匿名类

9.3 AWT组件库

常用的基本组件

CheckBox 复选框

复选框组

下拉式菜单（choice）

画布

单行文本输入区（TextField）

文本输入区（TextAera）

列表

Dialog

FileDialog

用户

MenuItem

Menu

• 菜单只能被添加到MenuBar中

MenuBar

• MenuBar只能���添加到Frame中

Color

• Java.awt.Color类提供了颜色的一些方法

Font

• Java.awt.Font类提供了字体

Font myFont = new Font(String name, int style, int size)

9.4 用Swing编写GUI

Swing概述

• javax.swing包中4个重要类：JApplet、JFrame、JDialog和JComponent
• JComponent是绝大部分组件的父类

graph TD A(Container) --> B(JComponent) A --> C(Window) C --> D(Frame) C --> E(Dialog) D --> F(JFrame) E --> G(JDialog)

• JFrame, JApplet, JDialog， JWindow都是重组件，有同位体，可以和操作系统交互信息，称为Swing的顶层容器

• javax.swing.event包中定义了事件和事件监听器类。

• javax.swing.table包中包括了表格组件的支持类。

Swing的特性

• 支持键盘代替鼠标
• 使用图标

9.5 Swing组件和容器

组件的分类

• 顶层容器：JFrame, JApplet, JDialog， JWindow
• 中间容器：JPanel, JScrollPane, JSplitPane, JToolBar
• 特殊容器：JInternalFrame， JLayeredPane, JRootPane
• 基本组件
  • JButton
  • JComboBox
  • JList
  • JMenu
• 不可编辑的信息显示
  • Jlabel
  • JProgressBar
  • JToolTip
• 可编辑的信息显示
  • JFileChooser
  • JTable
  • JTextArea

使用Swing组件的基本规则

• 加组件不能直接添加到顶层容器之中，要加到与顶层容器相关的内容面板（content pane）上

• 避免使用非Swing的重量级组件

• 添加组件的两种方式

 //getContentPane()获取JFrame的内容面板后再添加组件
frame.getContentPane().add(childComponent);
// 建立一个中间容器，把组件添加到容器中，用setContentPane方法把该容器置为JFrame的内容面板
JPanel contentPane = new JPanel();
frame.setContentPane(contentPane);

各种容器面板

根面板

• 由以下3个部分组成
  • GlassPane：玻璃面板，完全透明，默认不可见，用于接收鼠标事件和在组件上绘图
  • ContentPane：
  • JMenuBar：可选择菜单条
• 常用方法：

Container getContentPane();
JMenuBar getMenuBar();
Component getGlassPane();
JLayeredPane getLayeredPane();

分层面板

• Swing提供两种分层面板：JLayeredPane和JDesktopPane，
• JDesktopPane是JLayeredPane的子类，用以容纳内部框架

JPanel

• 是中间容器，是轻量组件
• 默认布局是FlowLayout

JScrollPane

JSplitPane

JTabbedPane

JToolBar

JInternalFrame

• 需添加到一个容器中（通常为JDesktopPane），否则不显示
• 不必调用show()或setVisible()方法，内部框架随所在容器一起显示
• 必须用setSize()或pack()或setBounds方法设置尺寸
• setLocation()或setBounds设置其在容器中的位置
• 像顶层JFrame一样，对内部框架添加组件也要加到它的内容面板上
• 在内部框架中建立对话框，不能使用JDialog作为顶层窗口，要用JOptionPane或JInternalFrame
• JInternalFrame不能监听窗口事件，但可监听JInternalFrameEvent

各种组件

JButton

• 构造方法

JButton(String text, Icon icon)

JCheckBox

JRadioButton

JComboBox

JProgresBar

JTable

JTree

JOptionPane类

• showXXXDialog()方法所用参数：

  • parentComponent:指示对话框的父窗口对象
  • message：
  • title
  • messageType：
    • ERROR_MESSAGE
    • PLAIN_MESSAGE
  • icon
  • optionType
    • DEFAULT_OPTION
    • YES_NO_OPTION
  • initialSelectionValue

  String inputValue = JOptionPane.showInputDialog("Input something")
  

4. 布局管理器

• BoxLayout

事件处理

• 需要用到的两个包：java.awt.event 和 java.swing.event

10 Applet

与Application的关系

• Application使用命令行命令直接运行，从main()方法开始运行

• Applicati的解释器是java.exe，Applet的解释器是兼容java的浏览器

• Applet的主类要定义为Applet类或JApplet类的子类

• Applet可以不包含main()方法

Applet工作原理

• 运行于浏览器环境
  • 首先要创建一个HTML文件，通过编写HTML语言代码告诉浏览器载入何种Applet以及如何运行。
• 每个Applet必须是通过扩展Java的Applet类来实现
• 所有的Applet须继承自Applet类

class AppletName extends Applet

1. 浏览器（向WWW服务器）请求、下载、解释、显示HTML
2. 浏览器遇到HTML中的Applet标记，根据Applet的名字和位置请求、下载Applet字节码文件（.Class）
3. 浏览器用Java解释器执行Applet

• 字节码文件和HTML文件可以放在相同或不同的服务器上

Applet的生命周期

1. 初始化：init()
2. 开始运行:start()
   1. Applet的主体
3. 停止运行:stop()
4. 撤销清理:destroy()
   1. 浏览器关闭时自动调用
   2. 清除Applet所用的所有资源

9.2 Applet的类层次结构

• Java.awt.Panel > Java.applet.Applet > Java.swing.JApplet
• 是一个面板容器

9.3 Applet类API

• 显示方法

  • paint(Graphics g)
  • update(Graphics g)
  • repaint()

• HTML标记方法

  • public URL getDocumentBase()
  • public URL getCodeBase()
  • public String getParameter(String name)

• 多媒体支持方法

  • public image getImage(URL utl, String name)
  • public AudioClip getAudioClip(URL utl, String name)
  • public void play(URL utl, String name)

• Applet信息报告方法

10.2 Applet的编写

• import java.applet.*
• 如果基于Swing的Applet:

import javax.swing.*;
public class AppletName extends JApplet{}

在HTML中applet标记的使用

• 必要：applet, code, width, height

<applet code = "Hello.class" width = 300 height=300>
</applet>

• CODE
• WIDTH
• HEIGHT
• CODEBASE
• ALT
• NAME

使用标记参数向Applet传递信息

• PARAM NAME = appletParameter1 VALUE value
  • Applet 可以用getParameter()获取<PARAM>属性指定的参数
  • getParameterInfo()可得到有关<PARAM>属性的说明信息

获取参数步骤

• 在页面中:

<param name=p1 value="11"> //name后不需加引号

• 在Applet类中

s1=getParameter("p1")

10.3 Applet与GUI

1. Applet中的事件处理

2. 基于AWT组件的Applet用户界面

3. 基于Swing组件的Applet用户界面

• 唯一子类：JRootPane 根面板
• JRootPane中的ContentPane是JApplet除了菜单条以外所有构件的父类
• 默认布局：BoarderLayout
• 绘图方法：paintComponent()

4. JApplet添加构件方法

方法1

• 用getContentPane()方法获得JApplet内容面板，再向内容面板中增加构件：

  Container contentPane = getContentPane();
  contentPane.add(SomeComponent)
  

方法2

• 建立一个JPanel之类的中间容器
• setContentPane()，将中间容器设为JApplet的内容面板

  JPanel contentPane = new JPanel();
  contentPane.add(SomeComponent);
  setContentPane(contentPane);
  

10.4 Applet的多媒体支持

• 显示图像
  • getImage()
• 动画

10.5 Applet与工作环境的通信

11 集合与泛型

11.1 集合的概念

• Collection，即Container

集合类的特点

• 只容纳对象名
• 容纳的元素都是Object类型
  • 把一个对象置入集合类，它的类信息将消失
• 大小可变
  • 解决数组定义数组时就要确认数组大小的问题

集合体系结构

• Java集合结构由两个接口树构成
• Collection
  • 定义了所有集合的基本操作
  • Set
  • List
• Map

集合分类

Set

• 集里的对象不按任何特定的方式排列
• 按索引值操作数据
• 不能有重复的元素

List

• 按索引值操作数据
• 可以有重复的元素

Map

• 映射的每一项为“键——值对”，key不能重复，value可以重复

简单集合类

Vector

• 实现动态数组

ArrayList

• 实现了List接口

以上为两个动态数组

11.2 泛型

泛型类

class 类名 <T> {...}

泛型接口