Corejava上机实验

第一章：开始
一）基础实验：
1.在Linux下安装JDK，配置环境变量
安装JDK：
sudo chmod 777 /opt
cp /opt
cd /opt
chmod a+x
./
配置环境变量：
cp ~/.bahsrc ~/.
vi ~/.bashrc
G==>到文件结尾
o==>下一行输入
JAVA_HOME=/opt/ JAVA_HOME PATH CLASSPATH
:wq
. ~/.bashrc
javac
echo $JAVA_HOME
2.编辑、编译、运行一个带有包名的，输出Hello World！
vi （example/chap01/src/）
javac –d bin src/
3.java –cp bin 编辑、编译、运行一个带有包名的，完成整数的加减运算
vi （example/chap01/src/）
javac –d bin src/
java –cp bin MymathTest
二）扩展实验：
1.JVM组成
类装载器：将java字节码加载到内存
运行时数据区：
方式区：类型信息
堆区：对象
栈区：保留方式挪用状态，如局部变量、参数、返回值
PC寄放器：指向下一条将要执行的指令
本地址法栈：保留本地址法挪用状态
执行引擎：运行类方式中的指令
三）作业：
1.什么是JDK，其包括哪些内容
Java Development Kit(Java开发工具包)，JDK要紧包括内容：
a. Java虚拟机：负责解析和执行Java程序，Java虚拟机可运行在各类平台上；
b. JDK类库：提供最基础的Java类及各类有效类，、、,、、等包中的类都位
于JDK类库中。

c. 开发工具：这些开发工具都是可执行程序，要紧包括：
javac编译工具；
java运行工具；
javadoc生成JavaDoc文档的工具
jar打包工具
2.和java相关的环境变量有那几个，它们有什么作用
JAVA_HOME：简化其它变量设置进程中的内容输入。

可先行将JDK的安装途径概念为一变量，以后凡利用到JDK安装途径的地址均利用该变量进行替换。

PATH：指定执行外部命令时找寻对应可执行文件的途径范围。

CLASSPATH：代表Java类的根途径，java命令会从CLASSPATH中寻觅所需的Java类；Java编译器编译Java类时，也会从CLASSPATH中寻觅所需的Java 类；classpath的默许值为当前途径。

3.java的优秀特性
跨平台：字节码跨平台，在任何平台上字节码都一样，但不同平台有不同平台的JVM
易编程：没有指针（垃圾回收器）、面向对象（符合人类试探方式）
代码平安：有字节码校验器，适合在网络传输
4.字节码校验器验证哪些内容
代码和jvm标准一致
代码不能破坏系统的完整性
没有堆栈的上溢和下溢
参数类型是正确的
类型转换是正确的
5.java程序编辑、编译、运行进程
vi javac java xxx
6.java中包的作用
将有关联关系的类组织在一路，便于治理；解决命名冲突问题
7.什么是API，如何查看API
Application Programming Interface
先查看package class/interface field/constructor/method
8.修正、、、四个java源文件中的错误，使其能够编译和运行（exercise/chap01）
第二章：标识符、关键字、类型
1）基础实验：
1.单行、多行注释例子
example/chap02/src/
2.写一java程序添加文档注释，通过javadoc产生API文档（包括作者、版本
等信息）
example/chap02/src/
javadoc -d ./doc -author -version src/
3.数据类型测试例子
example/chap02/src/
4.类、对象测试例子
example/chap02/src/
example/chap02/src/
二）扩展实验：
1.找零问题：有2元，买东西花了元，问找零多少?
注意：在需要精准答案的地址，要幸免利用float或double；
关于货币计算，要利用int、long或BigDecima(用于浮点数计算)属于math
Import .*;
.
.
.
BigDecima a=new
2.长整除问题：
l ong micros_per_day = 24 * 60 * 60 * 1000 * 1000;
long millis_per_day = 24 * 60 * 60 * 1000;
/ millis_per_day);
输出结果。

注意：当你操作专门大的数字时，必然要提防溢出；较大整数运算可利用BigInteger
3.低级问题
+ 5432l)输出结果。

