Java入门基础

ONE

1. JDK
   JDK是Java Development Kit的缩写，也就是Java开发工具包
2. SDK
   SDK是Software Development Kit的缩写，也就是软件开发工具包
3. JRE
   JRE是Java Runtime Environment的缩写，也就是Java运行环境
4. 查看电脑系统环境变量
   cmd中输入set
   查看单个环境变量
   set 要查看的环境变量名
5. 新建环境变量
   set 环境变量名称=值
6. 删除环境变量
   set 环境变量名称=
   注：等号右边不输入任何的值，按回车，就能删掉环境变量
7. 在已经存在的环境变量上增加值
   set 环境变量=原理的值 + ； + 新的值
8. 配置java环境变量
   set path=%path%；C:\jdk位置\bin
9. 配置classpath
   set classpath=.;C\jdk位置\lib\tools.jar

TWO

java语言的基本要素
java语言主要由标识符、保留字（关键字）、分隔符、变量、常量等元素组成。这些元素各自都有各自的语法含义和规定。

1. 标识符（identifier）
   程序中任何一个变量、常量、类和对象都需要一个标志它存在的名字，这个名字就称之为标识符。在java中对标识符做如下规定：
   1）标识符必须由字母、下划线和美元符号（$）开头。后面的字符可以包含字母、数字、下划线和美元符号。
   2）Java严格区分大小写字母。
   3）不能用Java的关键字做标识符，如：main， public。

2. 保留字（关键字）（reserved word）
   具有专门的意义和用途，且不能作为一般标识符使用的一类字符称为保留字（关键字）。java语言的关键字均为小写字母。

3. 数据类型
   基本类型：字节型 byte、布尔型 boolean、字符型 char、短整型 short、整型 int、长整型 long、浮点型 float、双精度型 double

4. 常量和变量
   （1）常量
   Java常用的常量有布尔常量、字符常量、整数常量、浮点常量
   布尔常量 只有两个值：true和false
   字符常量 单个字符通常被表示为字符类型
   整数常量 整数类型是指那些没有小数部分的数字
   浮点常量 浮点类型是指那些含有小数部分的数字
   字符串 字符串代表的是一个字符序列

字符常量使用单引号，字符串使用双引号

5. 变量
   Java是一个严格的“类型化”的语言，每个变量在使用之前都需要声明它的数据类型并初始化该变量。
   格式：数据类型 变量名=初值；

数据类型转换
Java语言不支持变量类型之间的任意转换。数据类型转换分为自动转换和强制转换，自动转换时遵循从低到高的转换规则，即：byte -> short -> char -> int -> long -> float -> double.对于数值类型的数据来说，低位数据可以直接转换为高位数据，而高位数据只能通过强制类型转换才能被转换为低数据，因为这种转换可能会丢失部分数据造成数据失真。
强制类型转换的格式为：（数据类型）数据表达式

运算符和表达式
按照运算符功能，运算符可分为7种：赋值运算符、算术运算符、逻辑运算符、关系运算符、条件运算符、位运算符和其他运算符。
按照操作数多少，可分为：一元运算符、二元运算符、三元运算符。

1. 赋值运算符：=、 +=、 -=、 *=、 /=、 %=
2. 算术运算符：++、 --、 -、 +、 -、 *、 /、 %
3. 逻辑运算符：NOT（非） ！、AND（与） &、OR（或） |、逻辑与（&&）、逻辑或（||）
4. 关系运算符：==、！=、>、>=、<、<=
5. 条件运算符：条件运算是三元运算符，有3个操作符。条件表达式的格式为：条件表达式？结果1：结果2
6. 位运算符和其他运算符：位运算符用于对二进制位进行运算。位运算的操作数和结果都是整数。
   位取反：~ 、 位与：&、 位或：|、 位异或：^（相同为0，否则为1）
   左位移：<<、右位移：>>、 不带符号的位右移：>>>
   各个位运算符的运算顺序（优先级）：~、<<、>>、>>>、&、^、|
   位取反等于原数的反数再减1，如a=23, ~a=(-a - 1)=-24

数组
数组是一组具有相同名字，不同下标的变量集合。Java中数组必须先定义后使用。

1. 一维数组的定义
   数据类型 数组名[]；
   数据类型 []数组名；
   直接赋值使用大括号，int a[] = {1,2,3,4}
   数组名=new 数据类型[数组长度]

二维数组

1. 二维数组的定义
   数据类型 数组名[][]；
   数据类型 [][]数组名；
2. 二维数组的初始化
   静态初始化：在定义数组时给出数组元素的初值
   动态初始化：使用new运算符为数组分配内存空间和初始化
3. 二维数组的引用
   数组名[行下标][列下标]

THREE

1. 条件语句
   分为单一条件（比如：if语句）和多重条件语句（switch语句）

（1）if语句
if、 if … else …

（2）switch语句
switch(表达式) {
case 常量1：语句1；
break;
case 常量2：语句2；
break;
…
default:语句n;
}

使用switch语句时应注意以下几点：

1. case后面的常量必须是整数或字符型，而且不能有相同的值；

2. switch后面的表达式可以是整型表达式或字符表达式。但case后面的数据必须是常量或常量表达式。

3. 通常在每一个case中都应使用break语句提供一个出口，使流程跳出开关语句。否则，在第一个满足条件case后面的所有语句都会被执行。

