java学习笔记
第一章简介
1.什么是Applets?
Applets是一种贮存于WWW服务器的用Java编程语言编写的程序，它通常由浏览器下载到客户系统中，并通过浏览器运行。Applets 通常较小，以减少下载时间，它由超文本标识语言（HTML）的Web页来调用。
2.什么是Java applications？
Java applications是一种独立的程序，它不需要任何Web 浏览器来执行。可运行于任何具备Java运行环境的设备中。
3. 什么是Java虚拟机？
提供硬件平台规范
解读独立于平台的已编译的字节码
可当作软件或硬件来实现
可在Java技术开发工具或Web 浏览器上实现
4. Java 虚拟机规范为Java 虚拟机（JVM）作了如下定义：
在真实机器中用软件模拟实现的一种想象机器。Java虚拟机代码被存储在 .class 文件中；每个文件都
包含最多一个public 类。
编译器在获取Java 应用程序的源代码后，将其生成字节码（字节码被存储在 .class 文件中。），它是为JVM 生成的一种机器码指令。每
个Java 解释器，不管它是Java 技术开发工具，还是可运行applets 的Web 浏览器，都可执行JVM。
5．什么是垃圾收集？
不再需要的分配存储器应取消分配
在其它语言中，取消分配是程序员的责任
Java 编程语言提供了一种系统级线程以跟踪存储区分配
垃圾收集的作用；
可检查和释放不再需要的存储器（在JVM空闲周期）
可自动完成上述工作
可在JVM 实现周期中，产生意想不到的变化
6．关于存储器漏洞？
当在系统中没有能够被分配的存储器时，可导致程序瘫痪，这种程序被称作具有存储器漏洞。
垃圾收集在Java 技术程序的生命周期中自动进行，它解除了取消分配存储器的要求，并避免了存储器
漏洞。然而，垃圾收集可在JVM 实现的周期中，产生意想不到的变化。
7.java程序的运行过程？
构成Java 软件程序的字节码在运行时被加载、校验并在解释器中运行。当运行applets 时，字节码可
被下载，然后由建于浏览器中的JVM 进行解释。解释器具备两种功能，一是执行字节码，二是对底层硬件
做适当调用。
8.java的运行环境？
一个Java 技术的运行环境可运行为JVM 编译的代码并执行如下三大任务：
加载代码－由类加载器执行
校验代码－由字节码校验器执行
执行代码－由运行时的解释器执行
类加载器的作用？
类加载器为程序的执行加载所需要的全部类。类加载器将局部文件系统的类名空间与来自网络源的类
名空间相分离，以增加安全性。由于局部类总是首先加载，因而可限制任何“特洛依木马”的应用。
9. 注意----所有源于网络的类文件都要经过字节码校验器。
10．程序运行的起始点；Java 技术解释器必须发现这一严格定义的点，否则将拒绝运行程序。
11 public－方法main()可被任何程序访问，包括Java 技术解释器。
static－ 是一个告知编译器main()是用于类HelloWorldApp 中的函数的关键字。为使main()在程序做其
它事之前就开始运行，这一关键字是必要的。
12.编译并运行
编译
当你创建了HelloWorldApp.java 源文件后，用下列程序行进行编译：
c:/student/javac HelloWorldApp.java
如果编译器未返回任何提示信息，新文件HelloWorldApp.class 则被存储在与源文件相同的目录中，除
非另有指定。
运行
为运行你的HelloWorldApp 应用程序，需使用Java 解释器和位于bin 目录下的java:
c:/student/ java HelloWorldApp Hello World!
注意－必须设置PATH 环境变量以发现java 和javac，确认它包括c:/jdk1.2/bin
11. 命名
如果·java 文件包括一个公共类，那么它必须使用与那个公共类相同的文件名。例如在前例中的类的
定义是
public class HelloWorldapp
源文件名则必须是HelloWorldapp.java
类计数
在源文件中每次只能定义一个公共类。
12. 一个Java 源文件可包含三个“顶级”要素：
一个包声明（可选）
任意数量的输入语句
类和界面声明
该三要素必须以上述顺序出现。即，任何输入语句出现在所有类定义之前；如果使用包声明，则包声
明必须出现在类和输入语句之前。
13.什么是类和包？
类是描述提供某种功能的模块的一般术语。Java 开发集（JDK）给出了一套标准的类（称作类库），
这些类可执行大部分所需的基本行为不仅为编程任务（例如，类可提供基本的数学函数、数组和字符
串），而且为图形和网络。
类库被组织成许多包，每个包都包含几个类。如下所列为一些重要的包：
java.lang 包含一些形成语言核心的类，如String、Math、Integer 和Thread。
java.awt 包含了构成抽象窗口工具包（AWT）的类，这个包被用来构建和管理应用程序的图形用户界
面。
java.applet 包含了可执行applet 特殊行为的类。
java.net 包含执行与网络相关的操作的类和处理接口及统一资源定位器(URLs)的类。
java.io 包含处理I/O 文件的类。
java.util 包含为任务设置的实用程序类，如随机数发生、定义系统特性和使用与日期日历相关的函数。
14. 使用Java API 文档
1. 一组超文本标识语言(HTML)文件提供了有关API 的信息
2. 一个包包含了对所有类信息的超链接
3. 一个类文档包括类层次、一个类描述、一组成员变量和构造函数等。
第二章 标示符，关键字和类型
1.java中的注释方法：
三种允许的Java 技术程序注释风格
//comment on one line
/* comment on one
or more line */
/** documenting comment */
注意------有关这些注释的格式和 javadoc 工具的使用，请见JDK1.2 API 文件的 docs/tooldocs/win32
目录
2. 分号、块和空白
一个语句是一行用分号(；) 终止的代码
一个块是以上括号和下括号为边界的语句集合
块语句可被嵌套
Java 程序中允许任意多的空白
语句块可被嵌套。HelloWorldApp 类由main 方法构成，这个方法就是一个语句块，它是一个独立单元，
单元本身可作为在类HelloWorldApp 块中的一组事务之一。
Java中所有的指令都是小写的。
快捷方式的设定；
3.标识符
是赋予变量、类和方法的名称
可从一个字母、下划线(_)或美元符号($)开始（不能是数字开头）
是大小写区别对待的, 且无最大长度
不能是关键字，但可包含关键字作为一部分。
Java 技术源程序采用有效的16-bit 双字节字符编码标准(Unicode) ，而不是8-bit ASCII 文本。因而，
一个字母有着更广泛的定义，而不仅仅是a 到z 和A 到Z。
谨慎对待非ASCII字符，因为Unicode 可支持看似相同而实际不同的字符。
注意──包含美元符号（$）的关键字通常用的较少，尽管它在BASIC和VAX/VMS系统语言中有着广泛的
应用。由于它们不被熟知，因而最好避免在标识符中使用它们，除非有本地使用上的习惯或其他不得已
的原因。
4 .Java 关键字
Java 编程语言中的关键字。
abstract do implements private throw
boolean double import protected throws
break else instanceof public transient
byte extends int return true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continue for null synchronized
default if package this
关键字的注意事项；（所有关键字必须小写）
true、false 和null 为小写，而不是象在C++语言中那样为大写。严格地讲，它们不是关键字，而是文
字。然而，这种区别是理论上的。
无sizeof 运算符；所有类型的长度和表示是固定的，不依赖执行。
goto 和const 不是Java 编程语言中使用的关键字
5. 基本Java 类型
原始类型
Java 编程语言为八个原始数据类型和一个特殊类型定义了文字值。原始类型可分为四种：
逻辑类 boolean
文本类 char （0~65535）
整数类 byte, short, int, long
浮点类 double, float
逻辑类：boolean 数据类型有两种文字值：true 和false。
注意──在整数类型和boolean 类型之间无转换计算。有些语言（特别值得强调的是C 和C++）允许将数
字值转换成逻辑值， 这在Java 编程语言中是不允许的；boolean 类型只允许使用boolean 值。
文本类：char
代表一个16-bit Unicode 字符（无符号不分正负）
必须包含用单引号（’’）引用的文字（一个char 文字必须包含在单引号内(‘’)。）
使用下列符号：
‘a’
‘/t’ 一个制表符
‘/u????’ 一个特殊的Unicode 字符，????应严格使用四个16 进制数进行替换
String 不是原始类型，而是一个类（class），它被用来表示字符序列。字符本身符合Unicode 标准，且
上述char 类型的反斜线符号适用于String。与C 和C++不同，String 不能用 /0 作为结束。具有用双引号引用的文字。
String可和基本类型串接 （串接的应用）
String str = "Just For Fun…"+123;
String str = "Just For Fun…"+true;
String str = "Just For Fun…"+ 0.5f ;
注意--如果一个操作数已经是一个String, 则加号(+)将另一个操作数转换成String。
char 型別正確表示法：
char a = 12345;
char a = ‘/’’; （显示引号）
char a = ‘/ucafe’;
整数类──byte, short, int, long
采用三种进制──十进制、八进制和16 进制
2 十进制值是2
077 首位的0 表示这是一个八进制的数值
0xBAAC 首位的0x 表示这是一个16 进制的数值
具有缺省int
用字母“L”和“l”定义long
注意──所有Java 编程语言中的整数类型都是带符号的数字。
请注意，在Java 编程语言中使用大写或小写L 同样都是有效的，但由于小写l 与数字1 容易混淆，因而，使用小写不是一个明智的选择。
每个整数数据类型具有下列范围：
Integer Length Name or Type Range
8 bits byte -2 7 ... 2 7 -1
16 bits short -2 15 ... 2 15 -1
32 bit int -2 31 ... 2 31 -1
64 bits long -2 63 ... 2 63 -1
int的正确标示方法；
int a = ‘a’;
范围的表示是按Java 编程语言规范定义的且不依赖于平台。
浮点──float 和double
缺省为double
浮点文字包括小数点或下列各项之一
E 或e (增加指数值)
F 或f (float)
D 或d （double）
3.14 一个简单的浮点值（a double）
4.02E23 一个大浮点值
2.718F 一个简单的float 长度值
123.4E+306D 一个大的带冗余D 的double 值
浮点数据类型具有下列范围：
浮点长度 名称或类型
32 bits float
64 bits double
注意──浮点文字除非明确声明为float，否则为double
double除了不能放boolean型別外，所有基本型別可以放的東西，他都可以 !
6. 变量、声明和赋值
7. Java 编码约定
8.对象的理解
要定义一个新的类型，你必须指出需要多大存储器和如何解释存储器内容。这不是根据字节数或位的顺序和含义来做，而是根据已经定义的其它类型来做。
注意----- class 不仅仅是一个集合数据类型，这个问题以后还将进一步讨论.
9.创建一个对象
原始类型的声明可分配存储器空间
非原始类型的声明不分配存储器空间
声明的变量不是数据本身, 而是数据的引用reference (或指针)
注意----你也可以认为引用是一个指针(pointer), 这可能会有助于你的理解。实际上, 在大多数实现中,
也确实可以这样认为。值得注意的是, Java 编程语言实际上不支持指针数据类型。
创建一个新类型；
class MyDate {
int day;
int month;
int year;
}
10. 创建一个对象----存储器分配和布局
MyDate myBirth;
myBirth = new MyDate ();
第一个语句(声明)仅为引用分配了足够的空间，而第二个语句则通过调用对象为构成MyDate 的三个整
数分配了空间。对象的赋值使变量myBirth 重新正确地引用新的对象。这两个操作被完成后，MyDate 对象
的内容则可通过myBirth 进行访问。
一个声明仅为一个引用分配存储器。
关键字new 意味着存储器的分配和初始化
使用一个语句同时为引用today 和由引用today 所指的对象分配空间也是可能的。
MyDate today = new MyDate ();
11. 引用类型的赋值
第三章 表达式和流程控制
1.变量和作用域：
局部(local)变量是在一个方法内定义的变量, 也被称作自动（automatic）、临时（temporary）或栈（stack）变量。
当一个方法被执行时, 局部变量被创建；当一个方法被终止时, 局部变量被清除。
局部变量必须使用之前初始化, 否则编译时将出错。
在方法外定义的变量是在使用new Xxxx ()调用构造一个对象时被创建。在构造一个对象时，可创建两
种变量。一是类变量，它是用static 关键字来声明的；只要需要对象，类变量就将存在。二是实例变量，它
不需用static 关键字来声明；只要对象被当作引用，实例变量就将存在。实例变量有时也被用作成员变量，
因为它们是类的成员。
方法参数变量定义在一个方法调用中传送的自变量，每次当方法被调用时，一个新的变量就被创建并
且一直存在到程序的运行跳离了该方法。
当执行进入一个方法时，局部变量被创建，当执行离开该方法时，局部变量被取消。因而，局部变量
有时也被引用为“临时或自动”变量。在成员函数内定义的变量对该成员变量是“局部的”，因而，你可以在几个成员函数中使用相同的变量名而代表不同的变量。
注意── 一个具有空值的引用不引用任何对象。试图使用它引用的对象将会引起一个异常。异常是出现
在运行时的错误，这将在模块7“异常”中讨论。
在方法外定义的变量被自动初始化。局部变量必须在使用之前做“手工”初始化。如果编译器能够确
认一个变量在初始化之前可被使用的情形，编译器将报错。
2.运算符
Separator [] () ; ,
R to L ++ -- + - ~ ! (data type)
L to R * / %
L to R + -
L to R << >> >>>
L to R < > <= >= instanceof
L to R == !=
L to R &
L to R ^
L to R |
L to R &&
L to R ||
R to L ?:
R to L = *= /= %= += -= <<= >>= >>>= &= ^= |=
注意──instanceof 是Java 编程语言特有的运算符
3．表达式
支持的位运算符如下：
！──NOT &──AND
｜──XOR ^──OR
布尔运算符如下：
~ ──Complement(取反) &──AND
^──XOR ｜ ｜──OR
4.位移运算符
运算符>>进行算术或符号右移位。移位的结果是第一个操作数被2 的幂来除，而指数的值是由第二个
数给出的。在移位的过程中， 符号位被拷贝。
逻辑或非符号右移位运算符>>>主要作用于位图，而不是一个值的算术意义；它总是将零置于最重要
的位上。
注意──移位运算符将它们右侧的操作数模32 简化为int 类型左侧操作数, 模64 简化为long 类型右侧操作数。因而, 任何int x, x >>> 32 都会导致不变的x 值, 而不是你可能预计的零。
注意------值得称赞的重要一点是: >>>运算符仅被允许用在整数类型, 并且仅对int 和long 值有效。如
果用在short 或byte 值上, 则在应用>>>之前, 该值将通过带符号的向上类型转换被升级为一个int。有
鉴于此，无符号移位通常已成为符号移位。
运算符<<执行一个左移位。移位的结果是：第一个操作数乘以2 的幂，指数的值是由第二个数给出的。
5. 类型转换
如果赋值的信息丢失，程序员必须采用类型转换的方法确认赋值
在short 和char 之间的赋值需要一个显式转型
6. 升级和表达式的类型转换
当没有信息丢失时，变量可被自动升级为一个较长的形式。
一般来讲，如果变量类型至少和表达式类型一样大（位数相同），则你可认为表达式是赋值兼容的。
对 + 运算符来说，当两个操作数是原始数据类型时，其结果至少有一个int，并且有一个通过提升操
作数到结果类型、或通过提升结果至一个较宽类型操作数而计算的值，这可能会导致溢出或精度丢失。例
如：
short a，b，c
a=1；
b=2；
c= a+b；
上述程序会因为在操作short 之前提升每个short 至int 而出错。然而，如果c 被声明为一个int，或按
如下操作进行类型转换：
c = (short)(a+b);
则上述代码将会成功通过。
有关于流程控制：
7.分支语句
if, else 语句
if, else 语句的基本句法是：
if (布尔表达式)｛
语句或块；
｝ else ｛
语句或块；
｝
在Java 编程语言中，if ()用的是一个布尔表达式，而不是数字值，这一点与C/C++不同。前面已经讲
过，布尔类型和数字类型不能相互转换。
switch 语句
switch 语句的句法是：
switch (expr1)｛
case expr2:
statements;
break;
case expr3:
statements;
break;
default:
statements;
break;
｝
注意──在switch (expr1) 语句中，expr1 必须与int 类型是赋值兼容的；byte, short 或char 类型可
被升级；不允许使用浮点或long 表达式。
如果没有break 语句作为某一个case 代码段的结束句，则程序的执行将继续到下一个case，而不检查case
表达式的值。
for 循环
for 循环的句法是：
for (init_expr; boolean testexpr; alter_expr)｛
statement or block
｝
注意──Java 编程语言允许在for () 循环结构中使用逗号作为分隔符。 例如，for (i= 0, j = 0; j<10;
i++, j++)是合法的；它将i 值初始化为零，并在每执行完一次循环体后，增加一次它们的值。
while 循环的句法是：
while (布尔表达式) ｛
语句或块
｝
do 循环的句法是：
do ｛
语句或块；
｝
while (布尔测试)
作为一种编程惯例，for 循环一般用在那种循环次数事先可确定的情况，而while 和do 用在那种循环
次数事先不可确定的情况。
特殊循环流程控制
break ［标注］；
continue［标注］；
label: 语句；// where statement must be any
// legal statement.
break 语句被用来从switch 语句、loop 语句和预先给定了label 的块中退出。
continue 语句被用来略过并跳到循环体的结尾。
label 可标识控制需要转换到的任何有效语句，它被用来标识循环构造的复合语句。
有关于数组：
8.数组声明
声明不能创建对象本身，而创建的是一个引用，该引用可被用来引用数组。数组元素使用的实际存储器可由new语句或数组初始化软件动态分配。
方括号级可以放在变量左边也可以放在右边。
注意----当数组声明的方括号在左边时，该方括号可应用于所有位于其右的变量
9.创建数组
使用关键字new 创建一个数组对象。
s = new char [20];
用来指示单个数组元素的下标必须总是从0 开始，并保持在合法范围之内－－大于0 或等于0 并小于
数组长度。
10.初始化数组
当创建一个数组时，每个元素都被初始化。
注意－－所有变量的初始化(包括数组元素)是保证系统安全的基础，变量绝不能在未初始化状态使用。
Java 编程语言允许使用下列形式快速创建数组:
String names [] = {
“Georgianna”,
“Jen”,
“Simon”,
};
其结果与下列代码等同：
String names [] ;
names = new String [3];
names [0] = “Georgianna”;
names [1] = “Jen”;
names [2] = “Simon”;
这种”速记”法可用在任何元素类型。例如：
Myclass array [] = {
new Myclass (),
new Myclass (),
new Myclass ()
};
适当的类类型的常数值也可被使用：
Color palette [] = {
color.blue,
color.red,
color.white
};
11.多维数组
12.数组的界限
所有数组的下标都从0 开始
int list [] = new int [10];
for (int i= 0; i< list.length; i++)
System.out.println(list[i]);
13.拷贝数组
数组一旦创建后，不能调整数组的大小，可使用相同的引用变量来引用一个全新的数组
int elements [] = new int [6];
elements = new int [10];
在这种情况下，第一个数组被有效地丢失，除非对它的其它引用保留在其它地方。
arraycopy()可作如下使用：
// original array
1.int myArray[] = { 1, 2, 3, 4, 5, 6 };
2.
3.// new larger array
4.int hold[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
5.// copy all of the myArray array to the hold
6.// array, starting with the 0th index
7.System.arraycopy(myArray, 0, hold, 0,
8.myArray.length);
在这一点，数组hold 有如下内容：1,2,3,4,5,6,4,3,2,1。
注意—在处理对象数组时，System.arraycopy()拷贝的是引用，而不是对象。对象本身不改变。
第五章 对象和类
1.抽象数据类型
有些程序语言（少数），包括Java，允许在数据类型的声明和操作该类型变量的代码的声明之间有紧密的联系。这种联系通常被称为抽象数据类型。
2.类和对象
Java 编程语言中的抽象数据类型概念被认为是class。类给对象的特殊类型提供定义。它规定对象内部
的数据，创建该对象的特性，以及对象在其自己的数据上运行的功能。因此类就是一块模板。
类是对象的抽象，对象是类的实例。在Java 编程语言中使用new 运算符实例化一个对象。
方法定义了可以在对象上进行的操作，换言之，方法定义类来干什么。因此Java 编程语言中的所有方法都属于一类。不象C++程序，Java 软件程序不可能在类之外的全局区域有方法。
3. 值传递
Java 编程语言只由值传递参数。，也就是说，参数不能由被调用的方法来改变。
当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。
4.this 引用
关键字this 是用来指向当前对象或类实例的。Java 编程语言自动将所有实例变量和方法引用与this 关键字联系在一起，因此，使用关键字在某些情况下是多余的。也有关键字this 使用不多余的情况。如，需要在某些完全分离的类中调用一个方法并将当前对象的一个引用作为参数传递时。例如：
Birthday bDay = new Birthday (this);
5.关于如何正确地调用方法，诸如“参数“月份”的值在对象中必须在有效范围内”的规
则被叫做不变量（或前置和后置条件）。
6.封装：数据隐藏通常指的就是封装。它将类的外部界面与类的实现区分开来，隐藏实现细节。迫使用户去使
用外部界面，即使实现细节改变，还可通过界面承担其功能而保留原样，确保调用它的代码还继续工作。
这使代码维护更简单。
7. 重载方法名称
参数表必须不同
返回类型可以不同
有两个规则适用于重载方法：
调用语句的参数表必须有足够的不同，以至于允许区分出正确的方法被调用。正常的拓展晋升（如，
单精度类型float 到双精度类型double）可能被应用，但是这样会导致在某些条件下的混淆。
方法的返回类型可以各不相同，但它不足以使返回类型变成唯一的差异。重载方法的参数表必须不同。
8.构造并初始化对象
调用new XXX()来为新对象分配空间会产生如下结果：
新对象的空间被分配并被初始化为0 或空值
进行了显式的初始化
构造函数被执行使用关键字new 会导致下述情况：
首先，新对象的空间被分配并初始化到0 或空值。在Java 编程语言中，该阶段是不可分的，以确保在
分配空间的过程中不会有大小为随机值的对象。
其次，进行显式的初始化。
第三，构造函数被执行，它是一种特殊方法。括号中传递给new 的参数被传递给构造函数。
9.构造函数
一个新对象的初始化的最终步骤是去调用一个叫做构造函数的方法。
方法名称必须完全与类名称相匹配.
对于方法，不要声明返回类型.
调用重载构造函数
如果有一个类带有几个构造函数，那么也许会想复制其中一个构造函数的某方面效果到另一个构造函
数中。可以通过使用关键字this 作为一个方法调用来达到这个目的。
public class Employee {
private String name;
private int salary;
public Employee(String n, int s) {
name = n;
salary = s;
}
public Employee(String n) {
this(n, 0);
}
public Employee() {
this( " Unknown " );
}
}
在第二个构造函数中，有一个字符串参数，调用this(n,0)将控制权传递到构造函数的另一个版本，即采
用了一个String 参数和一个int 参数的构造函数中。
在第三个构造函数中，它没有参数，调用this(“Unknownn”)将控制权传递到构造函数的另一个版本，
即采用了一个String 参数的构造函数中。
注— 对于this 的任何调用，如果出现，在任何构造函数中必须是第一个语句。
注— 如果增加一个带参数的构造函数声明到一个类中，该类以前没有显式构造函数，那么将失去该缺省构
造函数。基于这一点，对new Xxx()的调用将会引起编译错误。认识到这一点很重要。
10.子 类 关键字extends 来实现
注--这种方法是在维护和可靠性方面的一个伟大进步。如果在Employee 类中进行修改，那么， Manager
类就会自动修改，而不需要程序员做任何工作，除了对它进行编译。
注— 对一个继承的方法或变量的描述只存在于对该成员进行定义的类的API 文档中。当浏览探索一个（子）
类的时候，一定要检查父类和其它祖先类中的继承成员。
11. 参数和异类收集
可以创建具有共同类的对象的收集（如数组）。这种收集被称作同类收集。
Java 编程语言有一个对象类，因此，由于多态性，它能收集所有种类的元素，正如所有类都扩展类对
象一样。这种收集被称作异类收集。
异类收集就是不相似的东西的收集。在面向对象语言中，可以创建许多东西的收集。所有的都有一个
共同的祖先类-Object 类。如：
Employee [] staff = new Employee[1024];
staff[0] = new Manager();
staff[1] = new Employee();
甚至可以写出一个排序的方法，它将职员按年龄或薪水排序，而忽略其中一些人可能是经理。
注-每个类都是Object 的一个子类，因此，可以用Object 数组作为任何对象的容器。唯一不能被增加到
Object 数组中的唯一的东西就是基本变量（以及包装类，将在模块6 中讨论，请注意这一点）。比Object
数组更好的是向量类，它是设计来贮存异类收集对象的。
12. 单继承性
当一个类从一个唯一的类继承时，被称做单继承性。单继承性使代码更可靠。界面Interface提供多继承性的好处，而且没有（多继承的）缺点。
13. 构造函数不能被继承
子类从超类（父类）继承所有方法和变量
子类不从超类继承构造函数
包含构造函数的两个办法是:
使用缺省构造函数
写一个或多个显式构造函数
14. 多态性
有能力拥有有许多不同的格式，就叫做多态性。
一个对象只有一个格式
一个变量有许多格式，它能指向不同格式的对象
象大多数面向对象语言一样，Java 实际上允许引用一个带有变量的对象，这个变量是父类类型中的一
个。因此，可以说：
Employee e = new Manager()
使用变量e 是因为，你能访问的对象部分只是Employee 的一个部分；Manager 的特殊部分是隐藏的。
注-多态性是个运行时问题，与重载相反，重载是一个编译时问题。
15.关键字super
关键字super 可被用来引用该类中的超类。它被用来引用超类的成员变量或方法。超类行为被调用，就好象对象是超类的组件。调用行为不必发生在超类中，它能自动向上层类追溯。
super.method()格式的调用，如果对象已经具有父类类型，那么它的方法的整个行为都将被调用，也包括其所有副面效果。该方法不必在父类中定义。它也可以从某些祖先类中继承。
16. Instanceof 运算符
假如能使用引用将对象传递到它们的父类中，那么有时你想知道实际有什么，这就是instanceof 运算符的目的。
注— 在C++中，可以用RTTI（运行时类型信息）来做相似的事，但在Java 编程语言中的instanceof 功能
更强大。
16.对象的类型转换 （类型转换发生的类必须是当前引用类型的子类。）
使用instanceof 来测试一个对象的类型。
用类型转换来恢复一个对象的全部功能。
用下述提示来检查类型转换的正确性：
向上的类型转换是隐含地实现的。（可由简单的赋值实现）
向下的类型转换必须针对子类并由编译器检查。
当运行时错误发生时，运行时检查引用类型。
16.覆盖方法
子类可以修改从父类继承来的行为
子类能创建一个与父类方法有不同功能的方法，但具有相同的
（名称 返回类型 参数表）
17. 虚拟方法调用
Employee e = new Manager();
e.getDetails();
编译时类型与运行时类型
事实上，你得到与变量的运行时类型（即，变量所引用的对象的类型）相关的行为，而不是与变量的
编译时类型相关的行为。这是面向对象语言的一个重要特征。它也是多态性的一个特征，并通常被称作虚
拟方法调用。
注— 如果你是C++程序员，就会在Java 编程语言和C++之间得出一个重要的区别。在C++中，你要想得到
该行为，只能在源程序中将方法标记成virtual。然而，在纯面向对象语言中，这是不正常的。当然，C++
这么做是要提高执行速度。
18.调用覆盖方法
覆盖方法的规则
必须有一个与它所覆盖的方法相同的返回类型
不能比它所覆盖的方法访问性差
不能比它所覆盖的方法抛出更多的异常。
19. 调用父类构造函数
对象的初始化是非常结构化的。
当一个对象被初始化时，下述行为按顺序发生：
存储空间被分配并初始化到0 值
层次中的每个类都进行显式初始化
层次中的每个类都调用构造函数
Java 编程语言总是在执行子构造函数前调用父类构造函数的版本。
注— 调用super()能将任意数量的合适的参数赋到父类中的不同构造函数中，但它必须是构造函数中的第
一个语句。
当被使用时，super 或this 必须被放在构造函数的第一行。显然，两者不能被放在一个单独行中，但这
种情况事实上不是一个问题。如果写一个构造函数，它既没有调用super(…)也没有调用this(…)，编译器自
动插入一个调用到父类构造函数中，而不带参数。其它构造函数也能调用super(…)或this(…)，调用一个
Static 方法和构造函数的数据链。最终发生的是父类构造函数（可能几个）将在链中的任何子类构造函数前执行。
20.编组类
包的声明：
包声明必须在源程序文件的开始被声明
根据源程序文件，只允许有一个包声明
// Class Employee of the Finance department for the
// ABC company
package abc.financedept;
public class Employee {
...
}
包名称是分层的，由圆点隔开
Import 语句
告诉编译器到哪儿寻找类来使用，必须先于所有类声明
import abc.financeDept.*;
public class Manager extends Employee {
String department;
Employee [] subordinates;
}
注— import 语句必须先于所有类声明。
21. 目录布局及CLASSPATH 环境变量
第六章 高级语言的特性
1. 类（static）变量
在所有类的实例中共享
可以被标记为public 或private
如果被标记为public 而没有该类的实例，可以从该类的外部访问
public class Count {
private int serialNumber;
private static int counter = 0;
public Count() {
counter++;
serialNumber = counter;
}
}
2. 类(static)方法
因为static 方法不需它所属的类的任何实例就会被调用，因此没有this 值。结果是，static 方法不
能访问与它本身的参数以及static 变量分离的任何变量。访问非静态变量的尝试会引起编译错误。
注-非静态变量只限于实例，并只能通过实例引用被访问。
静态方法不能被覆盖成非静态。
3. 静态初始化程序
在static block 中，类可以包含方法程序中不存在的代码。当类被装载时，静态代码块只执行一次。类中不同的静态块按它们在类中出现的顺序被执行。
4.关键字final
Final 类不能被分成子类
Final 方法不能被覆盖
Final 变量是常
被标记为static 或private 的方法被自动地final，因为动态联编在上述两种情况下都不能应用。
注-如果将引用类型（即，任何类的类型）的变量标记为final，那么该变量不能指向任何其它对象。但可
能改变对象的内容，因为只有引用本身是final。
5. 抽象类
声明方法的存在而不去实现它的类被叫做抽象类
可以通过关键字abstract 进行标记将类声明为抽象
public abstract class Drawing {
public abstract void drawDot(int x, int y);
public void drawLine(int x1, int y1,
int x2, int y2) {
// draw using the drawDot() method repeatedly.
}
}
一个abstract 类可以包含非抽象方法和变量
不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的
一个实例。不能有抽象构造函数或抽象静态方法。
Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。
6. 接 口
接口是抽象类的变体。
在接口中，所有方法都是抽象的。没有一个有程序体。接口只可以定义static final成员变量。
多继承性可通过实现这样的接口而获得。
句法是：
public interface Transparency {
public static final int OPAQUE=1;
public static final int BITMASK=2;
public static final int TRANSLUCENT=3;
public int getTransparency();
}
instanceof 运算符可以用来决定某对象的类是否实现了接口。
类能实现许多接口。由类实现的接口出现在类声明的末尾以逗号分隔的列表中。
下例表示一个简单的接口和实现它的一个类：
public interface SayHello {
public void printMessage();
}
public class SayHelloImpl implements SayHello {
public void printMessage() {
System.out.println("Hello");
}
}
对于下述情况，接口是有用的：
声明方法，期望一个或更多的类来实现该方法。
揭示一个对象的编程接口，而不揭示类的实际程序体。（当将类的一个包输送到其它开发程序中时它是
非常有用的。）
捕获无关类之间的相似性，而不强迫类关系。
描述“似函数”对象，它可以作为参数被传递到在其它对象上调用的方法中。它们是“函数指针”（用
在C 和C++中）用法的一个安全的替代用法。
7. 高级访问控制
修饰符同类 同包 子类 通用性
公共是 是 是 是
受保护是 是 是
缺省是 是
私有是
8. 降 级
降级就是过时的构造函数和方法调用。
过时的方法和构造函数由具有更标准化的命名规则的方法所取代。
当升迁代码时，用-deprecation 标志来编译代码：
javac -deprecation MyFile.java
9. ==运算符与equals()方法
equals()和==方法决定引用值是否指向同一对象
equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。
10. toString()方法
被用来将一个对象转换成String
被用来将一个基本类型转换成String
11. 内部类
允许一个类定义被放到另一个类定义里
把类在逻辑上组织在一起
可访问它们所嵌套的类的范围
内部类属性
类名称只能用在定义过的范围中，除非用限定的名称。
内部类的名称必须与所嵌套的类不同。
内部类可以被定义在方法中。
任何变量，不论是本地变量还是正式参数，如果变量被标记为final，那么，就可以被内部类中的方
法访问。
内部类可以使用所嵌套类的类和实例变量以及所嵌套的块中的本地变量。
内部类可以被定义为abstract.
属性
只有内部类可以被声明为private 或protected，以便防护它们不受来自外部类的访问。访问保护不
阻止内部类使用其它类的任何成员，只要一个类嵌套另一个。
一个内部类可以作为一个接口，由另一个内部类实现。
被自动地声明为static 的内部类成为顶层类。这些内部类失去了在本地范围和其它内部类中使用数据
或变量的能力。
内部类不能声明任何static 成员；只有顶层类可以声明static 成员。因此，一个需求static 成员的内部类必须使用来自顶层类的成员。
注-内部类有常常被用作创建事件适配器的方便特征。事件适配器将在后面模块中讨论。
12. 包装类
用来将基本数据元素看作对象，包装类可以被用作：
基本数据类型包装类
boolean Boolean
byte Byte
char Char
short Short
int Int
long Long
float Float
double Double
13. 收集API
收集（或容器）是代表一个对象组的单个对象，被认为是它的元素。
收集类Vector,Bits,Stack,Hashtable,LinkedList 等等都被支持。
收集API 包括将对象保持为下述情况的界面：
收集-没有具体顺序的一组对象
设定-没有复制的一组对象
列表-有序对象组，允许复制
14.反射API
第七章 异常
第八章 创建GUIs
//有类的静态方法，称为类方法，可以直接用类名调用
如
class A{
public static void fun(){
……
}
……
}
这个类的方法fun你可以用对象调用，或者也能用类名直接调用
A a = new A();
a.fun();
或者
直接用
A.fun();是可以,不过这个fun()必须是static方法
static方法可以直接 类名.方法名来调用的，但方法内用到的全局变量也必须是static.
Java 中static的作用
我们定义了一个静态的方法名为main，这就意味着告诉Java编译器，我这个方法不需要创建一个此类的对象即可使用。
静态方法 ;
通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。
静态变量
静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，(只要有一个实例改变了这个变量，所有这个类实例中都跟着改变)当然对于final则另当别论了。
static定义的变量初始化会优先于任何其它非static变量，不论其出现的顺序如何。
static的作用
在面向对象的思想中，class是一个虚无的东西，在其它语言中，如PHP ，定义了一个发邮件的类，必须先建一个对象，然后调用这个对象的某个函数来发送邮件。
而在JAVA中，整个程序就是一个对象(everything is Object),
在运行时，是输入: java 文件名
这个时候大家可以想到，class怎么可以直接运行？所以，在main函数中，就必须加 static 静态化main函数？也就是说，加了static函数之后，不需要先建立一个对象，然后再运行这个对象的函数
另外：java的file name为什么必须跟主类名一致呢？ 运行java时的命令： java aa //这里的aa是file name ,如果主类名跟file name不一致，而一个.java文件可以有多个类的，计算机则不知道哪一个的主类，不知道程序应该从哪一个地方开始运行。
熟记JAVA规则：
一个JAVA程序必须有且只有一个主类,主类必须带main函数。主类必须带public关键字,其它类不能带 public关建字。
声明为static的方法的限制.第二条:static方法可以通过类对象的引用来访问非static的属性.（须验证）
int x=10;
String xx=“”+x；穿衣服
int y=Integer.parseInteger(“x”); 脱衣服；
类集概述
Java的类集（Collection）框架使你的程序处理对象组的方法标准化。
类集框架创建的另一项接口Iterator接口。一个迭代程序iterator用于每次访问类集中的的一个元素。
////// 一个java档案可以有很多类别，但只能有一个类能宣告public，其类名与档案名一样。
//////java档案规则 ：第一行（注释不算）package也就是这个档案所在的目录，如果要用到其他类，就要写import 该类别的目录，再来才是类的宣告。（impiort要写在package和class之间）
第一行要寫package也就是這個檔案所放的目錄，如果要用到其他類別，就要寫 import 該類別的目錄，再來才是類別的宣告.
Java檔案中如果要使用其他Java檔案就必須使用import指令，說明要使用的類別在哪個package
例子；
package com.icsc.dpms.test
import java.util.Date;
class FinalTest {
Date d = new Date();
public void showSample() {
d.setYear(2001);
}
}
• 一個.java檔案中可以有很多很多類別或介面
• 只能有一個class可以宣告public，而且檔名一定和類別名稱相同
• 如果這檔案有package，則一定要宣告在第一行 (註解不算)
• 如果這檔案有import，一定要宣告在package和class之間
• import 和 package 宣告適用檔案中所有類別
//抽象類別
抽象類別不能拿來產生物件
抽象類別提供可以從不同的角度去操控物件，也就是使用多型增加彈性和延伸性
abstract class TEST {
}
// final類別
final類別絕對不能繼承
類別前面宣告final意味著此類別不允許有子類別
final class TEST {
}
//內隱類別
類別裡面還可以宣告類別
類別中的類別稱為內隱類別，使用內隱類別的目的是進一步封裝某種種類的行為
class TEST {
class Inner {} //內隱類別
}
//靜態類別
內隱類別可以宣告為靜態類別
宣告靜態類別將無法使用外覆類別的屬性，但可以被直接生成物件 (後面章節會細述)
class TEST {
static class Inner {} //靜態類別
}
//方法总类
一般的方法
產生物件後呼叫使用
一般的方法必須產生物件後才能使用
class A {
void show(){
System.out.println(“ShowTime!”);
}
A a = new A();
a.show(); //必須先產生物件才能呼叫show()方法
靜態的方法
不需產生物件就可以使用
靜態方法可直接使用，也可以產生物件後使用
class A {
static void show(){
System.out.println(“ShowTime!”);
}
}
A.show(); //直接透過類別名稱呼叫show()方法
final的方法
final的方法不允許被改寫
宣告final的方法不能被繼承後改寫
class SuperClass{
public final void showSample() {
System.out.println("One thing.");
}
}
以下是错误的
class SubClass extends SuperClass{
public void showSample() {
System.out.println("Another thing.");
}
}
// final變數
必须初始化，且值不允许被改变；
//介面的定義
一種規範，只要符合規範，就可以使用介面來操控
如何符合規範?
實做介面中所有的方法
//介面的宣告
• 所有方法必定是抽象方法
public abstract (有沒有寫都可以)
• 所有的欄位必定是
public static final (有沒有寫都可以)
• 介面本身可以繼承一個或多個介面
• 介面不能實作介面或類別
//介面的實作
介面是提供類別可以擴充實作的功能，介面和類別很像，只不過介面中只能有常數和抽象方法。
介面的實作:
Class 类别名 implements 介面1，介面2{
}
// Java 記憶體模型運作
Stack 執行堆疊
Heap 物件存放處
GC什時候執行，會不會不會把我的物件清掉?
// hashCode()
1.特定物件的hashCode一定不能變
2.碰撞發生機率越小越好
3.算hashCode速度越快越好
4.hashCode一樣不表示相同物件
5.相同物件的hashCode一定一樣
何謂建構子(即构造函数)
每個類別一定都有建構子，不能產生物件而沒有執行建構子
當類別有老爸時(父類別)，會先生出老爸才會有子類別物件
建構子必須滿足下列條件
建構子也是一種方法
和類別名稱一模一樣
可以傳入引數，沒有回傳型別
每個類別一定都至少有一個建構子
//預設建構子
Q.類別中如果沒有宣告建構子?
A.編譯器時會自動加上一個空建構子，並且空建構子裡面會填上 super();
Q.類別中如果有宣告建構子?
A.編譯器時會自動建構子裡面會填上 super();
Q.類別中如果有宣告建構子有引數呢?
A.編譯器時會自動在建構子裡面會填上 super();
Q.類別中宣告建構子有引數而且也寫super()
A.編譯器時什麼事情都不會做
建構子可以透過this關鍵字來呼叫另外一個建構子，但如果使用this，一定要在第一行呼叫。
因為建構子一定要先執行如果你用了this,那編譯器不會加上super
當父類別沒有空建構子時，但却有自建其他建构子…,建立子类别时，先呼叫super()父类别的空建构子，而父类别没有空建构子。会出现编译错误。
//生成物件的啟動順序
一 載入類別
1.初始化static敘述(欄位和區塊)
二 生成物件
1.初始化欄位和區塊
2. 呼叫建構子
//生成物件的啟動順序(有父類別)
一 載入類別 - 初始化static敘述(欄位和區塊)
先載入父類別,再載入本身類別!!!
二 生成物件 - 先產生父類別物件
1. 初始化欄位和區塊
2. 呼叫建構子
1.String的方法
public char charAt(int index) 取某位字符；
public String concat(String s) 串后面串接字串s；
public boolean equalsIgnoreCase(String s) 比较是否相同忽略大小写；
public int length() 取长度；
public String replace(char old, char new) 代替；
public String substring(int begin) 从第begin个字符开始截取串；
public String substring(int begin, int end) 从第begin个字符开始截取串至第end不包含end；
public String toLowerCase() 将串转成小写；
public String toUpperCase()将串转成大写；
public String trim() 去除串两边的空白，不包含串中间的；
public String toString() 将对象转成串；
2.Wrapper 类别
Java中的八个基本类型因为不是对象类型，因此不能放入Collection容器。这八个基本类型分别对应八个类，包装基本类型后就可以放入Collection容器。
包装方法；
Integer i1 = new Integer(42);
Integer i2 = new Integer("42");
写基本类型或字符串都可以，只有char类型不能写字符串形式的。
Character ch=new Character（‘A’）；
去包装方法；
例如将某字符串转成基本类型
double d4 = Double.parseDouble("3.14");
long L2 = Long.parseLong("101010", 2);（其中2是指定字符串进制，只有Double和Float不能使用）
3.collection的用法；
Map map=new HashMap();
map.put("aaa","10000");
map.put("bbb","10000");
//map.get("aaa");
System.out.println(map.get("aaa"));
Iterator sss=map.keySet().iterator();
while(sss.hasNext()){
System.out.println(sss.next());
}
LinkedList y = new LinkedList();
y.add("A");
y.add("B");
//System.out.println(y.add("A"));
String o = (String) y.get(1);
System.out.println(o);
//System.out.println(y.add("A"));
/*Collection c = new LinkedList();
c.add("a");
c.add("c");
c.add("b");
c.add("a");
Iterator it = c.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}*/
Collection c = new ArrayList();
c.add("a");
c.add("c");
c.add("b");
c.add("a");
Iterator it = c.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
///////静态的方法可以直接使用，也可以产生对象后使用。
//////声明为final的方法不允许继承类修改。声明为final的基本类型变量不可以被修改；
例如 final int num=20； 不能 int=30；
声明为final的实体变量其指向不能改变。但其中的基本类型变量的值可改变。
例如 final int[] atrr=new
//////java中只允许单一的继承。但不限制继承深度。
////方法名称一样，引入参数不同叫多载。（overload）
////方法名字参数都一样，在子类中的实现方式不一样叫覆写（override）一定有继承
//累前面有两种修饰因子：存取修饰和非存取修饰
其中存取修饰因子包含两种：声明为public或不用声明。
非存取修饰因子包含三种：final不允许继承，abstract一定要继承，strictfp很少用到。
//方法的存取修飾子
public 開放,所有類別都可以盡情使用
protected 保護，同目錄或子類別才能使用
default 內定，只有同目錄才能使用
private 私有，只有類別本身才能用
//方法的非存取修飾子
synchronized
abstract
final
static
strictfp , native
//声明为静态static的方法不能调用此方法外的非静态static变量或方法；
//对象间的关系，has-a，is-a,对应override和overload
//所有的 Java類別，如果沒有寫extends某類別，編譯器都會自動加上nds Object。
Object所擁有的方法，就是所有Java類別擁有的方法!
boolean equals(Object obj) 判断两对象是否相同
当比较的是两个基本类型时是比较他们的值是否相等。
当比较的是两个对象时是比较他们的引用是否指向相同的对象。
如果两不同对象属性相同即认定他们相等，要用boolean equals(Object obj)判断时需要在改写此函数功能。
例如；
class Ball {
int num;
Ball(int x){
num = x;
}
public boolean equals(Object obj){
Ball ball = (Ball)obj;
return ball.num == num;
}
}
其中Ball ball = (Ball)obj;
return ball.num == num;
等同于 return obj instances of ball&&((Ball)obj).num==this.numl;
equals() 条约的一致性；所有指向同对象的引用都会随着对象而改变，这改变都会一致。
equals() 条约 里null就是flase
所有和null比较的引用永远都是false。
equals()改写：java已经将八个基本类型和String类型改写了equals()方法，所以可以直接使用。
String toString() 将对象转成字串
失败例子：
//球的类别
class Ball {
int num;
Ball(int x){
num = x;
}
}
//产生一颗球并显示号码
class Main {
public static void main(String[] q){
Ball ball = new Ball(37);
System.out.println(ball);
}
}
结果显示Ball@107077e
Object的toString()会显示该类别和内存位置；
成功例子；
改写toString函数；
class Ball {
int num;
Ball(int x){
num = x;
}
public String toString(){
return “”+num;
}
hashCoce的应用：两个不同的对象hashCoce有可能一样；这是会发生碰撞，发生碰撞后会影响查找速度。
找人例子；找出蔡依林并显示位置
class Human {
String name;
Human(String name){
this.name = name;
}
public boolean equals(Object obj){
Human h=(Human)obj;
return h.name==name;
}
}
public class FindOut {
public int find(Object[] obj,Human h){
//...
for(int pos=0;pos<obj.length;pos++){
if(obj[pos].equals(h)){
return pos+1;
}
}
return -1;
}
public static void main(String[] args) {
Object[] obj = {
new Human("蔡依琳"),
new Human("倫斯菲"),
new Human("趙玉柱"),
new Human("賓拉登"),
new Human("楊承琳")};
FindOut fo = new FindOut();
int pos = fo.find(obj,new Human("蔡依琳"));
//int pos = fo.find(obj,new Human("于力"));
System.out.println("找到了! 在第"+pos+"個位置");
}
}
对属性名字做hashCode；
查找函数直接写成以下形式；
int findOut(Object[] obj,Human h){
return h.hashCode();
}
全部函数；
class Human {
String name;
Human(String name){
this.name = name;
}
public int hashCode(){
return name.hashCode()%5;
}
}
public class FindOut {
public int find(Object[] obj,Human h){
return h.hashCode();
}
public static void main(String[] args) {
Object[] obj = {
new Human("趙玉柱"),
new Human("kk"),
new Human("張惠妹"),
new Human("倫思斐"),
new Human("蔡依琳")};
FindOut fo = new FindOut();
for(int i=0;i<5;i++){
System.err.print(obj[i].hashCode());
}
int pos = fo.find(obj,new Human("kk"));
System.out.println("找到了! 在第"+pos+"個位置");
}
}
数字过滤程序：
package 数字过滤;
public class NumFilter {
String back="";
public String toString(){
return back;
}
/*void append(String msg){
for(int i=0;i<msg.length();i++){
if(msg.charAt(i)>='0'&&msg.charAt(i)<='9')
{back=back+msg.charAt(i);
}
}*/
public NumFilter filterNum(String msg){
for(int i=0;i<msg.length();i++){
if(msg.charAt(i)>='0'&&msg.charAt(i)<='9')
{back=back+msg.charAt(i);
}
//return this;
}
return this;
}
public NumFilter filterAlphabet(String msg){
for(int i=0;i<msg.length();i++){
if(msg.charAt(i)>='a'&&msg.charAt(i)<='z')
{back=back+msg.charAt(i);
}
//return this;
}
return this;
}
//class MX{
public static void main (String[] pass){
NumFilter nf = new NumFilter ();
nf.filterNum("1sa24da")
.filterAlphabet ("dj2jdf4323kj");
//nf.append("1sa24da");
//nf.append("dj2jdf4323kj");
System.out.println(nf); //顯示12424323
}
}
战斗机装甲车攻击程序（应用了接口的方法）
//接口的应用
interface gongji{
void fire();
}
//声明飞机类
class feiji{
void takeOff(){
}
void landing(){
}
}
// 声明战斗机类继承飞机类
class zhandou extends feiji implements gongji{
public void fire(){
System.out.println("fire");
}
}
//声明车子类
class chezi{
void forward(){
}
void backward(){
}
}
//声明装甲车继承车子类
class zhuangjia extends chezi implements gongji{
public void fire(){
System.out.println("fire");
}
}
class start{
public static void main (String[] pass){
//start start1=new start();
//声明数组包含两架飞机和一个装甲车
gongji [] eagle={new zhandou(),new zhandou(),new zhuangjia()};
//zhandou zhandou1=new zhandou();
//zhandou zhandou2=new zhandou();
//zhuangjia zhuangjia1=new zhuangjia();
//zhandou1.fire();
//zhandou2.fire();
//zhuangjia1.fire();
//发动攻击
eagle[0].fire();
eagle[1].fire();
eagle[2].fire();
}
}
例外处理程序；
public class exception{
static void a()throws Exception{
//try{
b();
//}catch(Exception e){
// System.out.println("可以了");
//}
}
static void b() throws Exception{
throw new RuntimeException();
}
public static void main(String[] args) {
try{
a();
}catch(Exception e){
System.out.println("处理了");
}
}
}
对象生成顺序程序；
class Bar {
static {System.out.println("1");}
{System.out.println("3");}
private int x = getValue();
public Bar(){
System.out.println("5");
}
public static int getValue(){
System.out.println("4");
return 1;
}
}
class Foo extends Bar{
static {System.out.println("2");}
{System.out.println("6");}
private int x = getValue();
public Foo(){
System.out.println("8");
}
public static int getValue(){
System.out.println("7");
return 1;
}
public static void main(String[] args){
Foo f = new Foo();
}
}