注意：做题要细心；在long类型字面常量中，必然要用大写的L
三）作业：
1.java中注释的分类
java中注释分三类
运算符，就能够访问引用变量所引用的实例的方式.
2) 大体类型Java虚拟机遇为其分派数据类型实际占用的内存空间；
引用类型仅是一个指向堆区中某个实例的指针。

例：public class Counter {
int count = 13;
}
Counter counter = new Counter();
counter引用变量-------------> Counter实例
count变量(占4个字节,值为13)
counter引用变量的取值为Counter实例的内存地址。

counter引用变量本身也占必然的内存空间，到底占用多少内存空间取决于Java虚拟机的实现，这对Java程序是透明的。

注：counter引用变量到底位于Java虚拟机的运行时数据区的哪个区？
取决于counter变量的作用域，若是是局部变量，那么位于Java栈区；静态成员变量，那么位于方式区；实例成员变量，那么位于堆区；
2.编程（exercise/chap02/exercise1）
1）仿照Teacher类创建Student类
要求：Student类要描述姓名、性别、年龄
2）仿照TeacherTest类创建StudentTest类
要求：
a) 在StudentTest类中创建Student的对象
b) 为该对象的属性（姓名、性别、年龄）赋值
c) 将该对象的属性（姓名、性别、年龄）输出
3.编程（exercise/chap02/exercise2）
1）为Teacher类添加一个方式，用于在教师原有薪水的基础上增加5000
2）修改TeacherTest类，增加对教师增加薪水方式的挪用，并将增加后的薪水值输出
4.编程（exercise/chap02/exercise3）
已知类MyPoint表示一个二维的点，其概念如下：
public class MyPoint {
public int x;
public int y;
public String toString() {
return ("[" + x + "," + y + "]");
}
}
利用上面已提供的MyPoint类，成立一个TestMyPoint程序，该程序执行以下操作：
1）概念两个类型为MyPoint的变量，变量名为：start 和 end。

每一个变量赋值一个新的MyPoint的对象。

2）将start 的 x 和 y 值设置为10，end的 x值设置为20，y值为30。

3）打印输出这两点变量，利用类似于如下的代码：point is ”+start);
4）编译运行TestMyPoint。

5）声明一个类型为MyPoint的新变量，名为stray 将现有变量end 的引用值赋值给stray。

6）打印输出stray 和 end 。

7）将新值赋值给stray 变量的 x 和 y成员。

打印输出stray end start。

8）编译运行TestMyPoint。

end报告的值反映了stray中的转变，说明这两个变量引用的似同一个MyPoint对象。

可是，start并无改变，说明start与另两个变量无关。