4. 循环语句
   for、 while、do…while

一个循环一般包括4部分内容：
初始化部分、循环体部分、迭代部分、终止部分

3. 跳转语句
   跳转语句用来实现程序执行过程中流程的转移。
   Java的跳转语句有三个：continue、break、return

continue语句必须用于循环结构中，作用是终止当前这一轮的循环，跳过本轮剩余的语句，直接进入当前循环的下一轮。
continue + 标号名：这个标号名应该定义在程序中外层循环语句的前面，用来标志这个循环结构。
public class test{
public static void main(String args[]) {
System.out.println(“200~300之间所有的素数);
int n = 0;
uper:
for(int i = 201; i < 300; i+=2) {
for(int j = 2; j < i; j++) {
if(i % j == 0) {
continue uper;
System.out.print(” " + i);
n++;
if(n < 6) {
continue;
}
System.out.println();
n = 0;
}
}
}
System.out.println();
}
}

break语句，使程序的流程从一个语句块内部跳转出来，如从switch语句的分支中跳出来，或从循环体内部跳出。

return语句，用于方法的返回上。当方法用void声明时，说明不需要返回值。

FOUR

类和对象

1. 类
   类是java的核心，java程序都是由类组成的，一个程序至少要包含一个类，也可以包含多个类。
   类是一种抽象的数据类型，它是所有具有一定共性的对象的抽象。Java是面向对象的程序设计，它总结对象的特征，设计成类。类就是对象的软件图纸、模板或原型，它定义了同类对象共有的变量和方法。

1）类的创建
[public] [abstract] [final] <类名> [extends父类名] [implements接口名} {
<类体（成员变量和成员方法）>
}
[] 表示为可选项， <> 表示必选项。

class（类名）
class关键字告诉编译器这是一个类，类名随便取，但必须是合法的标识符。class前面的关键字称为类的修饰符。

public（公共的）类
公共类可以被任何包中的类使用，但同一个源程序文件中只能有一个publick类，不能出现两个以上的public类。

abstract（抽象的）类
有时定义的类代表了一个抽象的概念，就不能用它来实例化一个对象，它只能被继承。

final（最终的）类
一个最终类不可能有子类，也就是说它不能被继承。把一个类说明成最终类的好处是可以提高系统的安全性，黑客常用的一个攻击技术是设计一个子类，然后用它替换原来的父类。

abstrack和final不能同时修饰一个类。

extends（继承） + 父类名
extends告诉编译器，创建的类是从父类继承下来的子类。从父类继承，可以提高代码的重用性，不必从头开始编写代码。

implements（实现） + 接口名
接口是消息传递的通道，通过接口，消息才能传递到处理方法中进行处理。一类只能继承一个父类，但可以实现一个或多个接口，如果有多个接口，要用逗号分隔。

2. 对象
   Java是完全面向对象的编程语言。现实世界中，对象（object）是状态（属性）和行为（方法）的结合体。软件开发中，对象定义为相关数据和方法的集合。对象是现实世界对象的抽象模型，从现实世界中抽象出来的对象使用数据和方法描述其在现实世界中的状态和行为特征。一般用变量描述其状态，用方法实现其行为。变量是一种有名称的数据实体，而方法则是和对象相关的函数或过程。

对象的创建
创建对象必须要做的工作：声明对象、实例化和初始化
声明对象： <类名> <对象名>；
实例化和初始化： <对象名> = new <类名> ([参数列表])

对象的使用
对象被实例化后才可以使用，为了让解释器知道代码的内存地址， 使用对象的任何成员时都要加上引用，也就是在变量和方法的前面加上对象名，并用圆点分割。
<对象名> . <变量名>
<对象名> . <方法名>

清除对象
Java虚拟机实际上是利用变量生存期来管理内存的，对象的引用被保存在变量中，当程序跳出变量所在的区域后，它就会被自动清除。
如果要明确地清除一个对象，可以自行清除它，只需要把一个null值赋给这个对象引用。

抽象与封装
抽象和封装是类的两个重要特征。
抽象：类就是抽象数据模型，用它描述对象。
封装：数据封装、继承、覆盖和多态是面向对象程序设计的四大特点。通过类将对象的特性和功能组合成一个整体，称为封装。构造类就是建立封装的实体，将类作为一个整体使用，而将内部构造隐藏起来。

继承（inheritance）与多态（polymorphism）

子类继承了父类的状态和行为，一般来说，层次越高，类就越抽象，反之类就越具体。继承使父类的代码得到重用，在继承父类提供的共同特性基础上添加新的代码。Java不支持多继承，子类只能有一个父类。Java中所有的类都是通过直接或间接地继承 java.lang.Object 得到的。在继承机制中有两个比较特殊的类，即final类和abstract类。把一些不能被继承的类定义为final类，把一些必须被继承的类定义为abstract类，abstract类表示的是抽象的概念，不能被实例化为某一个具体的对象，抽象类必须被某一个类继承，并在子类中得到实现。

多态：通过多态使对象能够根据收到的参数产生相应的操作，即每个对象能够以适合自己的形式完成操作。多态使对象具有应变能力，适应各种需要，提高已有代码的扩充性。

类继承的格式如下：
class 子类 extends 父类

接口（interface）
在java中，接口就是为两个不相关的类提供交流的工具。接口不需要建立继承关系，就可以使两个不相关的类进行交互。接口由类的声明语句中的关键字引入，并在类体中实现接口的方法。Java语言支持抽象类与抽象方法。在抽象类里必须声明一个抽象方法，而其他方法可以拥有属于自己的功能。

成员变量与成员方法

1. 成员变量
   a) 成员变量与封装
   成员变量描述了类和对象的状态，有时也称为属性、数据或域。
   b) 成员变量的声明
   成员变量的声明必须放在类体中，通常是在成员方法之前。在方法中声明的变量不是成员变量，而是方法的局部变量，二者是有区别的。
   c) 成员变量的修饰
   [public] [private] [protected] [package] //访问控制修饰符
   [static] [final] [transient] [volatile] <数据类型> <成员变量名称>

1. public（公共）变量
   可被任何包中的任何类访问，只有在确认任何外部访问都不会带来不良后果的情况下才将成员声明为公共的。
2. private（私有）变量
   只能被声明它的类所使用，拒绝任何外部类的访问，私有变量是不公开的，它们得到了最好的保护，这是对类进行封装时使用的主要方法。
3. protected（受保护）变量
   可被声明它的类和派生子类以及同一个包中的类访问。
4. package（包）变量
   在声明时常常省略package关键字，也就是说没有修饰符的变量被视为包成员。包成员可被声明它的类和同一个包中的其他类（包括派生子类）所访问，在其他包中的子类则不能访问父类的的包成员。
5. static（静态）变量
   static声明的成员变量被视为类的成员变量，而不把它当做实例对象的成员变量。也就是说，静态变量是类固有的，可以直接引用，其他成员变量仅仅被声明，只有等到生成实例对象后才存在，才可以被引用。因此，也把静态变量称为类变量，非静态变量称为实例变量。相应地，静态方法也称为类方法，非静态方法称为实例方法。
6. final（最终）变量
   一旦成员变量被声明为final，在程序运行中将不能被改变。这样，成员变量就变成了一个常量。
7. transient（过渡）变量
   Java语言目前对transient修饰符没有明确说明，它一般用在对象序列化上，说明成员变量不许被序列化。
8. volatile（易失）变量
   用来防止编译器对该成员进行某种优化，一般不常用。

成员方法
对象的行为由类的方法实现，其他对象可以调用一个对象的方法，通过消息的传递实现对该对象行为的控制。
a. 成员方法的设计
类的设计集中体现在成员方法的设计上。成员方法的设计应该从类的整体行为出发，能正确响应外部消息，自然地改变对象的状态，并符合相对独立性、结构清晰、可重用性强等编程要求。

b. 成员方法的声明与修饰
成员方法相当于其他语言的函数或过程，是命令语句的集合。成员方法的声明一般放在成员变量的声明之后。
[public] [private] [protected] [package] //访问控制修饰符
[static] [final] [transient] [volatile] 返回值类型 方法名（参数列表） [throws异常类型]

1. final（最终）方法
   方法被声明为最终方法后，将不能被子类覆盖，也就是说最终方法能被子类继承和使用，但不能在子类中修改或重新定义它。这种修饰可以保护一些重要的方法不被修改，尤其是那些对类的状态和行为有关键性作用的方法被保护后，可以避免未知情况的发生。

2. abstract（抽象）方法
   一个抽象类可以含有抽象方法。所谓抽象方法是指不能实现的方法，因为它没有方法体，所以抽象方法不能出现在非抽象类中。一个抽象类可以定义一个统一的编程接口，使其子类表现出共同的状态和行为，但各自的细节则是不同的。子类共有的行为由抽象类中的抽象方法来约束，而子类行为的具体细节则通过抽象方法的覆盖来实现。

3. native（本地）方法
   用其他语言编写的方法在Java中称为本地方法。如果你有一个用其他语言如C语言写成的函数，希望在Java中能利用这些资源，你可以编写本地方法。JDK提供了Java本地接口JNI（Java Native Interface），使得Java虚拟机能运行嵌入在Java程序中的其他语言的代码。这些语言包括C/C++、FORTRAN、汇编语言等。嵌入外部语言代码基于以下考虑：Java系统包不提供对平台依赖性程序的支持时；想利用现有的其他语言资源时；出于运行速度的要求而使用其他语言开发的运行模块。

4. syschronized（同步）方法
   同步方法用于多线程编程。多线程在运行时，可能会同时存取一个数据。为避免数据的不一致 ，应将方法声明为同步方法，对数据进行加锁，以保证线程的安全。

5. throws（异常）类型
   每一个异常对象都对应着一个异常类，如果暂时不希望方法处理某种异常，可将其抛出，使程序得以继续运行。

6. 返回值类型
   Java要求一个方法必须声明它的返回值类型。如果方法没有返回值就用关键字void作为返回值类型，否则应使用基本数据类型或对象类型说明返回值类型，比如：
   public int getA();
   void setxy(intx, inty);
   public String getN();
   protected Object clone(); //返回值为Object类。

7. 方法名
   方法名可以是任何有效的Java标识符。方法名可以和成员变量同名，也可以和成员方法同名。同一个类中的方法同名现象叫方法重载（overload），重载使一个类的多个方法享有同一个名称，可以减轻程序员的负担。同名方法由参数的个数和类型来区分，同一个类中不能有名称、参数个数和参数类型都相同的方法出现。