输出结果应与下面类似：
Start point is 【10，10】
End point is 【20，30】
Stray point is 【20，30】
End point is 【20，30】
Stray point is 【47，50】
End point is 【47，50】
Start point is 【10，10】
第三章：表达式和流程操纵
一）基础实验：
1.局部变量和实例变量测试例子
2.操作符测试例子
example/chap03/src/
example/chap03/src/位运算
3.if语句测试例子
example/chap03/src/
example/chap03/src/判定闰年
4.switch语句测试例子
example/chap03/src/
example/chap03/src/某一年月有多少天
5.for、while、do while循环语句测试例子
example/chap03/src/三种循环实训1累加到100
example/chap03/src/产生10个[200,500]间的随机数
example/chap03/src/求两个数的最大公约数和最小公倍数
6.break、continue关键字测试例子
example/chap03/src/
2）扩展实验：
1.复合赋值
short x = 0;
int i = 123456;
x += i;类型转换时，若是最初的数值类型是有符号的，那么就执行符号扩展；
若是它是char，那么不管将要被转换成什么类型，都执行零扩展
三）作业：
1.编程
exercise/chap03
第四章：数组
一）基础实验：
1.数组基础（声明、创建、初始化、赋值）测试例子
example/chap04/src/
2.求一组数的平均值
example/chap04/src/
3.求一组数的最大值
example/chap04/src/
4.冒泡排序
example/chap04/src/
5.java辅助类辅助类的sort(int[] n)和binarySearch(int[] n,int key)
example/chap04/src/
6.随机抽取中奖电话号码
example/chap04/src/
7.产生4位验证码
example/chap04/src/
8.多维数组测试例子
example/chap04/src/
9.填充二维方阵
example/chap04/src/
10.数组拷贝
example/chap04/src/
二）扩展实验：
1.产生100个[1,6]的整数，并统计每一个整数显现的频率
example/chap04/src/
三）作业：
1.编程
exercise/chap04
第五章：面向对象编程
1）基础实验：
1）java的三大特性是哪些?每一个特性的具体含义是什么?
2）范围修饰符有几种?别离代表什么范围?
3）什么是构造器?
a)构造器确实是和类名相同但无返回类型的方式
4）重写和重载的区别?
a)重写是子类的方式覆盖父类的方式，要求方式名和参数都相同
b)重载是在同一个类中的两个或两个以上的方式，拥有相同的方式
名，可是参数却不相同，方式体也不相同，最多见的重载的例子
确实是类的构造函数
5）类的创建和初始化
chap05/ chap05/
6）参数传递
i.example/ch05/
ii.example/chap05/
7）this关键字的利用
a)example/ch05/
b)example/ch05/
8）类的创建顺序
a)example/ch05/
9）重载的构建
a)example/ch05/
10）继承的利用
a)example/ch05/
b)example/ch05/
c)example/ch05/
11）说明super关键字的利用情形
a)能够挪用父类的属性和方式
b)能够区分子类和父类的属性和方式
c)挪用父类构造器
12）多态的练习
a)example/ch05/
b)example/ch05/
2）扩展实验：
a)参考值传递和引用传递的不同方式来分析书上程序
i.前两个输出i值都为2 大体类型参数值传递的进程是参数拷贝进
程
ii.第三个输出是”zhao”,”male”,20,第四个输出是”larry”,”male”,20
引用类型参数值传递的进程是堆区地址传递的进程
iii. 最后两个输出都是”zhao”,”male”,20.最后一个的参数又从头开辟的一段内存,与原来的不是同一个地址,所以互不影响.
b)通过实例说明一下重载的二义性，提出解决方法
i.处置结果存在不确信性
eg:add(int a,float b)
add(float a,int b)
add(10,10)
ii.强制类型转换或精准对应参数
c)何时利用instanceof关键字
i.当一个变量没方法说明在哪个类域时,通过利用instanceof关键字
能够进行判定
ii.if(kevin instanceof Manager) {
Manager manager = (Manager)kevin;
}.
三）作业：
exercise/chap05
第六章：高级语言特性
1）基础实验：
1).static变量和实例变量的区别?
a) static变量关于每一个类而言在内存中只有一个，能被类的所
有实例所共享；实例变量关于每一个类的每一个实例都有一份，
它们之间互不阻碍；
b) Java虚拟机在加载类的进程中为static变量分派内存，实例变
量在加载完类后创建对象时分派内存；
c) static变量存在方式区，实例变量存在堆区；
d) static变量能够直接通过类名访问，实例变量通过引用类型变
量访问；
2）分析代码，说明里面所对应的值.
a)第一次count值为1 serialName值为1
b)第二次count值为2，serialName值为2
3）Static的利用
a)example/ch06/
4) 利用static实现单例模式
example/ch06/
4）Final修饰符的作用?
a)Final修饰的变量是不能被更改
b)Final修饰的class不能被继承
c)Final修饰的方式不能被重写
5）Final的利用
a)examle/ch06/
6）abstract修饰符的作用?
a)可用来修饰类和成员方式。

i.用abstract修饰的类表示抽象类，抽象类不能实例化，即不许
诺创建抽象类本身的实例。

没有效abstract修饰的类称为具体类，具体类能够被实例化。

ii.用abstract修饰的方式表示抽象方式，抽象方式没有方式体。

抽象方式用来描述系统具有什么功能，但不提供具体的实现。

iii.没有abstract修饰的方式称为具体方式，具体方式具有方式体。

b)语法规那么；
1) 抽象类中能够没有抽象方式，但包括了抽象方式的类必需被
概念为抽象类；
2) 没有抽象构造方式，也没有抽象静态方式；
3) 抽象类中能够有非抽象的构造方式；
4) 抽象类及抽象方式不能被final修饰符修饰。

7）abstract的利用
example/ch06/
8）描述接口
a)一个类只能继承一个直接的父类，但能实现多个接口
b)接口是抽象类的抽象，抽象类可存在有方式体的方式，接口中的
方式全数为抽象方式
c)接口中的所有方式均是抽象方式，默许都是public、abstract
类型的
d)接口中的成员变量默许都是public, static, final类型，必需
被显式初始化
e)接口中没有构造方式，不能被实例化
9）接口的利用
a)example/ch06/
b)example/ch06/
c)example/ch06/
d)example/ch06/
e)example/ch06/
10）内部类的利用
a)
静态内部类：
i.静态内部类的实例可不能自动持有外部类的特定实例的引用，在
创建内部类的实例时，没必要创建外部类的实例
ii.静态内部类能够直接访问外部类的静态成员，若是访问外部类的
实例成员，就必需通过外部类的实例去访问。

iii.在静态内部类中能够概念静态成员和实例成员
iv.能够通过完整的类名直接访问静态内部类的静态成员
b)实例内部类：
i.在创建实例内部类的实例时，外部类的实例必需已经存在
ii.实例内部类的实例自动持有外部类的实例的引用。

在内部类中，能够直接访问外部类的所有成员，包括
成员变量和成员方式
iii.外部类实例与内部类实例之间是一对多的关系，一个内部类实例只会引用一个外部类实例，而一个外部类实例
对应零个或多个内部类实例。

在外部类中不能直接访问内部类的成员，必需通过内部类的实例去访问。

iv.实例内部类中不能概念静态成员，而只能概念实例成员
v.若是实例内部类B与外部类A包括同名的成员，那么在类B中，表示类B的成员，表示类A的成员。

vi.局部内部类和实例内部类一样，能够访问外部类的所有成员，另外，局部内部类还能够访问所在方式中的final类型
的参数和变量
c)局部内部类；
i.在一个方式中概念的内部类，它的可见范围是当前方式。

和局部
变量一样，局部内部类不能用访问操纵修饰符
(public, private和protected)及static修饰符来修饰
ii.局部内部类和实例内部类一样，不能包括静态成员
11）内部类的利用
a)实例内部类：
example/ch06/
b)静态内部类：
example/ch06/
c)局部内部类
example/ch06/
d)匿名内部类
example/ch06/
e)内部类
example/ch06/
12）封装类的作用
1) 用引用类型表示数值；例如表示一个缺考学生的成绩；
2) 有些场合必需要引用类型；例如集合中只能存储引用类型；
3) 实现大体类型间和与字符串间转换；
example/ch06/
13) 集合
a) Collection和Iterator接口
1).在Collection接口中声明了适用于Set和List的通用方式： boolean add(Object o): 向集合中加入一个对象的引用； void clear(): 删除集合中的所有对象引用，即再也不持有这些
对象的引用；
boolean contains(Object o): 判定在集合中是不是持有特定对象的引用；
boolean isEmpty(): 判定集合是不是为空；
Iterator iterator(): 返回一个Iterator对象，可用它来遍历集合中的元素；
boolean remove(Object o): 从集合中删除一个对象的引用；
int size(): 返回集合中元素的数量；
Object[] toAttray(): 返回一个数组，该数组包括集合中的所有元素；
2) Iterator接口隐藏底层集合的数据结构，向客户程序提供
了遍历各类类型的集合的统一方式。

Iterator接口中声明方式：
hasNext(): 判定集合中的元素是不是遍历完毕，如没有，就返回true;
next(): 返回下一个元素；
remove(): 从集合中删除上一个由next()方式返回的元素；
b) List接口及其实现类的利用
要紧特点是其元素以线性方式存储，集合中许诺寄存重复对象。

要紧实现类包括：
1）ArrayList: 代表长度可变的数组。

许诺对元素进行快速
的
随机访问，可是向ArrayList中插入与删除元素的速度较慢；
2）LinkedList: 在实现中采纳链表结构。

对顺序访问进行了优化，向List中插入和删除元素的速度较快，随机访问速度那
么相对较慢。