8. 参数列表
   方法的调用者正是通过参数列表将外部信息传递给方法的。在参数列表中要声明参数的类型，并用逗号分隔多个参数。

9. 方法体
   方法也是分为方法头和方法体，方法体就是方法中用一对{}括起来的部分。

10. 消息传递
    一个对象和外部交换信息主要靠方法的参数来传递。

构造方法
构造方法（constructor）对于类是十分重要的，new操作符为对象分配内存后将调用类的构造方法确定对象的初始状态，初始化所有变量。也就是说，对象的初始化任务要靠构造方法来完成。定义构造方法时要在构造方法中对类中的成员变量定义赋值的方式，一个类可以包含多个构造方法，不同的构造方法有不同的参数列表，Java虚拟机会自动根据传进来的参数，自动判别程序调用的是哪一个构造方法。

FIVE

super与this关键字
super和this是常用来指代父类对象和子类对象的关键字；

this表示对当前类的引用。当一个类被实例化为一个对象时，this就是对象名的另一种表示。this的使用格式如下：
this.成员变量名
this.方法名（[参数列表]）

super表示对当前类的直接父类对象的引用，super的使用格式如下：
super.成员变量名
super.方法名（[参数列表]）

类的继承
在程序设计中，新类可以在原有类的基础上建立，新类可以保留原有类的成员变量和方法，也可以根据需要加以修改并可添加新的成员变量和方法，这些新功能允许以统一的风格处理不同类型的数据。
类的继承的格式如下：
class 子类 extends 父类

关于类的继承应注意以下几点：

1. 一个类可以有多个子类，也可以没有子类，但必须有一个父类，默认的父类为Object，它在java.lang中定义。
2. 一个类是父类还是子类是相对的。
3. 子类不能继承父类中的private成员，除此之外，其他所有的成员都可以通过继承变成子类的成员。
4. 子类不仅可以继承父类的原有成员，还可以增加新的成员，也可以对父类成员进行修改。
5. Java语言只支持单继承，不支持多继承。

成员方法的继承与覆盖（override）
子类可以继承父类的方法，也可以定义自己的方法。但子类定义的 方法与父类方法同名时，子类就会覆盖父类方法。

成员变量的继承和隐藏
子类可以继承父类的成员变量，也可以定义自己的成员变量。当子类定义的成员变量与父类的成员变量同名时，父类的成员变量会被隐藏掉，也就是说，在默认情况下，子类使用自己的成员变量。这时如果要使用父类的成员变量要使用关键字super在子类中对同名成员变量加以说明。

子类继承了父类，子类的构造方法里调用了super()，用 new 实例化子类，super()则会去执行父类的构造方法。
this()执行当前的构造方法。

多态
所谓多态，就是为类创建多个同名的方法。

1. 成员方法的重载
   指对同名方法的重新定义，即为类定义多个名称相同、但参数不同的方法。
2. 构造方法的重载
   类中包括多个同名但参数不同的构造方法，就称为构造方法重载。

构造方法的继承
子类可以继承父类的构造方法，其规则如下：

1. 如果子类没有定义构造方法，则继承父类无参数的构造方法。如果子类定义了构造方法，无论是无参数的参数的构造方法还是带参数的构造方法，在创建子类对象时，首先执行继承自父类的无参数构造方法，然后再执行自己的构造方法。
2. 如果在子类中需要调用父类的带参数的构造方法，可以通过语句super（[参数列表]）调用所需的父类构造方法，且该语句必须作为子类构造方法的第一条语句。
3. 如果需要在某个构造方法中调用本类中的其他构造方法，可以通过语句this（[参数列表]）调用所需的构造方法，且该语句必须作为构造方法中的第一条语句。

包
包是Java提供的管理类和接口的工具。即包是管理文件的文件夹（目录）。一个包对应一个文件夹，包中还可以有包，称为包等级。包是一种松散的类的集合，通常将需要在一起工作的类和接口放在一个包中。
当源程序中没有声明类所在的包时，Java将类放在默认包中，即运行编译器的当前文件夹中。

Java的系统包
Java提供了大量的类，为便于管理和使用，分为不同的包。这些包又称为类库或API包，API（application program interface）即应用程序接口。
许多Java API包都以“java.”开头，以区别用户创建的包。

1. java.lang包
   java.lang包是语言包，包含基本数据类型、数学函数、字符串类等。这是唯一自动引入每个Java程序的类型，程序中无需用import语句引入java.lang包。
   java.lang中包含有以下主要类：
   a) 数据类型包装类，对应8个基本数据类型，数据类型包装类也有8个：BigDecimal、BigInteger、Byte、Double、Float、Integer、Long、Shoot。
   b) 提供基本数学函数的数学类Math。
   c) 用于字符串处理的String类和StringBuffer类。
   d) 系统类System。
   e) Object类。
   f) 线程类Thread。
   g) 类操作类class。

2. java.util包
   java.util包是实用包，包中包含一些实用工具。主要有日期类Date、堆栈类stack、随机数类Random、向量类Vector等。

3. java.io包
   java.io包是输入输出包，是Java语言的标准输入输出类库，用于进行各种输入输出操作。

4. java.net包
   java.net包是网络包，是实现网络功能的类库。包中含有访问网上资源的URL类，用于通信的Socket类和网络协议子类库等。

5. java.awt包
   java.awt包是组件包，提供了创建图形用户界面（GUI）的全部工具。它包括许多我们熟悉的图形组件类，用于管理组件排列的布局管理类Layout；以及常用的颜色类Color、字体类Font。java.awt.event类库用来处理各种不同类型的事件。

6. java.applet包
   java.applet包是小应用程序包，是为java Applet程序服务的类库。

7. java.security包
   java.security包包括java.security.acl和java.security.interface子类库，利用这些类可对Java程序进行加密，设定相应发安全权限等。

包的创建
创建包的语句需要使用关键字package，而且应该是整个.java文件的第一个语句，表示该文件的全部类都属于这个包。包名一般采用小写，以便与类名有区别。创建包的语句如下：
package 包名；
在使用package语句时应注意：

1. 每个java程序文件中只能有一条package语句，并且必须是第一个语句，而且前面不能注释和空格。
2. 要在当前文件夹下创建多级文件夹，在包名中用分隔符“.”指明各个文件夹的层次。
   即：package 包名1.包名2.包名3
   如： java.awt.image就是一个等级包
3. 执行package语句时，先检查语句中指定的包（文件夹）是否存在，若存在，则直接使用原有文件夹；否则，建立文件夹。

包的引用
在编写源程序时，如果要使用某个包中的类，要在Java程序的开头添加import语句，指明源程序要使用含有该类的包，如下面的语句：
import java.awt.Graphics; 表示程序要使用Java的awt系统包中的Graphics类。
import java.applet.*; 表示程序中需要引入applet包中的全部类。
要引入Java包，仅在程序汇总添加import语句还不够，还要告诉系统，程序运行时到哪里去找Java包。由于Java使用文件系统来存储包和类，类名就是文件名，包名就是文件夹名，所以进行环境变量的设置就是找到存放包的路径，如：“E:\Java程序设计基础\lesson5;”。

接口（interface）
接口就是方法定义和常量值的集合。
接口的优点就是一个接口类可以被任意多的类实现，每个类可以共享程序接口而不必关心其他类是如何实现的。

1. 创建接口
   接口中只包括常量数据成员和抽象方法。
   创建接口要使用声明接口语句，格式如下：
   [public] interface 接口名 [extends 父接口名1，父接口名2，…，父接口名n] {
   [public static final] 数据类型 常量数据成员名1 = 常量值；
   …
   [public static final] 数据类型 常量数据成员名n = 常量值；
   [public ] [abstract] [native] 返回值 数据类型方法名1（参数列表） [throw 异常列表];
   …
   }

声明接口的几点说明：
a) interface是接口声明的关键字，引导所定义的接口的名字。接口的访问修饰符只有public一个。用public修饰的接口是公共接口，可以被所有的类和接口使用，而没有public修饰符的接口则只能被同一个包中的其他类和接口使用。
b) 声明的接口名首字母一般要大写。
c) 定义一个接口时可以通过extends关键字声明该新接口是某个已经存在的父接口的派生接口，它继承父接口的所有属性和方法。与类的继承不同的是一个接口可以有一个以上的父接口。
d) 接口体的声明是定义接口的重要部分。它由两部分组成：一部分是对接口中属性的声明，另一部分是对接口中方法的声明。接口中的所有属性都必须是public static final，接口中的所有方法都必须是默认的public abstract，可以省略不写。
e) 接口中方法体可以用java语言书写，也可以用其他语言书写。如果用其他语言书写时，接口方法需使用native修饰符。

实现接口
接口的声明仅给出了抽象方法，只有方法头，没有方法体，相当于程序开发早期的一种协议，接口中的方法不能直接使用，需要通过某个类为接口的抽象方法书写语句并定义实在的方法体，称为实现这个接口。

一个类要实现接口时，要注意下列问题：
a) 因为一个类可以实现多个接口，所以用implements关键字声明该类将要实现哪些接口。
b) 一个类在实现某接口的抽象方法时，必须使用完全相同的方法头。如果所实现的方法与抽象方法有相同的方法名和不同的参数列表，则只是在重载一个新的方法，而不是实现已有的抽象方法。
c) 如果实现某接口不是abstract类型且包括多个抽象方法，那么类要实现该接口的所有抽象方法。
d) 如果某接口是abstract类型，那么类可以不实现接口的所有方法。

接口的继承关系
在Java中，和类一样，接口也可以实现继承，一个接口可以继承父接口的所有成员。

1. 接口的单继承
2. 接口的多重继承
   在Java语言中，不支持类的多重继承，但是支持接口的多重继承，其语法格式如下：
   interface 接口名 extends 接口名1， 接口名2， …

异常处理

1. 异常（Exception）
   当Java程序违反了java语言的语义限制时，java虚拟机就会发出出错信号，这就是java异常，异常又称为例外。
   一般异常发生的原因有以下3种：
   a) java虚拟机检测到了非正常的执行状态。
   b) hava程序代码中的throw语句被执行。
   c) 异步异常发生
   在java中的异常对象是以类的层次结构进行组织的。它的最顶层是Throwable类（父类），它派生了两个子类：Exception和Error。Error类由系统保留，Exception类供应用程序使用。

2. 异常的处理机制

1. 抛出异常
   在java中当语义限制被违反时，将会抛出异常，也就是产生一个异常事件，生成一个异常对象，并把它提交给运行系统，在由运行系统寻找相应的代码来处理异常。