随机访问是指检索位于特定索引位置的元素。

3）Vector类：与ArrayList一样也实现了List接口，表示一个可变的对象数组；
与ArrayList的不同：Vector是同步（线程平安）的，占用的资源多一些，运行效率要低一些，要紧用在多线程环境下，
ArrayList是不同步的，适合在单线程环境下利用
4）利用：
example/ch06/
c) Set接口及其实现类的利用
Set集合中寄存的是对象的引用，而且没有重复对象。

要紧实现类包括：
1）HashSet: 依照哈希算法来存取集合中的对象，存取速度比较快；
2）LinkedHashSet: HashSet子类，不仅实现Hash算法，还实现链表数据结构，链表数据结构能提高插入和删除元素的性能；
3）TreeSet: 实现SortedSet接口，具有排序功能；
4)利用：
example/ch06/
example/ch06/
example/ch06/
example/ch06/
example/ch06/
d)Map接口及其实现类的利用
Map是一种把键对象和值对象进行映射的集合，它的每一个元素都包括一对键对象和值对象。

向Map集合中加入元素时，必需提供
一对键对象和值对象，从Map集合中检索元素时，只要给出键对象，
就会返回对应的值对象。

要紧实现类包括：
1）HashMap
按哈希算法来存取键对象，有专门好的存取性能，为了保证HashMap能正常工作，和HashSet一样，要求当两个键对象
通过equals()方式比较为true时，这两个键对象的hashCode()方式返回的哈希码也一样。

2）TreeMap
实现了SortedMap接口，能对键对象进行排序。

和TreeSet 一样，TreeMap也支持自然排序和客户化排序两种方式。

3)利用
example/ch06/
14) 反射
a)一个对象或类取得自身的Class对象的进程称为反射。

b)有两种方式能够取得自身的Class对象引用(对每一个被装载的类
型(类或接口)，虚拟机都会为它创建一个的实例)：
i) Class c = (“
相同点：
a. 都不能被实例化；
b. 都能包括抽象方式；
2. 不同点；
a. 抽象类中能够为部份方式提供默许的实现，从而幸免子类中重
复实现它们，提高代码的可重用性，而接口中只能包括抽象方式；
b. 一个类只能继承一个直接的父类，那个父类有可能是抽象类；但一个类
能够实现多个接口，这是接口的优势所在。

2)几种内部类的区别
a. 声明的位置:
静态内部类：类的内部，方式的外部，用static关键字修饰；
实例内部类：类的内部，方式的外部，不用static关键字修饰；
局部内部类：方式的内部；
匿名内部类：既能够在类的内部，方式的外部，也能够在方式的
内部；
b. 实例化方式:
静态内部类：new (); ew Inner(); ashMap去掉了HashTable 的contains方式，可是加上了
containsValue（）和containsKey（）方式。

ii).hashTable同步的，而HashMap是非同步的，效率上逼hashTable 要高。

iii).hashMap许诺空键值，而hashTable不许诺。

三）作业：
exercise/chap06
第七章：异样
一）基础实验：
a). 异样产生的条件, 或称为异样情形。

在Java代码中哪些是异样情
形呢？例如：
i. 整数相除运算中，分母为0;
ii. 通过一个没有指向任何具体对象的引用去访问对象的方式； iii. 利用数组长度作为下标访问数组元素；
iv. 将一个引用强制转化成不相干的对象；
等等；
b). 异样会改变正常程序流程;
异样产生后，正常的程序流程被打破了，要么程序中止，要么程序被转向异样处置的语句；
c). 当一个异样的事件发生后，该异样被虚拟机封装形成异样对象抛出。

d). 用来负责处置异样的代码被称为异样处置器
f). 通过异样处置器来捕捉异样
…catch语句
在Java语言中，用try...catch语句来捕捉处置异样。