2. 捕获异常
   异常抛出后，运行时系统从生成异常对象的代码开始，沿着方法的调用栈进行查找，直到找到包含相应处理的方法代码，并把异常对象交给该方法为止，此过程称为捕获异常。

3. try-catch-finally语句
   异常处理语句格式如下：
   tr y{…}
   catch(异常类型e) {…}
   catch(异常类型e) {…}
   …
   finally {…}

4. throw语句
   使用throw语句就可以声明抛出一个或多个异常。throw后面要跟一个异常类对象，用于指出异常的名称和类型。
   throw语句的格式如下：
   <异常对象>;

SIX

语言基础类库

1. Object类
   Object类是Java程序中所有类的直接或间接父类，所有其他类都是从Object类派生出来的，Object类包含了所有Java类的公共属性，Object类中的一些主要方法：
   a) protected Object clone() 生成当前对象的一个拷贝，并且返回这个复制对象
   b) public boolean equals(Object obj) 比较两个对象是否相同，返回true或false
   c) public final Class getClass() 获取当前对象类的信息
   d) protected void finalize() 定义回收当前对象时需要清理的工作
   e) public String toString() 返回当前对象本身的有关信息，按字符串返回

2. 数据类型类

1. 数字类Number
   数字类Number是一个抽象类，是Integer，Long，Short，Float，Double的父类。在Number类中定义了数据类型转换的方法，通过在子类中重写这些方法，实现特定数据类型的转换。
   public int intValue()
   public long longValue()
   public short shortValue()
   public byte byteValue()
   public double doubleValue()

2. 整数类Short，Integer和Long
   常量
   Short，Integer和Long中分别定义了MIN-VALUE和MAX-VALUE两个常量
   public final static X MIN_VALUE 表示X类型数据的最小值
   public final static X MAX_VALUE 表示X类型数据的最大值
   其中X为：Short，Integer和Long

常用方法
Short，Integer和Long各类都提供了将字符串变成相应数据类型的方法。
public static int parseInt(String str)
public static long parseLong(String str)
public static short parseShort(String str)

3. Math类
   数学类Math类头格式如下：
   public final class Math extends Object

数学类提供的数学常量
public final static double E
public final static double PI

数学类提供的常用函数
a) 最大、最小值函数
public static int max(int x, int y)
public static long max(long x, long y)
public static float max(float x, float y)
public static double max(double x, double y)
public static int min(int x, int y)
public static long min(long x, long y)
public static float min(float x, float y)
public static double min(double x, double y)

b) 绝对值函数
public static int abs(int x)
public static long abs(long. x)
public static float abs(float. x)
public static double abs(double. x)

c) 平方根函数
public static double sqrt(double x)

d) 幂函数
public static double pow(double x, double y)

e) 指数函数
public static double exp(double x)

f) 对数函数
public static double log(double x)

g) 三角函数
public static double sin(double x)
public static double cos(double x)
public static double tan(double x)
public static double sin(double x)
public static double acos(double x)
public static double atan(double x)
以上x的单位必须是弧度

4. System类
   System类是属于java.lang包的一个终止类，用于访问系统资源（如标准输入输出、系统属性等）。它是一个功能强大、非常有用的特殊的类，它提供了标准输入/输出、运行时的系统信息等重要工具。它所有的属性和方法都是static的。这个类不能实例化，即不能创建System类的对象，引用时以System为前缀即可。

用System类获取标准输入/输出
public static PrintStream err;
public static InputStream in;
public static PrintStream out;

用System类的方法获取系统信息，完成系统操作。
System类提供了一些用来与运行Java的系统进行交互操作的方法，利用它们可以获取Java解释器或硬件平台的系统参量信息和系统属性，也可以直接向运行系统发出指令来完成操作系统级的系统操作。通过方法getProperty()和getProperties()获取系统属性，通过方法setProperties()设置系统属性。
public static void exit(int status) 强制java虚拟机退出运行状态
例如System.exit(0)
public static String getProperty(String str)
public static Properties getProperties()
public static void setProperties(Properties p)

5. String类
   a) 构造方法与创建String类的对象String类提供了以下四种形式的构造方法：
   public String()
   public String(String value)
   public String(StringBuffer value)
   public String(char value[])

b) String类的常用方法
求字符串长度
public int length()

从字符串中查找单个字符所在位置
public int indexOf(int ch)
public int indexOf(int ch, int fromindex)

从字符串中查找子串
public int indexOf(String str)
public int indexOf(String str, int fromIndex)
public int lastindexOf(String str)
public int lastindexOf(String str, int fromIndex)

查找指定位置对应的字符
public int charAt(int index)

字符串的截取
public String subString(int beginindex, [int endindex])

字符串的大小写转换
public String toLowerCase()
public String toUperCase()

字符替换
public String replace(char oldc, char newc)

6. Date日期类
   比较两个日期的方法
   public calendar after(Date value)
   public calendar before(Date value)

查询日期数据的方法
public int getYear()
public int getMonths()
public int getData()
public long getTime()
public int getHour()
public int getMinutes()
public int getSeconds()

修改日期数据的方法
public void setYear(int year)
public void setMonths(int month)
public void setHour(int hour)
public void setMinutes(int minute)
public void setSeconds(int second)
public void setTime(longtime)

Random随机数类

1. 构造方法
   public Random()
   public Random(long seed)

2. 随机数中的方法
   public void setSeed(long seed)

3. 产生随机数的方法
   public int nextInt()
   public long nextLong()
   public float nextFloat()
   public float nextDouble()

Applet类与Applet程序

Applet类主要包括以下五个方法：
init()、start()、stop()、paint()、destroy()
分别对应Applet程序生命周期的四个阶段：初始化、启动、暂停和消亡

当发生如下三种事件时，浏览器自动调用paint()方法。

1. 调用start()方法启动Applet后，自动调用paint()方法重新在屏幕上显示信息。
2. 当改变Applet所在的浏览器窗口时，如窗口放大、缩小、移动或被其他部分遮挡，图形被覆盖后又重新显示在屏幕的最前方，遇到这些情况都要调用paint()方法，以便恢复屏幕原来显示的内容。
3. 调用Applet的其他相关方法时，系统也会相应地调用paint()方法。例如，当调用repaint()方法时，系统首先调用update()方法，以便清空Applet实例占用的屏幕空间，然后调用paint()方法重新在屏幕上显示信息。

HTML与Applet的参数传递

SEVEN

组件
组件（component）是构成GUI的基本元素，通过对不同事件的响应来完成和用户的交互或组件之间的交互。

标签（Label）
Label组件的继承关系：Java.lang.Object -> Java.awt.Component -> Java.awt.Label

1. 创建标签
   Label lbl = new Label();

2. 标签的构造方法
   a. Label()
   b. Label(String label)
   c. Label(String label, int alignment)
   Label的对齐方式有3种，分别用Label类的3个常量LEFT、CENTER和RIGHT来表示左对齐、居中对齐和右对齐。

3. 标签的常用方法
   a. public int getAlignment()
   b. public String getText()
   c. public void setText(String value)
   d. public void setAlignment(int alignment)

按钮
继承关系：Java.lang.Object -> Java.awt.Component -> Java.awt.Button

1. 创建按钮
   Button btn = new Button();
2. 按钮的构造方法
   public Button()
   public Button(String text)
3. 按钮的常用方法
   public String getLabel()
   public void setLabel(String label)

下拉式列表框
继承关系：Java.lang.Object -> Java.awt.Component -> Java.awt.Choise

1. 创建下拉式列表框
   Choice chc = new Choice();
2. 下拉式列表的常用方法
   public void addItem(String item)
   public int countItem()
   public String getItem(int index)
   public int getselectIndex()
   public String getselectItem()
   public void select(int pos)
   public void select(String str)

复选框和选项按钮

1. 创建复选框
   Checkbox c[] = new Checkbox[3];
2. 复选框和选项按钮的构造方法
   checkbox()
   checkbox(“科目名”)
   checkboxGroup()
3. 复选框和选项按钮的常用方法
   public checkboxGroup getcheckboxGroup()
   public String get Label()
   public Boolean getState()
   public void setCheckboxGroup(CheckboxGroup g)
   public void setLabel(String label)
   public void setState(Boolean state)

列表框：list
List list = new List(项数， 是否多选);
List list = new List(7, true);

文本框
继承关系：Java.lang.Object -> Java.awt.Component -> Java.awt.TextComponent -> Java.awt.TextField

1. 创建文本框
   TextField txt = new TextField();
2. 文本框的构造方法
   TextField()
   TextField(int columns) 文本可以显示的长度
   TextField(String text)
   TextField(String text, int columns)
3. 文本框的常用方法
   public void setEchoChar(char c) 设置文本显示为星号
   public void setText(String t)

文本区
文本框组件的继承关系：Java.lang.Object -> Java.awt.Component -> Java.awt.TextComponent -> Java.awt.TextArea

1. 创建文本区
   TextArea textArea = new TextArea();
2. 文本区的构造方法
   TextArea()
   TextArea(int rows, int columns)
   TextArea(String text)
   TextArea(String text, int rows, int columns)
   TextArea(String text, int rows, int columns, int scrollbars)
3. 文本区的常用方法
   public void append(String str)
   public void insert(String str, int pos)
   public void setText(String t)
   public int getRows()
   public void setRows(int rows)
   public int getColumns()
   public void setColumns(int columns)
   public void setEditable(boolean b)

菜单
Menu类的继承关系：java.lang.Object -> java.awt.MenuComponent -> java.awt.MenuItem -> java.awt.Menu

1. 菜单条式菜单
   MenuBar bar = new MenuBar();
2. 弹出式菜单
   PopupMenu pm = new PopupMenu();

布局管理（LayoutManager）

1. 顺序布局
   顺序布局（FlowLayout）是最基本的一种布局，是面板（Panel）及其子类Applet的默认布局方式。
2. 边界布局
   边界布局（BouderLayout）将容器分为5个区：东、南、西、北和中。
3. 卡片布局
   卡片布局（CardLayout）可以将容纳多个，并将各个组件像卡片一样重叠起来，每次只显示放在最上面的一个组件。
4. 网格布局
   网格布局（GridLayout）把容器空间分成若干个网格，每个网格可以放置一个组件，网格布局方式适合组件较多的情况。
5. 面板
   面板（Panel）属于无边框的容器，无边框的容器包括Panel和Applet，其中Panel是Container的子类，Applet是Panel的子类。