格式如下： try {
可能会显现异样情形的代码；
} catch(异样类型异样参数) {
异样处置代码
} catch(异样类型异样参数) {
异样处置代码
}
1). 若是try代码块中没有抛出异样，try代码块中语句会顺序执行完，catch代码块内容可不能被执行；
2). 若是try代码块中抛出catch代码块所声明的异样类型对象，程序跳过try代码块中接下来代码，直接执行catch代码块中对应内容; a. 能够存在多个catch代码块，究竟执行哪个，看抛出的异样对象是不是是catch代码块中异样类型；
b. 异样只能被一个异样处置器所处置, 不能声明两个异样处置器
处置相同类型的异样；
c. 多个catch语句块所声明的异样类型不能愈来愈小；
d. 不能捕捉一个在try语句块中没有抛出的异样；
3). 若是try代码块中抛出catch代码块未声明的异样类型对象，异样被抛给挪用者；哪个挪用了这段语句块哪个负责处置那个异样；
4)利用
example/ch07/
语句
任何情形下都必需执行的代码
Example/ch07/
所有异样类的先人类为类。

它有两个直接的子类：
1). Error类：表示仅靠程序本身无法恢复的严峻错误，比如内存空间不足，或Java虚拟机的方式挪用栈溢出。

在大多数情形下，碰到如此的错误时，建议让程序终止。

2). Exception类：表示程序本身能够处置的异样。

Exception还能够分为两种：运行时异样和受检查异样。

a).运行时异样
RuntimeException类及其子类都被称为运行时异样，这种异样的特点是Java编译器可不能检查它，也确实是说，当程序中可
能显现这种异样时，即便没有效try...catch语句捕捉它，也没
有效throws子句声明抛出它，仍是会编译通过。

例如divide()
方式的参数b为0, 执行a/b操作时会显现ArithmeticException
异样，它属于运行时异样，Java编译器可不能检查它。

b). 受检查异样
除RuntimeException及其子类之外，其他的Exception 类及其子类都属于受检查异样(Checked Exception)。

这种异样
的特点是Java编译器会检查它，也确实是说，当程序中可能显
现这种异样时，要么用try...catch语句捕捉它，要么用throws
子句声明抛出它，不然编译可不能通过。

5. 异样声明和处置
1). 利用throw声明代码会倒致异样；
2). 利用try-catch-finally语句结构处置或在方式声明上声明throws继续抛出；
异样处置语句的语法规那么：
i). try代码块不能离开catch代码块或finally代码块而单独存在。

try代码块后面至少有一个catch代码块或finally代码块。

ii). try代码块后面能够有零个或多个catch代码块，还能够有零个或最多一个finally代码块。

若是catch代码块和finally代码块并存，finally代码块必需在catch代码块后面。

iii). try代码块后面能够只跟finally代码块。

iv). 在try代码块中概念的变量的作用域为try代码块，在catch 代码块和finally代码块中不能访问该变量。

v). 当try代码块后面有多个catch代码块时，Java虚拟机遇把实际抛出的异样对象依次和各个catch代码块声明的异样类型匹配，若是异样对象为某个异样或其子类的实例，就执行那个catch代码块，而可不能再执行其他的catch代码块。

vi). 若是一个方式可能显现受检查异样，要么用try...catch语句捕捉，要么用throws子句声明将它抛出。

vii). throw语句后面不许诺紧跟其它语句，因为这些语句永久可不能被执行。

能够概念自己的异样类，继承Exception，必需人工抛出；
example/ch07/SelfException
引入，在java程序中加入检查语句，要紧用于程序调试；
断言机制
在程序中概念的boolean表达式（假定条件）不成立时（即返
回false），系统将产生一个Error对象，类型为AssertionError类
型；
在约定条件不成立的情形下需要终止程序操作时利用断言；
断言作为Error的一种，断言失败没必要进行铺获处置或声明抛出，
一旦显现终止程序，没必要进行补救和恢复。

利用
assert boolean表达式[:表达式]
断言用于程序调试，java运行时环境默许关闭断言功能；
开启断言功能：
java -ea classname
或
java -enableassertions classname
关闭断言功能：
java -da classname
或
java -disableassertions classname
二）扩展实验：
1. 异样挪用栈
异样处置时所通过的一系列方式挪用进程被称为异样挪用栈。