事件处理方法

1. 事件与事件处理方法
2. Java的事件处理
   Java.awt.event包定义了许多事件监听器接口，用于发现和处理事件。事件监听器接口名称由事件类型名和Listener组成。如：动作事件监听器接口ActionListener，选择ItemListener，文本TextListener。

通过事件监听器接口处理事件要有三个步骤：

1. 定义类实现事件监听器接口
   要建立处理事件的类需说明类实现事件监听器接口，说明格式为：
   public class 类名 implements 监听器接口列表
2. 将产生的组件注册为事件监听器
   注册语句为：组件名.addXXListener(new 类名)
3. 实现监听器接口的抽象方法
   在实现监听器接口的类中为抽象方法编代码。

Java事件类、对应接口及接口中的方法

1. ActionEvent动作事件类， ActionListener单击事件接口
   actionPerformed(ActionEvent e)单击按钮、文本行中单击鼠标、双击列表框选项
2. ComponentEvent组件事件类，ComponentListener接口
   ComponentMoved(ComponentEvent e)移动组件
   ComponentHidden(ComponentEvent e)隐藏组件
   ComponentResized(ComponentEvent e)改变组件大小
   ComponentShown(ComponentEvent e)显示组件
3. ContainerEvent容器事件类，ContainerListener接口
   componentAdded(ContainerEvent e)添加组件
   componentRemoved(ContainerEvent e)删除组件
4. FocusEvent焦点事件类，FocusListener接口
   focusGained(FocusEvent e)获得焦点
   focusLost(FocusEvent e)失去焦点
5. ItemEvent选择事件类，ItemListener接口
   itemStateChanged(ItemEvent e)选择复选框、选取项框、单击列表框、选中带复选框的菜单项
6. KeyEvent键盘击键事件类，KeyListener接口
   KeyPressed(KeyEvent e)按下键盘时
   KeyReleased(KeyEvent e)释放键盘时
   KeyTyped(KeyEvent e)
7. MouseEvent鼠标事件类，MouseListener鼠标按钮事件接口
   mouseClicked(MouseEvent e)单击鼠标时
   mouseEntered(MouseEvent e)鼠标进入
   mouseExited(MouseEvent e)鼠标离开
   mousePressed(MouseEvent e)按下鼠标
   mouseReleased(MouseEvent e)放开鼠标
   mouseDragged(MouseEvent e)拖拽鼠标时
   mouseMoved(MouseEvent e)鼠标移动时
8. TextEvent文本事件类，TextListener接口
   textValueChanged(TextEvent e)文本行、文本区中修改内容时
9. WindowEvent窗口事件类，WindowListener接口
   WindowOpened(WindowEvent e)打开窗口
   WindowClosed(WindowEvent e)关闭窗口
   WindowClosing(WindowEvent e)关闭窗口
   WindowActivated(WindowEvent e)激活窗口
   WindowDeactivated(WindowEvent e)窗口失去焦点

EIGHT

基本概念

1. 程序、进程与线程
2. 线程的生命周期与状态

1. 新建状态
   Thread SrThread = new Thread();
2. 就绪状态
   SrThread.start();
3. 运行状态
   进入运行状态的线程要执行run()方法。
4. 阻塞状态
   以下操作都会使线程进入阻塞状态。
   a) 调用sleep()方法使线程进入睡眠状态。
   b) 调用suspend()方法使线程进入挂起状态。
   c) 为等待一个条件变量，调用wait()方法。
   d) 执行费时的输入或输出操作。
5. 消亡状态
   线程消亡的原因有两个：
   一是线程完成全部工作，正常结束运行，即执行完run()方法中的每条语句后退出；
   二是线程被提前强制终止，如执行stop()方法或destory()方法终止线程。

实现多线程
用Java程序实现多线程有两种途径：一种是创建线程类Thread的子类，另一种是定义类实现Runnable接口。在线程的run()方法中编写实现线程具体操作的语句。

Thread类

1. Thread类的构造方法
   public Thread()
   public Thread(String threadName)
   public Thread(Runnable target)
   public Thread(Runnable target, String threadName)
2. 与线程运行和线程状态有关的方法
   public void start()
   public void run()
   public void sleep(long millisencond)
3. 与线程优先级有关的常量和方法
   Thread.MAX_PRIORITY
   Thread.MIN_PRIORITY
   Thread.NORM_PRIORITY
   public void setPriority(int priority)
   public int getPriority()

通过Thread类的子类实现多线程
通过Thread类的子类实现多线程主要涉及以下工作：

1. 定义一个Thread类的子类，用该子类表示用户线程类。
2. 在用户线程类中重写run()方法，使run()方法包含用户线程的操作。
3. 建立用户线程类对象。
4. 调用start()方法启动线程，以便执行run()方法。

通过Runnable接口实现多线程
主要涉及以下几项工作：

1. 定义类实现Runnable接口，用该类表示用户线程类。
2. 在用户线程类中重写run()方法。
3. 建立用户线程类对象。
4. 调用start()方法启动线程。

线程组

1. ThreadGroup类的构造方法
   public ThreadGroup(String groupName)
   public ThreadGroup(ThreadGroup obj, String groupName)
2. ThreadGroup类的其他方法
   ThreadGroup类提供了用于统一管理线程的方法interrupt()。interrupt()用于中断线程组中的所有线程。