1). 异样的传播
哪个挪用，哪个处置；
a. 异样情形发生后，发生异样所在的方式能够处置；
b. 异样所在的方式内部没有处置，该异样将被抛给该方式挪用
者，挪用者能够处置；
c. 如挪用者没有处置，异样将被继续抛出；如一直没有对异样
处置，异样将被抛至虚拟机；
2). 若是异样没有被捕捉，那么异样将使你的程序将被停止。

异样产生后，若是一直没有进行捕捉处置，该异样被抛给虚拟机。

程序将被终止。

3). 常常会利用的异样API
getCause()：返回类型是Throwable，该方式取得Throwable的异样缘故或null。

getMessage()：取得具体的异样犯错信息，可能为null。

printStatckTrace()：打印异样在传播进程中所通过的一系列方法的信息，简称异样处置方式挪用栈信息；在程序调试时期，此方
式可用于跟踪错误。

举例：example/ch07/CallStackTraceTest
2.常见的未检查的异样RuntimeException有哪些？别离代表什么含义？
1).
算术异样如：除0;
2).
空指针引用如：没初始化一个References便利用;
3).
数组越界如：调用一个有十个元素的Array的第十一个元素的内容;
4).
违背了java概念的平安规那么
5).
数据格式异样如：("a");
6). 数组长度为负数异样
三）作业：
exercise/chap07
第八章：GUI
一）基础实验：
1).GUI:Graphics User Interface 图形用户界面，与用户交互的窗口；
2).AWT：Abstract Window ToolKit抽象窗口工具集
AWT是JDK的一部份，能够说是Java API的子集，其中包括组件、容器和布局治理器等要素；AWT支持Java GUI事件处置；利用AWT能够进行Java GUI的开发；
3). 相关软件包：
.*：GUI大体组件包；
GUI事件处置包（用于实现与用户交互）；
.*:图形界面升级包；
1).组件是图形用户界面的大体组成元素；凡是能够显示在屏幕上而且
能够和用户交互的对象称为组件，例如：菜单、按钮、标签、文本框和转动条等；
2).组件不能单独的显示出来，必需放在必然的容器中才能显示出来；
3).在.*包中概念了很多组件类：Button、Menu、Lable、TextField；
4).在.*包中有一个抽象类，该类是除Menu类之外所有组件类的功能父
类，其中概念了GUI组件的大体特点，例如：尺寸、位置、颜色等；还实现了作为GUI组件应该具有的大体功能；
1).容器本身也是一个组件，因此Container是Component的子类；具
有组件具有的所有性质，只是容器组件能够容纳其他组件或容器；
2). 容器具有add()方式用于添加其他组件到容器中；
3). 容器分类：
a) 可以自由停泊的顶级窗口；例如：Frame
b) 可以作为容器容纳其他组件，但是不能独立存在，必须
添加到其他容器；例如：添加到Frame中；
4).利用
example/ch08/
用来操纵组件在容器中的排列风格；包括组件的位置和大小的设定；
每一个容器都有一个默许的布局治理器，当容器需要对某一组件进行定位或判定其大小尺寸时，就会挪用对应的布局治理器；
一个容器只能有一种排列风格；
1).FlowLayout
FlowLayout是Panel容器的默许布局治理器
布局成效：
a).组件在容器中逐行加入，行内自左向右，排满一行后换行；
b).不改变组件大小，按原始大小加入；
c).组件在容器中默许居中对齐，也能够通过构造方式设置对齐方式，
行间距，组件间距；
d)利用：
example/ch08/
2).BorderLayout
BorderLayout布局治理器是Frame默许的布局治理器；
布局成效：
a).BorderLayout将容器划分为东西南北中五个区域，组件只能被添
加到指定的区域；
b).添加组件时若是没有指定添加区域，默许添加到Center区域；一个区域只能放一个组件，若是在一个区域添加多个组件，那么先前添加的组件将作废；
c).组件大小被强行操纵，大小与指定区域大小相同；
d).利用
example/ch08/
3).GridLayout
GridLayout布局成效：
a).将容器划分为规那么的矩形网格，依照组件的加入顺序自左向右
逐行加入，行间自上而下，将组件放入单元格；
b).组件大小被强行操纵，和单元格大小相同，随着容器的大小转变，。