java基础知识大全(必看经典)

第一讲 Java语言入门

1.1 Java的特点

1.1.1面向对象：

• 与C++相比，JAVA是纯的面向对象的语言

C++为了向下兼容C，保留了很多C里面的特性，而C，众所周知是面向过程的语言，这就使C++成为一个"混血儿"。而JAVA语法中取消了C＋＋里为兼容C所保留的特性，如取消了头文件、指针算法、结构、单元等。

1.1.2可移植（平台无关性）：

• 生成中间字节码指令

与其他编程语言不同，Java并不生成可执行文件（.exe文件），而是生成一种中间字节码文件（.class文件）。任何操作系统，只要装有Java虚拟机（JVM），就可以解释并执行这个中间字节码文件。这正是Java实现可移植的机制。

• 原始数据类型存储方法固定，避开移植时的问题

Java的原始数据类型的大小是固定的。比如，在任何机器上，整型都是32位，而C++里整型是依赖于目标机器的，对16位处理器（比如8086），整数用两个字节表示；在像Sun SPARC这样的32位处理器中，整数用4个字节表示。在Intel Pentium处理器上，整数类型由具体的操作系统决定：对于DOS和Win32来说，整数是2个字节；对于Windows 9x 、NT和2000，整数是4个字节。当然，使整数类型平台无关之后，性能必然有所下降，但就Java来说，这个代价是值得的。Java的字符串，则采用标准的Unicode格式保存。可以说，没有这个特性，Java的可移植性也不可能实现。

1.1.3简单

• JAVA在语法上与C++类似

JAVA的语法与C++很接近，有过C或者C＋＋编程经验的程序员很容易就可以学会JAVA语法；

• 取消了C++的一些复杂而低效的特性比如：用接口技术代替了C++的多重继承。C＋＋中，一个类允许有多个超类，这个特性叫做"多重继承"，多重继承使得编译器非常复杂且效率不高；JAVA的类只允许有一个超类，而用接口（Interface）技术实现与C＋＋的多继承相类似的功能

其它被取消的特性包括：虚拟基础类、运算符过载等

• JAVA的基本解释器和类支持模块大概仅40K

即使加入基本的标准库和支持线程的模块，也才220K左右。与GUI（图形用户界面）相比，

明显小很多

1.1.4健壮

• 取消了指针算法

C的最关键的一个特性是它的强大指针算法，比如可以用指针访问字符串、数组甚至文件，很容易产生指针溢出，意外地改写内存和损毁数据。JAVA里有一个指针模型，对于普通的任务，如访问字符串、数组，根本不用指针，而一旦需要，比如访问对象、文件时，也可以获得指针的强大能力，但JAVA同时有高度的指针安全保障，用户永远不可能访问一个坏掉的指针、不可能造成内存分配错误，也用不着专门提防可能出现的内存漏洞。

1.1.5多线程

• 强大的多线程能力

多线程可以使程序有更好的交互性和实时性，并可以最大限度地利用多处理器系统。JAVA有着强大的多线程处理能力，因为各主流操作系统平台在线程的实施方面有重大的差异，所以JAVA为不同的操作系统实现了专门的多线程机制。在这点上来说，JAVA没有做到平台无关。

a

1.2 Java简史

• 首次亮相--1995年5月

Java技术起先是作为小型的计算机语言，用于消费类设备，比如有线电视交换盒等。因为这些设备的功能和内存均不足以运行大程序，所以程序要尽可能小；另外，由于不同的厂商可能选用不同的CPU，所以要求这种语言不能受限于任何一种独立的体系结构。1995年5月23日召开的SunWorld

'95大会上，一种全新的浏览器（今天的HotJava的前身）亮相，标志着Java的诞生。

• 开始流行--1996年1月

那时网景公司决定在Netscape2.0加入对Java的支持，Netscape2.0在1996年1月发布，从这一版本开始，所有Netscape浏览器均支持Java。注册了Java使用许可证的还有IBM、Symantec、Inprise和其他许多公司。就连微软，也加入了这一行列（尽管他们支持的Java和标准的Java稍有不同）。

• SUN的第一个JAVA版本--1996年初

Sun公司于1996年初发布了Java 1.02，遗憾的是，Java1.02还未摆脱其小型语言的影子，只适合用来做诸如网页上一个随机移动的文字之类的工作，并不适合用来做正规的程序开发。Java1.02作为一种正规的编程语言，可以说，准备得很不充分。

• 成熟--1998年

1998年12月，Java1.2问世了。它是一个功能全面的、具有高度扩展能力的新版本。3天后，Java1.2被改进成Java2，向"一次编写，到处运行"的目标前进了一大步。

• 现状

现在最新的Java版本是JDK1.4，它是一个测试版，稳定的正式版是JDK1.3。用户可以到/products/免费下载。微软在它的最新浏览器IE6.0中不再支持Java，为Java的发展带来阴影。

1.3 JDK的安装与编程环境的设定

1.3.1 Java程序的开发过程

经典的Java工具包是JDK。尽管可以用任何文本编辑器，如记事本，都可以直接编写Java程序然后用JDK的命令编译和运行，为了调试方便，也为了初学者容易上手，本教程课件将使用一个叫JPadPro的Java编写工具来调用JDK的工具。用户可以到下载这个工具。

1.3.2 JDK的安装

1.3.3安装运行之后，应该首先设置JDK工具包所在的路径。

菜单栏的JDK-〉select JDK Directory-〉选择刚才安装的JDK路径-〉OK。

1.3.4 新建一个project

菜单栏的File->new projects->选择路径, 输入project的名字。

1.4两个简单的程序示例

1.4.1 Java 应用程序：

• 编写

新建一个.java文件。File-〉new-〉java file-〉输入一个名字：Hello-〉点creat file.出现了一个空的java文件。

• 编译

JDK-〉compile 或者点击如演示所示的按钮。实际上是执行JDK工具包里的命令，与javac G:是等价的。便已完成之后在同一个文件夹就会有一个同名的.class文件。

• 看编译结果，改错

错误举例：少写一个分号；录入错误；

• 运行

JDK-〉Run classes-〉选择要运行的class，输入参数（这里，没有参数）或者点击如演示所示的按钮。

一个有参数的例子

• 看运行结果

1.4.2 Java Applet:

新建一个Java Applet文件。File-〉new-〉java Applet-〉输入一个名字：StarterApplet-〉出现了一个空的java文件和一个Html文件。

• 编译

JDK-〉compile 或者点击如演示所示的按钮。实际上是执行JDK工具包里的命令，与javac G:java2jiaochengexampleteach1 是等价的。

注意 不要隐藏文件的扩展名，否则给编译时带来麻烦！可以在工

工具/文件夹先项/查看/中修改！！

•

•

看编译结果，改错

运行

JDK-〉Test Applet-〉选择要运行的class，输入参数（这里，没有参数）

或者点击如演示所示的按钮

或者直接双击Html文件。

• 看运行结果

1.5 如果获得帮助

1.5.1 下载帮助

JDK并不包含帮助文件，需要到网站上下载，里面有示例和说明。

/javadoc/，下载下来时候，双击安装。

1.5.2 使用帮助

敲入想查找的关键字，按回车。

1.6 编程的一些约定

注意：在一个原文件中只能有一个public 类！且文件名与public类同名！

1.6.1命名规则

类名与文件名应该一致，否则编译出错。比如，class Hello的文件名应该是

类名首字母大写，每个单词开头大写，其他用小写。比如：, 。

变量名用第一个单词用小写字母，第二个以后的单词首字母大写。比如：int myAge;

方法的名字第一个单词用小写字母，第二个以后的单词首字母大写，比如：getMyAge()；

1.6.2 注释

/*

* Here is a block comment.

*/

表示完整的一段注释；

if (condition) {

/* Handle the condition. */

...

}

表示注释该行以下部分

if (a == 2) {

return TRUE; /* special case */

} else {

return isPrime(a); // works only for odd a

}

注释一行

1.6.3 分行

如果一行太长需要换行。比如：

someMethod(longExpression1, longExpression2, longExpression3,

longExpression4, longExpression5);

var = someMethod1(longExpression1,

someMethod2(longExpression2,

longExpression3));

var = someMethod1(longExpression1, someMethod2(longExpression2,

longExpression3));

讲演计划

第三讲 语句

Java的语句可以分为以下4种：

•

•

•

表达式语句

方法调用语句

控制语句

3.1表达式语句

一个表达式加上一个分号就构成了一个语句。分号表示一个语句的结束，缺少分号，编译将出错。最典型的表达式语句是赋值语句。

比如：int x;

x=23;

3.2方法调用语句

调用一个类的对象的方法：类名（或对象名）.方法名(参数列表)。

比如：

n("Hello").

如果方法有返回值，还可以把返回值赋值给一个变量。比如：

String s="Hello",

int len;

len=();

3.3控制语句

Java语言的控制语句有2种：条件语句、循环语句。

条件语句：

条件语句有两种：if语句和switch语句。

• if语句：

if (条件)

{代码块1}

else

{代码块2}

如果条件为真，则执行代码块1，否则执行代码块2。

else部分是可选的，也就是说，可以没有else。

如果有else，则与最近的if结合：

• switch语句

switch语句是多分支的开关语句，它的一般格式定义如下：

switch(表达式)

{

case 常量值1：

{代码块1}

break;

case 常量值2：

{代码块2}

break;

……

default:

{代码块}

}

语句中表达式的值必须是整型或者字符型；常量值1到常量值n必须也是整型或者字符型。switch语句首先计算表达式的值，如果表达式的值和某个case后面的常量值相同，就执行该case里的若干个语句直到break语句为止。如果没有一个常量与表达式的值相同，则执行default后面的若干个语句。default是可有可无的，如果它不存在，并且所有的常量值都和表达式的值不相同，那么switch语句就不会进行任何处理。

需要注意的是，在switch同一个语句中，case后的常量值必须互不相同。

3.3控制语句

Java语言的控制语句有2种：条件语句、循环语句。

条件语句：

条件语句有两种：if语句和switch语句。

• if语句：

if (条件)

{代码块1}

else

{代码块2}

如果条件为真，则执行代码块1，否则执行代码块2。

else部分是可选的，也就是说，可以没有else。

如果有else，则与最近的if结合：

• switch语句

switch语句是多分支的开关语句，它的一般格式定义如下：

switch(表达式)

{

case 常量值1：

{代码块1}

break;

case 常量值2：

{代码块2}

break;

……

default:

{代码块}

}

语句中表达式的值必须是整型或者字符型；常量值1到常量值n必须也是整型或者字符型。switch语句首先计算表达式的值，如果表达式的值和某个case后面的常量值相同，就执行该case里的若干个语句直到break语句为止。如果没有一个常量与表达式的值相同，则执行default后面的若干个语句。default是可有可无的，如果它不存在，并且所有的常量值都和表达式的值不相同，那么switch语句就不会进行任何处理。

需要注意的是，在switch同一个语句中，case后的常量值必须互不相同。

循环语句:

循环语句，顾名思义，是反复执行的语句。比如，计算100的阶乘，1*2*3*...*100，就需要用到循环语句，不然，就要写一百遍乘法。循环语句需要特别小心，很容易陷入死循环，所以循环体的代码块里需要有能使循环结束的语句。Java有三种循环语句：while语句，do-while语句和for语句。

• while语句：

while语句的格式是：

while(条件)

{代码块}

当条件成立的时候，执行代码块，再检查条件，如果还成立，再执行代码块，……直到条件不成立。

比如，计算10的阶乘：

• do-while语句

do-while语句的格式是：

do{

代码块

}while(条件)

do-while语句和while语句的区别在于：while语句先检查条件，如果条件不成立，则不进入循环体；do-while语句先执行循环体的代码，再检查条件，如果条件成立，则在此执行循环体的代码。所以，do-while语句至少要执行一遍循环体的代码块。

比如，计算10的阶乘：

• for语句

for语句是Java语言中用得最多的循环语句。它的格式如下：

for(表达式1，表达式2，表达式3)

{代码块}

其中，表达式1完成变量的初始化，表达式2时布尔类型的表达式，是循环条件，表达式3是党执行了一遍循环之后，修改控制循环的变量值。

for语句的执行过程是这样的：首先计算表达式1，完成必要的初始化工作；然后判断表达式2的值，如果表达式的值为true，则执行循环体；如果为false，则跳出循环。执行完循环体之后紧接着计算表达式3，以便改变循环条件，这样一轮循环就结束了。第二轮循环从计算表达式开始，如果表达式的值仍为true，则继续循环；否则循环结束，执行for语句后面的语句。

比如，计算10的阶乘：

• 嵌套循环

经常可以遇到嵌套循环的例子。所谓嵌套循环，是指一个循环体里还有一个或者更多个循环。比如计算10以内的阶乘之和，或者求50以内的素数，就需要用到嵌套循环。我们以求50以内的素数为例，说明嵌套循环的用法；求10以内的阶乘之和，将留作作业。

循环语句里的break语句和continue语句：

在循环体中，遇到break语句，那么整个循环语句就结束；如果遇到continue语句，那么本次循环就结束，就是说，不再执行本次循环中continue语句后面的语句，而是转入下一次循环。

3.5 变量的作用域

变量是由作用域的。所谓变量的作用域，是指一个变量在什么地方生效。总的来说，变量的作用域是声明它的块。所谓块，是指用一对花括号包围起来的任意数量的Java语句。变量只在声明它的块中有效，在这块以外，变量是无效的。

然而，不可以在两个嵌套的块中声明两个完全同名的变量。

注意，在C++中，这是允许的，内部定义会掩盖外部定义。这很容易造成错误，所以Java不允许这样做。

小结

这一讲，我们主要学习了Java的语句，主要是流程控制语句，包括条件语句和循环语句等。语句是程序的基本组成部分，是我们进一步学习Java的基础。希望同学们切实掌握好这部分内容，为我们的进一步学习打下坚实的基础。

习题

1.

编一个计算1!+2!+…+10!的应用程序

应用程序计算100以内的全部质数

2.

一个数如果恰好等于它的因子之和，这个数就称为“完数”，编写一个应用程序，求1000之内的所有完数。

3.

求45和的最大公约数和最小公倍数。

第四讲 数组和字符串

4.1什么是数组？为什么要数组？

除了基本数据类型，Java还提供一种导出类型：数组。数组是相同类型的数据按顺序组成的一种复合数据类型，通过数组名和下标，可以使用数组中的数据。下标从0开始。数组是所有编程语言中常用的数据结构。

为什么要数组呢？我们来举一个例子。假设我们需要表示一个班50个人的数学成绩，要求求出平均成绩。如果没有数组，我们需要用前面学过的声明变量的方法，声明50个变量，写50次加法运算！数组可以大大地简化类似的问题！我们只要声明一个长度为50的整型数组，结合上一讲我们学过的循环语句，就可以很方便地解决这个问题！

在以前的编程语言比如C或者C++中，字符串也使用数组来表示的：字符串是字符数组！所以

字符串与数组有着天然的联系。但是在Java中，提供了一种更方便的表示字符串的方法：用一个String类来表示。类是面向对象的语言特有的概念，对于初次接触面向对象技术的人来说，比较难理解。所以，这一讲，我们将学习表示字符串的String类，也对类的使用有一个粗略的了解，作为下一讲详细学习类的准备。

需要指出的是，C语言里的其他两种导出类型：结构体和共用体，在Java里已经被取消。

下面，我们来学习数组和字符串。

4.2数组的声明、创建和初始化

1.

数组的声明：

声明数组，包括声明数组的名字、数组包含的元素的数据类型。数组可以一维的，也可以是二维或者多维的。举例来说：一个班有50个人，我们用一个长度为50的一维数组表示；如果要表示每个同学的五门高考成绩，那我们就需要用一个第一维长度为50，第二维长度为5的二维数组。

声明一维数组有两种格式：

•

•

数组元素类型 数组名[ ]；

数组元素类型[ ] 数组名；

比如：int student[ ]; 或者： int[ ] student;

类似地，声明二维数组有两种格式：

•

•

数组元素类型 数组名[ ][ ]；

数组元素类型[ ][ ] 数组名；

比如：int score[ ][ ]; 或者： int[ ][ ] score;

下面，我们主要以一维数组为例，学习数组的用法。

2.

数组的创建：

声明数组仅仅给出了数组名字和元素的数据类型，想要真正使用数组还必须为数组分配内存空间，也就是创建数组。在为数组分配内存空间时必须指明数组的长度。为数组分配内存空间的格式如下：

• 数组名 = new 数组元素的类型 [ 数组的长度 ]

例如：student = new int [50]；

score = new int [50] [4]；

事实上，数组的声明和创建可以一起完成，比如：

int student [ ] = new int [50];

一旦数组被创建，数组的大小就不能改变。如果在程序运行期间，需要对数组的大小进行扩展，通常需要使用另一种数据对象：Vector。有关向量和扩展数组，有兴趣的同学可以在Java帮助中查找Vector的帮助。

student数组创建之后，其内存模式如图：

3.

数组的初始化：

创建数组后，系统会给每个元素一个默认的值，比如，整型数组的默认值是0。

我们也可以在声明数组的同时给数组一个初始值，我们称之为初始化。

int num [ ] = {2, 4, 4, 1}。

这个初始化动作相当于：

int num [ ] = new int [ 4];

num [0]=2; num [1]=5; num [2]=4; num [3]=1;

4.3数组的使用

1.

数组的访问

前面我们已经看到，数组通过下标访问数组元素，比如：student [ 0 ]=70，student [49]=87等。注意，下标从0开始，如果数组长度为n，则下标是0 ~ n -1，如果使用n或者以上的元素，将

会发生数组溢出异常。比如：student[ 50 ] = 79，虽然编译的时候能通过，程序运行时将中止。

二维数组的使用与之类似。

2.

数组的复制

可以把一个数组变量复制给另一个，但两个变量引用的都会是同一个内存空间，所以改变一个数组的值，另一个数组变量的值也会改变。

比如：

int num [ ] = {2, 3, 5, 1}；

int numcopy[ ]=num;

numcopy[2 ]=5;

现在，num[2]也变成了5。

如果真的想把一个数组的所有值都复制到另一个数组中，就需要采用System . arrarycopy()方法：System . arrarycopy ( num, 0, numcopy, 0, 4)。这样，num和numcopy将指向不同的内存空间，numcopy的值的改变，不会在影响num。有兴趣的同学可以参考帮助文件。

4.4字符串

前面已经说过：Java使用包中的String类来表示字符串，尽管我们可以用字符数组来实现类似的功能。关于类的详细知识，我们下一讲将会讲到。由于类是面向对象编程语言最核心的概念，学习起来有些难度，我们在这里先通过String类对类的概念有一个粗略的了解，以使我们下面的学习更顺利一些。

字符串，顾名思义，就是一串字符。比如："student100", "China"等。用一对双引号表示字符串。我们也可以把字符串看成字符数组（事实上，C就是把字符串当作字符数组来处理），但是把它视为类更方便一些。为什么？我们下面马上会看到。

• 字符串的声明、创建

字符串声明的格式是： String 字符串名

比如：String s;

字符串的创建格式：字符串名 = new String（字符串常量）或者 字符串名=字符串常量

比如：s = new String ( "student" ); 或者：s = "student"；

声明和创建可以一步完成，比如：String s = new String ( "student" ); 或者 String s =

"student";

大家是不是觉得：String这个类的声明，跟前面我们学过的基本数据类型的声明的格式是一样的，比如：整型的声明：int n; 比较一下： String s;

事实上，

类型 变量名

这种格式是类的声明的一般格式，你可以把类当作基本数据类型一样来声明。

另一方面，

变量名= new 类名（参数列表）；比如 s = new String ( "student" );

这是类的一般创建格式。

4.5与字符串有关的操作

• 字符串的长度

length()方法：

String s = "student";

int len=();

需要指出的是，()这种调用方法，是面向对象编程语言特有的方法，我们把s叫做String类的对象，就像int n，我们把n叫做整型变量一样；把length()叫做String类的方法。下面我们可以看到，String类的方法，都是通过 对象名.方法名（）这种方式调用的。

• 取子串

String s = "I am a Chinese";

String subs;

subs = ing (7);

• 字符串的比较

String tom = "my name is tom";

String jane = "my name is jane";

(jane)；返回false。表示不相等

eTo(jane)，返回一个负整数，因为第一个不相等的字符t和j相比，t在j的后面；如果返回0，表示相等；如果返回一个正整数，表示tom和jane第一个不相等的字符，tom的在jane的前面。

注意，不要用tom= =jane判断两个字符串是否相等，因为这样的话比较的是它们在内存中的地址是否相同，而不是我们所希望的比较字符串的内容是否相同。

• 字符串连接

String s = " I am";

String s2 = "a Chinese";

String s4, s4;

s4 = s+s2;

s4=s + 24;

整数型24将会自动转换为字符串。

• 字符串检索

字符串检索是指判断一个字符串是否包含某一个字符或者子字符串，如果有，返回它的位置，如果没有，返回一个负数。

String s = "I am a Chinese";

f("Chinese" )， 返回7；

f('a'); 返回2；

• 字符串转换为数值

如果一个字符串是一串数字，可以把它转换成相应的数值。

o 转换为整型：

String s = "21";

int x; x= nt (s);

o 转换为浮点型

String s = "22.124";

float f; f = f(s).floatValue()；

o 当然，也可以把整数或者浮点数转换为字符串类型：

String s;

int n = 24;

s = f ( n )；

o 其他

与字符串有关的方法还有很多，我们不可能一一讲解。前面我们说过，我们要学会使用帮助。我们查找关于String的帮助，就可以看到，有关于String的所有方法的详细讲解。希望同学们可以学会使用帮助。

小结

这一讲，我们学习了数组的一些知识，并通过String类，一方面学习了字符串的使用，另一方面先对类的一些概念和用法，比如类的方法调用，有了一些粗略的了解。

数组是我们经常要用到的数据结构，它是一种导出型的数据结构，对我们处理大规模的数据，有很大帮助。

前面我们说，用String类表示字符串，比我们自己用字符数组来做更方便。因为String类为我们提供了很多现成的可以直接使用的对字符串的操作方法。比如substring( )，equals( )等方法。如果我们要用字符数组来完成与substring类似的功能，就只能自己把子串的每一个字符复制到另外一个字符数组中；与equals()类似的功能，就只能自己一个一个字符地检查两个字符船是否相等。提供对自己的成员数据的完整的操作方法，也就是把数据和对数据的操作封装起来，是类的最大的好处。如果现在还不能理解这句话，不要紧，我们现在只需要知道：使用String类这种方法，非常方便。

习题

1.

声明一个数组，存一个学生的五门成绩。求该学生总成绩、平均成绩。

2.

将一个数组中的值按逆序重新存放，例如，原来顺序为：9，5，7，4，8，要求改为：8，4，7，5，9。

3.

编写一个应用程序，连接两个字符串：“I am”和“a student”，并求出第7个字符是什么？找出“am”在该字符串中的位置，最后把所有字符都变成大写字符。

4.

统计一个字符串中字母、空格和数字的个数。

第五讲：类、对象和接口（1）

5.1什么是类

上一讲我们使用了一个String类，我们说过：类把一类对象的成员函数和方法封装起来，使用起来很方便。那么，什么是类呢？要理解类，我们先来了解"对象"的概念，因为类就是用来创建对象的模板，它包含了被创建的对象的状态描述和方法定义。

我们可以把长虹牌电视机看成是一个对象。我们不必关心电视机里面的集成电路是怎样的，也不用关心电视机的显像管的工作原理，我们只需要知道电视机的遥控器上提供了对这台电视机的什么操作，比如选台、调节色彩、声音等。这样，我们虽然不知道电视机内部是怎么工作的，但我们可以使用这台电视机。听起来这跟编程没什么关系，但面向对象的思想正是与它类似：对象，对外只提供操作该对象的方法，内部的实现对外是隐藏的。我们把这种技术叫做数据隐藏。这样，程序员不必了解一个对象内部是怎么实现的，但可以很方便地使用这个对象。

类，就是对象的模板。比如，电视机是一个类，而某一台电视机就是这个类的一个对象，也叫一个实例。

我们前面使用的String类，虽然我们不知道，也不必知道里面的实现细节，但我们只要知道他的操作方法，就可以很方便地使用它。这样，对别的程序员编写的程序，我们可以很方便地拿来使用，从而提高软件的复用程度和编程的效率。

比如，我们构造一个类：TV，然后对外提供一些对它的操作方法，选台 selectChannel( )等。然后用这个类创建一个对象：TV kongKai；然后就可以这样操作这台电视： Channel。

类的另一个特性，也是它的一个大好处，是继承。继承的概念类似于这样一种表达：电视是一种电器。如果我们有一个电器类，那么，我们说，电视机类继承了电器类。继承有什么好处呢？设想电器类有一些属性，比如工作电压，功率，有些一些方法，比如：打开 open( )， 关闭：close( )。这时候，如果电视类继承了电器类，电视类就自动拥有了电器类的这些属性和方法，而不用再自己重写一遍（当然，如果想重写，也可以，我们把这种技术叫做重载）。这样做有什么好处呢？最明显的好处就是减轻编程的工作量。假设我们有令一个类：VCD类，它也继承了电器类，对于打开关闭等，同样不用重新编写。

好了，既然面向对象的方法有这么多好处，我们下面就来学习类和对象的一些基本知识。

5.2 一个例子

下面是一个完整的类的例子，我们用这个例子详细讲解类的一些用法。

class Employee

{

private String name;

private double salary;

private int hireYear;

private static String company=new String("IBM");

public Employee(String n, double s, int d)

{ name = n;

salary = s;

hireYear = d;

}

public void print()

{ n(name + " " + salary + " " + getHireYear() + " "+

getCompany());

return;

}

public void raiseSalary(double byPercent)

{ salary *= 1 + byPercent / 100;

}

public void raiseSalary(int byAbsolute)

{ salary +=byAbsolute;

}

public int getHireYear()

{ return hireYear;

}

public static String getCompany()

{

return company;

}

}

为了测试这个类，我们写了一个测试程序：

package teach4;

public class EmployeeTest

{ public static void main(String[] args)

{ Employee emp = new Employee ("Tony Tester", 38000, 1990);

();

alary(5.0D);

();

int raise=1000;

alary(raise);

();

}

}

5.3 类的结构

class Employee { } 表示一个类的声明，其中，class是关键字，Employee是类名。在一对大括号中的内容，我们叫做类体，是这个类的实现部分。

前面我们说过，类把数据和在数据上的操作方法封装起来，所以，类体中有两部分，一部分是数据，另一部分是方法。

数据部分是：

private String name;

private double salary;

private int hireDay;

分别是String类型的name，代表该员工的姓名，double类型的salary，代表该员工的薪水；int类型的hireDay，代表该员工的雇佣年份。

private是一个关键字，是私有的意思，表明这些数据，只能被类里面的方法访问，外部程序是不能直接访问这些数据的。这正是类的一个好处：对外隐藏数据。我们建议，始终保持数据的私用，也就是始终用private来修饰数据，来是我们的程序更安全。

这个类的方法部分是：

public Employee(String n, double s, Day d)

public void print()

public void raiseSalary(double byPercent)

public void raiseSalary(int byAbsolute)

public int getHireYear()

public static String getCompany()

所谓方法，就是对数据的操作，有过C编程时间的同学，可以把它理解为函数，只是这些函数是放在类里并对类的数据进行操作的。比如这个方法：

public void raiseSalary(double byPercent)就是对数据salary的操作。

public是一个关键字，是公有的意思，表明该方法可以用 对象名.方法名 的方式调用。比如我们的测试程序中: alary(5.0D)，就是对这个方法的调用。否则，如果是private，该方法就只能被类里的方法调用，像alary(5.0D)这种调用是非法的。

void表明方法的返回类型为空，也就是什么都不返回。public int getHireYear()这个方法的返回类型是int。一般来说，返回类型这部分是不能缺少的，即使方法什么都不返回，也要用一个void关键字修饰。有一个例外：构造函数。我们后面会讲到。

raiseSalary(double byPercent)是方法名，前面我们已经说过方法的命名规则，第一个单词小写，以后没个单词首字母大写。这样可以增加可读性，根据raiseSalary这个名字就可以知道这个方法的功能是涨工资。括号里是参数列表，类似于我们前面学过的变量的声明。如果有多个参数，用逗号隔开，比如 Employee(String n, double s, int d)。

方法的一对大括号里是方法的实现，就是我们前面学过的语句的组合。比如print( )方法，是打印出该员工的姓名工资等信息；raiseSalary( )方法是根据参数，把员工工资涨相应的比例。注意，如果方法有返回类型且不为void，那么在方法的实现中必须有return语句，返回相应的类型。比如hireYear( )方法，就有return子句。相反，如果返回类型是void，那么不能返回任何数据，但可以是一个return语句，后面不带返回值，比如print( )方法里就有一个空的return语句。

5.4 构造方法

我们注意到，有一个方法是与类名同名的，而且没有返回类型，比如这个例子中的public

Employee(String n, double s, int d)，我们把它叫做构造方法。构造方法是做什么用的呢？构造方法是在声明对象的时候，自动调用的方法，其作用是为对象的数据做一些必要的初始化工作。比如，这里的public Employee(String n, double s, int d)方法，就是初始化这个员工的姓名，工资和雇佣年份。在声明emp对象的时候，调用的就是构造函数。

Employee emp = new Employee ("Tony ", 10000, 1990);

如果没有定义构造函数，Java会自动提供一个默认的构造函数，把所有成员数据初始化为默认值，比如数字类型（包括整型、浮点型）将是0，布尔类型将是false等。注意在没有构造方法时，new后面的（）中不能有数字！！

需要注意的是，与构造函数相对的是析构函数，目的是在对象不再使用的时候回收对象使用的

内存。C++里就支持析构函数。但是，由于Java提供自动回收"垃圾"的机制，所以不需要进行内存回收，所以Java没有析构函数。

5.5 方法的重载

方法的名字相同但参数的类型或个数不同，我们叫做方法的重载。

类允许有相同名字的方法，比如我们这个例子中的raiseSalary方法。

public void raiseSalary(double byPercent)

public void raiseSalary(int byAbsolute)

第一个的参数是double型，表明工资上涨的百分比；第二个的参数使int型，表明工资上涨的数额。这两个方法参数不同。调用的时候，根据参数的不同，决定使用哪一个方法。比如，我们的例子中，alary(5.0D)的参数是double型，所以将会调用第一个，工资上涨5%，alary(raise)的参数raise是一个int型，所以将会调用第二个，是工资上涨1000元。

方法的重载的好处是使我们的程序处理更方便。比如，我们的例子中，涨工资，我们提供了统一的raiseSalary( ) 方法，我们不用自己判断涨的是百分比还是绝对数额，由程序自己判断，是程序更好用，可读性更强。

5.6 静态方法和静态成员变量

所谓静态方法和静态成员变量，是指那些用static关键字修饰的方法或者变量，比如我们例子中的private static String company就是一个静态成员变量，而public static String

getCompany()和public static void setCompany(String s)都是静态方法。

静态的意思，是指该方法或者变量在整个类中只有一份。我们说，类是用来创建对象的模板，就是说，我们创建对象的时候，每个对象都会有类中所声明的成员变量的一个副本。但是，对于静态成员变量，在内存中只有一个副本，所有的对象将共享这个副本。比如我们的例子中，所有Employee所在的公司就只有一个，所以我们没有必要为每一个Employee的对象都保留一个company的副本，所以我们把它声明为静态的成员变量。比如我们例子中有两个Employee类的对象：emp和emp2，他们的成员变量内存模式如下图所示：

所以，只要改变了company的值，对所有Employee的对象都是起作用的。

另一方面，静态方法只能访问静态成员变量，比如我们的例子中，setCompany( )只能访问company，如果它访问name之类的变量，编译器将会报错。而且静态方法的调用是 类名.方法名的方式来调用的，也可以用一般的 对象名.方法名 的方式来调用。

实际上，我们先前用的n( )方法，就是一个静态的方法，所以我们可以直接用 类名.方法名 的方式调用。而一个类里如果有main函数都要声明为静态方法，因为一个程序只能有一个main函数入口。

小结

这一讲我们学习了类和对象的一些基本概念和知识，包括类的结构，构造方法 ，方法的重载 ，静态方法和静态成员变量。类和对象，是面向对象编程语言的最重要的特征，也是精髓所在。希望大家努力掌握好这部分知识。下一讲，我们继续学习Java的继承、接口等概念。

习题

1.

类的成员变量和局部变量有什么区别？从内存考虑。

2.

编个程序检验一下public方法和private方法有什么区别。

3.

编一个程序检验静态方法和静态成员变量的用法。

4.

在我们的例子中再重载raiseSalary()方法，按工龄涨工资，比如，如果工龄为5年，那么增长1%*5；

第六讲 类、对象和接口（2）

6.1 类的继承

继承是类的另一个特性。继承的意义在于：我们重复使用或更改现成的类的方法，也可以加入新的数据成员以及新的方法，以满足新环境的需要。这种技术是所有面向对象的编程语言的一个基本特征。

让我们来看一个例子：前面我们定义了一个Employee类，这只是普通员工，现在我们要定义一个经理类。经理也是员工的一种，所以Employee类中的数据和方法他也应该有；但经理又不同于普通员工，经理有秘书，而且涨工资的时候还要加上分红。怎么办？我们要不要从头开始写一个经理类？

有了继承的技术，我们可以在Employee类的基础上，编写我们的Manager类。程序如下：

package teach4;

import ;

class Manager extends Employee

{

private String secretaryName;

public Manager(String n, double s, int d)

{ super(n, s, d);必须在构造方法的第一个语句。

secretaryName = "";

}

public void raiseSalary(double byPercent)

{ // add 1/2% bonus for every year of service

Date today = new Date(2001,1,1);

double bonus = 0.5 * (r() - getHireYear());

alary(byPercent + bonus);

}

public void setSecretaryName(String n)

{ secretaryName = n;

}

public String getSecretaryName()

{ return secretaryName;

}

}

我们以这个例子为例，学习继承的用法。

首先，请注意这个类的头部有些不同：class Manager extends Employee；其中，关键字extends是扩展的意思，表明Manager类是从Employee类继承而来。我们把Employee叫做父类或者超类，把Manager叫做子类或者衍生类。一般来说，子类比父类有更多的功能。

Manager的构造方法中有个语句：super(n, s, d)，super是一个关键字，意思是调用父类的方法，在这里是父类，也就是Employee的构造方法；类似地，alary(byPercent + bonus)表示调用父类Employee的raiseSalary方法。所以，如果要在子类中调用父类的方法，使用super。

Manage的构造方法调用了Employee的构造方法。事实上，一般要求子类用super语句调用父类的构造方法并附上恰当的参数。如果没有用super调用，将默认地调用父类的默认构造方法，这时，如果父类没有没有默认的构造方法，编译器将报错。在子类的构造方法中，如果有super语句，要求super语句在第一行。

子类自动拥有父类的标志为public的成员变量和方法，比如：虽然我们在Manager类中没有定义print( )方法，但是()是合法的，因为print( )是Employee类的一个方法。如果希望改变父类中的方法，使之适合子类，我们也可以覆盖它。比如，因为经理的提薪方式是：除了上涨百分比，还要加上工龄*0.5的奖金，与普通员工的提薪方式就有不同。所以，我们要覆盖掉这个方法。实际上，只要重写这个方法就可以了。alary(1.0)，将自动调用Manager类里定义的raiseSalary()方法，而不是Employeee里的方法。

但是，如果是私有的成员变量或者方法，也就是用private关键字修饰的那些，那么子类是不能访问的。如果希望子类能访问而别的类不能访问，我们可以用protected关键字，比如：protected

String name；这样，name对于Manager来说是可以可见和可访问的，而对于不是Employee的子类的其他类，则是不能访问的。

总结一下访问权限关键字：

•

•

•

•

public:对全世界来说都是可见的；

private:仅对类来说是可见的；

protected:对所有子类和同一个包（package）来说是可见的；

不声明：如果这三个关键字都没有，那么默认为对整个包可见。

Manager类里定义的setSecretaryName()和getSecretaryName()方法，都只能为Manager类的对象调用，Employee类的对象是不能调用这两个方法的。

继承可以是几层的。比如，我们可以以Manager为父类，再衍生出Executive类来。我们也可以从Employee类衍生出Programmer类来，它与Manager类没有什么关系。如果希望防止别人从自己编写的一个类中衍生出另一个类，可以加上关键字final，比如，不希望从Manager类中再衍生出别的类，我们可以把Manager类的声明改为：final class Manager extends Employee。这样可以提高程序的安全性，但可扩展性会受到影响。

我们可以画出类的继承结构如下：

6.2造型

也叫强制类型转换。回忆一下，我们在第二讲的Java的基本语法中，说到基本数据类型的强制类型转换，可以把一个浮点数强制转换为整型，比如：double x=3.14; int nx = (int)x;这样，x=3，把小数部分丢掉了。我们同样可以把类强制转换为另一个类。但不是什么时候都可以转换的，只有在继承结构图内部，才能进行强制类型转换。

比如：Manager boss; Employee emp; 下面这个语句：emp=boss，相当于emp=(Employee)boss；因为emp是Employee类型的，而boss是Manager类型的，但是，这时候，emp将不能调用Manager类的方法，比如getSecretaryName()，如果要调用，必须把emp转换回来。比如：Manager manager;

manager=(Manager)emp；这样，manager就可以调用getSecretaryName()了。只允许子类转换成父类的调用父类的方法不允许调过来。

但是，如果一个对象确实是Employee类型，现在要把它转换为Manager类型而且试图访问Manager的方法，编译将会通过，但是运行时将会出现异常，程序将中止运行。

6.3接口

前面我们介绍Java的特点的时候说过，Java不允许多重继承，即一个类不允许有多个父类，至多只能有一个父类。在Java中，取代多重继承的技术是接口。Java是用接口技术的原因，是因为多重继承要么使编译器非常复杂，要么效率不高。

那么，接口是什么呢？我们可以把接口理解为一个描述框架，里面定义了一些方法，但并不实现这些方法，而是由继承这个接口的类来实现。这样，如果某一个类继承了一个接口，意思是说：这

个类实现了接口所定义的所有方法。

比如，Java的标准库里定义了一个名为Comparable的接口。只要某个类是可对比的，就可以继承并实现这个接口。数字型和字符串型都是可比的，所以String, Float, Integer, Double等类都继承并实现了这个接口。如果我们定义我们的例子中的Employee类业是可比的，以进公司的年份来比较，那么我们也可以继承这个类，并实现它。

注意，如果继承了一个接口，就必须实现这个接口所声明的所有方法。

6.4 this对象引用

有时会有这种情况，想全面地访问当前的对象，而不是某一个特殊的实例变量。This关键字引用方法所运作的那个对象。

比如，我们可能经常会遇到这样的构造方法：this( )。这个方法会调用这个类中的另一个构造方法。我们来看看程序示例。

6.5 类的包装和引入

package和import语句

包(Package) 由一组类(class)和接口(interface)组成。它是管理大型名字空间，避免名字冲突的工具。每一个类和接口的名字都包含在某个包中。按照一般的习惯，它的名字是由"."号分隔的单词构成，第一个单词通常是开发这个包的组织的名称。

定义一个包由package语句定义。如果使用package语句，编译单元的第一行必须无空格，也无注释。其格式如下：package packageName;若编译单元无package语句，则该单元被置于一个缺省的无名的包中。即：如果源文件中定义的类在放在同一个包中，但该包没有名字。

import语句用来引入所需要的类。

为了引用已有的类，使用import语句，import语句必须放在package语句（如果有的华）和类的定义之间。import语句的格式：

import 包名.类名

比如：

import ;

import ;

如果要引用一个包里所有的类，用*表示，比如：

import .*;

package语句用来指明该源文件定义的类所在的包，可以把包粗略理解为存放类的文件夹。比如，.*，就是java提供的一个程序包，里面放置了诸如数学方法等很多有用的程序，供大家调用。我们把package语句叫做包装语句。为了引用一个类，我们需要用引入语句：import。比如，我们要使用数学方法（比如求绝对值、求开方等），就要用import ，然后就可以调用Math里的方法了，非常方便。

包装的作用是方便管理，避免重名。比如，我们的例子，通过 package teach5包装在teach4里的：以后如果谁要用我们的程序中的类，只要用import teach4就可以引用了。注意，同在一个package里的类，可以直接相互引用，不用import语句。比如我们例子中，EmployeeTest类使用了Employee类，但没有用 import Employee之类的语句，就是因为它们都被包装在teach5里。

6.5 类的包装和引入

package和import语句

包(Package) 由一组类(class)和接口(interface)组成。它是管理大型名字空间，避免名字冲突的工具。每一个类和接口的名字都包含在某个包中。按照一般的习惯，它的名字是由"."号分隔的单词构成，第一个单词通常是开发这个包的组织的名称。

定义一个包由package语句定义。如果使用package语句，编译单元的第一行必须无空格，也无注释。其格式如下：package packageName;若编译单元无package语句，则该单元被置于一个缺省的无名的包中。即：如果源文件中定义的类在放在同一个包中，但该包没有名字。

import语句用来引入所需要的类。

为了引用已有的类，使用import语句，import语句必须放在package语句（如果有的话）和类的定义之间。import语句的格式：

import 包名.类名

比如：

import ;

import ;

如果要引用一个包里所有的类，用*表示，比如：

import .*;

package语句用来指明该源文件定义的类所在的包，可以把包粗略理解为存放类的文件夹。比如，.*，就是java提供的一个程序包，里面放置了诸如数学方法等很多有用的程序，供大家调用。我们把package语句叫做包装语句。为了引用一个类，我们需要用引入语句：import。比如，我们要使用数学方法（比如求绝对值、求开方等），就要用import ，然后就可以调用Math里的方法了，非常方便。

包装的作用是方便管理，避免重名。比如，我们的例子，通过 package teach5包装在teach4里的：以后如果谁要用我们的程序中的类，只要用import teach4就可以引用了。注意，同在一个package里的类，可以直接相互引用，不用import语句。比如我们例子中，EmployeeTest类使用了Employee类，但没有用 import Employee之类的语句，就是因为它们都被包装在teach5里。

小结

这一讲，我们主要学习了类的继承和接口。至此，我们学习了完Java语言的主要的必备的基础知识。同学们现在应该可以编写自己的面向对象的应用程序了。希望同学们多加练习，熟练掌握。下一讲开始，我们开始面向应用，学习编写小应用程序，也就是Java Applet。

习题

1.

子类和父类的构造方法调用顺序是怎么样的，举例说明。

2.

编程实现"人"类、"学生"类和"大学生"类。"人"类是"学生"类的父类，"学生"类是"大学生"类的父类。"人"类的成员变量有：年龄，性别，籍贯；"学生"类的成员变量有：就读学校，成绩考评；"大学生"类的变量有：导师，每月补助。

3.

要求实现Comparable接口，按年龄比较两个人的大小；

•

•

•

•

•

类的数组；

类作为参数

this指针

子类

抽象类

习题

1.

子类和父类的构造方法调用顺序是怎么样的，举例说明。

2.

编程实现"人"类、"学生"类和"大学生"类。"人"类是"学生"类的父类，"学生"类是"大学生"类的父类。"人"类的成员变量有：年龄，性别，籍贯；"学生"类的成员变量有：就读学校，成绩考评；"大学生"类的变量有：导师，每月补助。

3.

要求实现Comparable接口，按年龄比较两个人的大小；

• 类的数组；

• 类作为参数

• this指针

• 子类

• 抽象类

补充部分

诚信、创新、开放、合JAVA的面向对象编程--------课堂笔记

面向对象主要针对面向过程。

面向过程的基本单元是函数。

什么是对象：EVERYTHING IS OBJECT（万物皆对象）

所有的事物都有两个方面：

有什么（属性）：用来描述对象。

能够做什么（方法）：告诉外界对象有那些功能。

后者以前者为基础。

大的对象的属性也可以是一个对象。

为什么要使用面向对象：

首先，面向对象符合人类看待事物的一般规律。

对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。

方法的定义非常重要。方法有参数，也可能有返回值。

注意区分：对象（本身）、对象的实现者、对象的调用者。

分析对象主要从方法开始。

我们通过类来看待对象，类是对象的抽象。

其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。

对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。这样才能使每个对象本身做成最好的。

对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。

实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。

可复用性是OOP的基础。

比较面向过程的思想和面向对象的思想：

面向过程的思想：由过程、步骤、函数组成，以过程为核心；

面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。

面向过程是先有算法，后有数据结构。

面向对象是先有数据结构，然后再有算法。

在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。

开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能 。

从语法上来看，一个类是一个新的数据类型。

在面向对象编程中，除了简单数据类型，就是对象类型。

定义类的格式：

class Student{

代码

}

注意类名中单词的首字母大写。

实例变量：定义在类中但在任何方法之外。（New出来的均有初值）

局部变量：定义在方法之中的变量。

局部变量要先赋值，再进行运算，而实例变量均已经赋初值。这是局部变量和实例变量的一大区别。

实例变量的对象赋值为null。

局部变量不允许范围内定义两个同名变量。实例变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。

实例变量和局部变量允许命名冲突。

书写方法的格式：

修饰符 返回值 方法名 调用过程中 方法体

可能出现的例外

public int/void addNumber(参数) throw Excepion {}

例：

public int addNumber(int a,int b){

}

注：方法名中的参数int a,int b为局部变量

类方法中的一类特殊方法：构造方法。

构造方法是当用类生成对象时，系统在生成对象的过程中利用的方法。

注意：构造方法在生成对象的时候会被调用，但并不是构造方法生成了对象。

构造方法没有返回值。格式为：public 方法名。

构造方法的方法名与类名相同。

构造方法是在对象生成的过程中自动调用，不可能利用指令去调用。

在一个对象的生成周期中构造方法只用一次，一旦这个对象生成，那么这个构造方法失效。

用类来生成对象的语句：

Student s=new Student()。

第一个Student表示这是用Student类进行定义。“Student()”表示调用一个无参数的构造方法。

如果()中有参数，则系统构造对象的过程中调用有参的方法。

此时S称为一个对象变量。

Student s的存储区域存放的是地址：一个对象在硬盘上占有一个连续地址，首地址赋予s空间。

S称为对象Student的引用。

注意：在对象变量中存放的是引用（地址）；在简单变量中存放的是数值。

可以构造多个构造方法，但多个构造方法的参数表一定不同，参数顺序不同即属于不同的构造方法：

public student(string name,int a){

}

public student(int a,string name){

}

为两个不同的构造方法。

如果我们未给系统提供一个构造方法，那么系统会自动提供一个为空的构造方法。

练习：写一个类，定义一个对象，定义两个构造方法：一个有参，一个无参。

（编写一个程序验证对象的传递的值为地址）

注意下面这种形式：

static void changename(student stu){e “LUCY”}

注意生成新的对象与旧对象指向无关，生成新对象生命消亡与旧对象无关。

面向对象方法的重载（overloading）和覆盖（overriding）。

在有些JAVA书籍中将overriding称为重载，overloading称为过载。

Overloading在一个类中可以定义多个同名方法，各个方法的参数表一定不同。但修饰词可能相同，返回值也可能相同。

在程序的编译过程中根据变量类型来找相应的方法。因此也有人认为

overloading是编译时的多态，以后我们还会学到运行时多态。

为什么会存在overloading技术呢？作为应对方法的细节。

利用类型的差异来影响对方法的调用。

吃（）可以分为吃肉，吃菜，吃药，在一个类中可以定义多个吃方法。

构造方法也可以实现overloading。例：

public void teach(){};

public void teach(int a){};

public void teach(String a){}为三种不同的方法。

Overloading方法是从低向高转。

Byte—short—float—int—long—double。

在构造方法中，this表示本类的其他构造方法：

student(){};

student(string n){

this();//表示调用student()

}

如果调用student(int a)则为this(int a)。

特别注意：用this调用其他构造方法时，this必须为第一条语句，然后才是其他语句。

This表示当前对象。

Public void printNum(){

Int number=40；

n();

}

此时打印的是实例变量，而非局部变量，即定义在类中而非方法中的变量。

表示实例变量。

谁调用那么谁即为当前(this)对象的number方法。

封装：使对象的属性尽可能私有，对象的方法尽可能的公开。用private表示此成员属性为该类的私有属性。

Public表示该属性（方法）公开；

Private表示该属性（方法）为只有本类内部可以访问（类内部可见）。

（想用private还要用set和get方法供其他方法调用，这样可以保证对属性的访问方式统一，并且便于维护访问权限以及属性数据合法性）

如果没有特殊情况，属性一定私有，方法该公开的公开。

如果不指明谁调用方法，则默认为this。

区分实例变量和局部变量时一定要写this。

11.29

继承：

父类（SuperClass）和 子类（SonClass）。

父类的非私有化属性和方法可以默认继承到子类。

Class Son extends Father{

}

而如果父类中的私有方法被子类调用的话，则编译报错。

父类的构造方法子类不可以继承，更不存在覆盖的问题。（非构造方法可以）

如果子类访问父类的构造方法，则在编译的时候提示访问不到该方法。

JAVA中不允许多继承，一个类有且只有一个父类（单继承）。

JAVA的数据结构为树型结构，而非网状。（JAVA通过接口和内部类实现多继承）

方法的覆盖（overriding）

方法的重载并不一定是在一个类中：子类可以从父类继承一个方法，也可以定义一个同名异参的方法，也称为overloading。

当子类从父类继承一个无参方法，而又定义了一个同样的无参方法，则子类新写的方法覆盖父类的方法，称为覆盖。（注意返回值类型也必须相同，否则编译出错。）

如果方法不同，则成重载。

对于方法的修饰词，子类方法要比父类的方法范围更加的宽泛。

父类为public，那么子类为private则出现错误。

之所以构造方法先运行父类再运行子类是因为构造方法是无法覆盖的。

以下范围依次由严到宽：

private ：本类访问；

default ：表示默认，不仅本类访问，而且是同包可见。

Protected：同包可见+不同包的子类可见

Public ：表示所有的地方均可见。

当构造一个对象的时候，系统先构造父类对象，再构造子类对象。

构造一个对象的顺序：（注意：构造父类对象的时候也是这几步）

① 递归地构造父类对象；

② 顺序地调用本类成员属性赋初值语句；

③ 本类的构造方法。

Super()表示调用父类的构造方法。

Super()也和this一样必须放在第一行。

This()用于调用本类的构造方法。

如果没有定义构造方法，那么就会调用父类的无参构造方法，即super()。

要养成良好的编程习惯：就是要加上默认的父类无参的构造方法。

思考：可是如果我们没有定义无参的构造方法，而在程序中构造了有参的构造方法，那么如果方法中没有参数，那么系统还会调用有参的构造方法么？应该不会。

多态：多态指的是编译时类型变化，而运行时类型不变。

多态分两种：

① 编译时多态：编译时动态重载；

② 运行时多态：指一个对象可以具有多个类型。

对象是客观的，人对对象的认识是主观的。

例：

Animal a=new Dog()；查看格式名称；

Dog d=(Dog)a。声明父类来引用子类。

（思考上面的格式）

运行时多态的三原则：（应用时为覆盖）

1、 对象不变；（改变的是主观认识）

2、 对于对象的调用只能限于编译时类型的方法，如调用运行时类型方法报错。

在上面的例子中：Animal a=new Dog()；对象a的编译时类型为Animal，运行时类型为dog。

注意：编译时类型一定要为运行时类型的父类（或者同类型）。

对于语句：Dog d=(Dog)a。将d强制声明为a类型，此时d为Dog()，此时d就可以调用运行时类型。注意：a和d指向同一对象。

3、 在程序的运行时，动态类型判定。运行时调用运行时类型，即它调用覆盖后的方法。

关系运算符：instanceof

a instanceof Animal;(这个式子的结果是一个布尔表达式)

a为对象变量，Animal是类名。

上面语句是判定a是否可以贴Animal标签。如果可以贴则返回true，否则返回false。

在上面的题目中： a instanceof Animal返回 True，

a instanceof Dog也返回 True，

instanceof用于判定是否将前面的对象变量赋值后边的类名。

Instanceof一般用于在强制类型转换之前判定变量是否可以强制转换。

如果Animal a=new Animal()；

Dog d=Dog()a;

此时编译无误，但运行则会报错。

Animal a=new Dog()相当于下面语句的功能：

Animal a=getAnimal()；

Public static mal;

Return new Dog()；

封装、继承、多态为面向对象的三大基石（特性）。

运行时的动态类型判定针对的是方法。运行程序访问的属性仍为编译时属性。

Overloading针对的是编译时类型，不存在运行时的多态。

习题：建立一个shape类，有circle和rect子类。

Shape类有zhouchang()和area()两种方法。

（正方形）squ为rect子类，rect有cha()用于比较长宽的差。

覆盖时考虑子类的private及父类的public（考虑多态），之所以这样是避免调用A时出现实际调用B的情况。而出现错误。

11.29下午讲的是教程上的Module6

Module6-7包括：面向对象高级、内部类、集合、反射（暂时不讲）、例外。

面向对象高级、集合和例外都是面向对象的核心内容。

面向对象高级： 修饰符：

static:①可修饰变量（属性）；②可修饰方法；③可修饰代码块。

Static int data语句说明data为类变量，为一个类的共享变量，属于整个类。

Int data为实例变量。

例：

static int data;

=0;

++的结果为1,此时的结果也为1。

Static定义的是一块为整个类共有的一块存储区域，其发生变化时访问到的数据都时经过变化的。

其变量可以通过类名去访问：类名.变量名。与通过访问对象的编译时类型访问类变量为等价的。

Public static void printData(){}

表明此类方法为类方法（静态方法）

静态方法不需要有对象，可以使用类名调用。

静态方法中不允许访问类的非静态成员，包括成员的变量和方法，因为此时是通过类调用的，没有对象的概念。是不可用的。

一般情况下，主方法是静态方法，所以可调用静态方法，主方法为静态方法是因为它是整个软件系统的入口，而进入入口时系统中没有任何对象，只能使用类调用。

覆盖不适用于静态方法。

静态方法不可被覆盖。（允许在子类中定义同名静态方法，但是没有多态，严格的讲，方法间没有多态就不能称为覆盖）

当static修饰代码块时（注：此代码块要在此类的任何一个方法之外），那么这个代码块在代码被装载进虚拟机生成对象的时候可被装载一次，以后再也不执行了。

一般静态代码块被用来初始化静态成员。

Static通常用于Singleton模式开发：

Singleton是一种设计模式，高于语法，可以保证一个类在整个系统中仅有一个对象。

11.30

final可以修饰类、属性、方法。

当用final修饰类的时候，此类不可被继承，即final类没有子类。这样可以用final保证用户调用时动作的一致性，可以防止子类覆盖情况的发生。

当利用final修饰一个属性（变量）的时候，此时的属性成为常量。

JAVA利用final定义常量（注意在JAVA命名规范中常量需要全部字母都大写）：

Final int AGE=10；

常量的地址不可改变，但在地址中保存的值（即对象的属性）是可以改变的。

Final可以配合static使用。 ？

Static final int age=10；

在JAVA中利用public static final的组合方式对常量进行标识（固定格式）。

对于在构造方法中利用final进行赋值的时候，此时在构造之前系统设置的默认值相对于构造方法失效。

常量（这里的常量指的是实例常量：即成员变量）赋值：

①在初始化的时候通过显式声明赋值。Final int x=3；

②在构造的时候赋值。

局部变量可以随时赋值。

利用final定义方法：这样的方法为一个不可覆盖的方法。

Public final void print(){}；

为了保证方法的一致性（即不被改变），可将方法用final定义。

如果在父类中有final定义的方法，那么在子类中继承同一个方法。

如果一个方法前有修饰词private或static，则系统会自动在前面加上final。即private和static方法默认均为final方法。

注：final并不涉及继承，继承取决于类的修饰符是否为private、default、protected还是public。也就是说，是否继承取决于这个方法对于子类是否可见。

Abstract(抽象)可以修饰类、方法

如果将一个类设置为abstract，则此类必须被继承使用。此类不可生成对象，必须被继承使用。

Abstract可以将子类的共性最大限度的抽取出来，放在父类中，以提高程序的简洁性。

Abstract虽然不能生成对象，但是可以声明，作为编译时类型，但不能作为运行时类型。

Final和abstract永远不会同时出现。

当abstract用于修饰方法时，此时该方法为抽象方法，此时方法不需要实现，实现留给子类覆盖，子类覆盖该方法之后方法才能够生效。

注意比较：

private void print(){}；此语句表示方法的空实现。

Abstract void print()； 此语句表示方法的抽象，无实现。

如果一个类中有一个抽象方法，那么这个类一定为一个抽象类。

反之，如果一个类为抽象类，那么其中可能有非抽象的方法。

如果让一个非抽象类继承一个含抽象方法的抽象类，则编译时会发生错误。因为当一个非抽象类继承一个抽象方法的时候，本着只有一个类中有一个抽象方法，那么这个类必须为抽象类的原则。这个类必须为抽象类，这与此类为非抽象冲突，所以报错。

所以子类的方法必须覆盖父类的抽象方法。方法才能够起作用。

只有将理论被熟练运用在实际的程序设计的过程中之后，才能说理论被完全掌握！

为了实现多态，那么父类必须有定义。而父类并不实现，留给子类去实现。此时可将父类定义成abstract类。如果没有定义抽象的父类，那么编译会出现错误。

Abstract和static不能放在一起，否则便会出现错误。（这是因为static不可被覆盖，而abstract为了生效必须被覆盖。）

例：（本例已存在文件中）

public class TestClass{

public static void main(String[] args){

SuperClass sc=new SubClass();

();

}

Abstract class SuperClass{

Abstract void print();}

}

class SubClass extends SuperClass(){

void print(){

n(“print”);}

}

JAVA的核心概念：接口（interface）

接口与类属于同一层次，实际上，接口是一种特殊的抽象类。

如:

interface IA{

}

public interface：公开接口

与类相似，一个文件只能有一个public接口，且与文件名相同。

在一个文件中不可同时定义一个public接口和一个public类。

一个接口中，所有方法为公开、抽象方法；所有的属性都是公开、静态、常量。

一个类实现一个接口的格式：

class IAImple implements IA{

};

一个类实现接口，相当于它继承一个抽象类。

类必须实现接口中的方法，否则其为一抽象类。

实现中接口和类相同。

接口中可不写public，但在子类中实现接口的过程中public不可省。

（如果剩去public则在编译的时候提示出错：对象无法从接口中实现方法。）

注：

① 一个类除继承另外一个类，还可以实现接口；

class IAImpl extends st implement IA{}

继承类 实现接口

这样可以实现变相的多继承。

② 一个类只能继承另外一个类，但是它可以继承多个接口，中间用“，”隔开。

Implements IA,IB

所谓实现一个接口，就是指实现接口中的方法。

③ 接口和接口之间可以定义继承关系，并且接口之间允许实现多继承。

例：interface IC extends IA,IB{};

接口也可以用于定义对象

IA I=new IAImpl();

实现的类从父类和接口继承的都可做运行时类型。

IAImple extends A implement IA,IB

IB I=new IAImple();

I instance of IAImple;

I instance of A;

I instance of IA;

I instance of IB;

返回的结果均为true.

接口和多态都为JAVA技术的核心。

接口往往被我们定义成一类XX的东西。

接口实际上是定义一个规范、标准。

① 通过接口可以实现不同层次、不同体系对象的共同属性；

通过接口实现write once as anywhere.

以JAVA数据库连接为例子：JDBC制定标准；数据厂商实现标准；用户使用标准。

接口通常用来屏蔽底层的差异。

②接口也因为上述原因被用来保持架构的稳定性。

JAVA中有一个特殊的类： Object。它是JAVA体系中所有类的父类（直接父类或者间接父类）。

此类中的方法可以使所的类均继承。

以下介绍的三种方法属于Object:

(1) finalize方法：当一个对象被垃圾回收的时候调用的方法。

(2) toString():是利用字符串来表示对象。

当我们直接打印定义的对象的时候，隐含的是打印toString()的返回值。

可以通过子类作为一个toString()来覆盖父类的toString()。

以取得我们想得到的表现形式，即当我们想利用一个自定义的方式描述对象的时候，我们应该覆盖toString()。

(3)equal

首先试比较下例：

String A=new String(“hello”);

String A=new String(“hello”);

A==B(此时程序返回为FALSE)

因为此时AB中存的是地址，因为创建了新的对象，所以存放的是不同的地址。

附加知识：

字符串类为JAVA中的特殊类，String中为final类，一个字符串的值不可重复。因此在JAVA VM（虚拟机）中有一个字符串池，专门用来存储字符串。如果遇到String a=”hello”时（注意没有NEW，不是创建新串），系统在字符串池中寻找是否有”hello”，此时字符串池中没有”hello”，那么系统将此字符串存到字符串池中，然后将”hello”在字符串池中的地址返回a。如果系统再遇到String

b=”hello”，此时系统可以在字符串池中找到 “hello”。则会把地址返回b，此时a与b为相同。

String a=”hello”;

n(a==”hello”);

系统的返回值为true。

故如果要比较两个字符串是否相同（而不是他们的地址是否相同）。可以对a调用equal:

n((b));

equal用来比较两个对象中字符串的顺序。

(b)是a与b的值的比较。

注意下面程序：

student a=new student(“LUCY”,20);

student b=new student(“LUCY”,20);

n(a==b);

n((b));

此时返回的结果均为false。

以下为定义equal（加上这个定义，返回ture或false）

public boolean equals(Object o){

student s=(student)o;

if (()&&==)

else return false;

}如果equals()返回的值为

以下为实现标准equals的流程：

public boolean equals(Object o){

if (this==o) return trun; //此时两者相同

if (o==null) return false;

if (! o instanceof strudent) return false; //不同类

studeng s=(student)o; //强制转换

if (()&&==) return true;

else return false;

}

以上过程为实现equals的标准过程。

练习：建立一个employee类，有String name,int id,double salary.运用get和set方法，使用toString，使用equals。

封装类：

JAVA为每一个简单数据类型提供了一个封装类，使每个简单数据类型可以被Object来装载。

除了int和char，其余类型首字母大写即成封装类。

转换字符的方式：

int I=10;

String s=I+” ”;

String s1=f(i);

Int I=10;

Interger I_class=new integer(I);

看javadoc的帮助文档。

附加内容：

“==”在任何时候都是比较地址，这种比较永远不会被覆盖。

程序员自己编写的类和JDK类是一种合作关系。（因为多态的存在，可能存在我们调用JDK类的情况，也可能存在JDK自动调用我们的类的情况。）

注意：类型转换中doubleintergerstring之间的转换最多。

12.01

内部类：

（注：所有使用内部类的地方都可以不用内部类，使用内部类可以使程序更加的简洁，便于命名规范和划分层次结构）。

内部类是指在一个外部类的内部再定义一个类。

内部类作为外部类的一个成员，并且依附于外部类而存在的。

内部类可为静态，可用PROTECTED和PRIVATE修饰。（而外部类不可以：外部类只能使用PUBLIC和DEFAULT）。

内部类的分类：

成员内部类、

局部内部类、

静态内部类、

匿名内部类（图形是要用到，必须掌握）。

① 成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列。

内部类和外部类的实例变量可以共存。

在内部类中访问实例变量：this.属性

在内部类访问外部类的实例变量：外部类名.this.属性。

成员内部类的优点：

⑴内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为PRIVATE，但是对于处于其内部的内部类还是可见的。）

⑵用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。

注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。

对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现和outer$两类。

（编写一个程序检验：在一个程序中验证内部类在编译完成之后，会出现几个class.）

成员内部类不可以有静态属性。（为什么？）

如果在外部类的外部访问内部类，使用.

建立内部类对象时应注意：

在外部类的内部可以直接使用inner s=new inner();（因为外部类知道inner是哪个类，所以可以生成对象。）

而在外部类的外部，要生成（new）一个内部类对象，需要首先建立一个外部类对象（外部类可用），然后在生成一个内部类对象。

in=()。

错误的定义方式：

in=new ()。

注意：当Outer是一个private类时，外部类对于其外部访问是私有的，所以就无法建立外部类对象，进而也无法建立内部类对象。

② 局部内部类：在方法中定义的内部类称为局部内部类。

与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。

注意：局部内部类不仅可以访问外部类实例变量，还可以访问外部类的局部变量（但此时要求外部类的局部变量必须为final）？？

在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。

要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。

③ 静态内部类：（注意：前三种内部类与变量类似，所以可以对照参考变量）

静态内部类定义在类中，任何方法外，用static定义。

静态内部类只能访问外部类的静态成员。

生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：

in=new ()；

而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。

静态内部类不可用private来进行定义。例子：

对于两个类，拥有相同的方法：

People

{

run();

}

Machine{

run();

}

此时有一个robot类：

class Robot extends People implement Machine.

此时run()不可直接实现。

注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。

用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。

④ 匿名内部类（必须掌握）：

匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口。

IA被定义为接口。

IA I=new IA(){};

注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。

因其为局部内部类，那么局部内部类的所有限制都对其生效。

匿名内部类是唯一一种无构造方法类。

匿名内部类在编译的时候由系统自动起名Out$。

如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。

因匿名内部类无构造方法，所以其使用范围非常的有限。

（下午：）Exception（例外/异常）（教程上的MODEL7）

对于程序可能出现的错误应该做出预案。

例外是程序中所有出乎意料的结果。（关系到系统的健壮性）

JAVA会将所有的错误封装成为一个对象，其根本父类为Throwable。

Throwable有两个子类：Error和Exception。

一个Error对象表示一个程序错误，指的是底层的、低级的、不可恢复的严重错误。此时程序一定会退出，因为已经失去了运行所必须的物理环境。

对于Error错误我们无法进行处理，因为我们是通过程序来应对错误，可是程序已经退出了。

我们可以处理的Throwable对象中只有Exception对象（例外/异常）。

Exception有两个子类：Runtime exception（未检查异常）

非Runtime exception（已检查异常）

（注意：无论是未检查异常还是已检查异常在编译的时候都不会被发现，在编译的过程中检查的是程序的语法错误，而异常是一个运行时程序出错的概念。）

在Exception中，所有的非未检查异常都是已检查异常，没有另外的异常！！

未检查异常是因为程序员没有进行必要的检查，因为他的疏忽和错误而引起的异常。一定是属于虚拟机内部的异常（比如空指针）。

应对未检查异常就是养成良好的检查习惯。

已检查异常是不可避免的，对于已检查异常必须实现定义好应对的方法。

已检查异常肯定跨越出了虚拟机的范围。（比如“未找到文件”）

如何处理已检查异常（对于所有的已检查异常都要进行处理）：

首先了解异常形成的机制：

当一个方法中有一条语句出现了异常，它就会throw（抛出）一个例外对象，然后后面的语句不会执行返回上一级方法，其上一级方法接受到了例外对象之后，有可能对这个异常进行处理，也可能将这个异常转到它的上一级。

对于接收到的已检查异常有两种处理方式：throws和try方法。

注意：出错的方法有可能是JDK，也可能是程序员写的程序，无论谁写的，抛出一定用throw。

例：public void print() throws Exception.

对于方法a，如果它定义了throws Exception。那么当它调用的方法b返回异常对象时，方法a并不处理，而将这个异常对象向上一级返回，如果所有的方法均不进行处理，返回到主方法，程序中止。（要避免所有的方法都返回的使用方法，因为这样出现一个很小的异常就会令程序中止）。

如果在方法的程序中有一行throw new Exception()，返回错误，那么其后的程序不执行。因为错误返回后，后面的程序肯定没有机会执行，那么JAVA认为以后的程序没有存在的必要。

对于try……catch格式：

try {可能出现错误的代码块} catch(exception e){进行处理的代码} ；

对象变量的声明

用这种方法，如果代码正确，那么程序不经过catch语句直接向下运行；

如果代码不正确，则将返回的异常对象和e进行匹配，如果匹配成功，则处理其后面的异常处理代码。（如果用exception来声明e的话，因为exception为所有exception对象的父类，所有肯定匹配成功）。处理完代码后这个例外就完全处理完毕，程序会接着从出现异常的地方向下执行（是从出现异常的地方还是在catch后面呢？利用程序进行验证）。最后程序正常退出。

Try中如果发现错误，即跳出try去匹配catch，那么try后面的语句就不会被执行。

一个try可以跟进多个catch语句，用于处理不同情况。当一个try只能匹配一个catch。

我们可以写多个catch语句，但是不能将父类型的exception的位置写在子类型的excepiton之前，因为这样父类型肯定先于子类型被匹配，所有子类型就成为废话。JAVA编译出错。

在try，catch后还可以再跟一子句finally。其中的代码语句无论如何都会被执

行（因为finally子句的这个特性，所以一般将释放资源，关闭连接的语句写在里面）。

如果在程序中书写了检查（抛出）exception但是没有对这个可能出现的检查结果进行处理，那么程序就会报错。

而如果只有处理情况（try）而没有相应的catch子句，则编译还是通不过。

如何知道在编写的程序中会出现例外呢

1． 调用方法，查看API中查看方法中是否有已检查错误。

2． 在编译的过程中看提示信息，然后加上相应的处理。

Exception有一个message属性。在使用catch的时候可以调用：

Catch(IOException e){n(e())};

Catch(IOException e){tackTrace()};

上面这条语句回告诉我们出错类型所历经的过程，在调试的中非常有用。

开发中的两个道理：

①如何控制try的范围：根据操作的连动性和相关性，如果前面的程序代码块抛出的错误影响了后面程序代码的运行，那么这个我们就说这两个程序代码存在关联，应该放在同一个try中。

② 对已经查出来的例外，有throw(积极)和try catch（消极）两种处理方法。

对于try catch放在能够很好地处理例外的位置（即放在具备对例外进行处理的能力的位置）。如果没有处理能力就继续上抛。

当我们自己定义一个例外类的时候必须使其继承excepiton或者RuntimeException。

Throw是一个语句，用来做抛出例外的功能。

而throws是表示如果下级方法中如果有例外抛出，那么本方法不做处理，继续向上抛出。

Throws后跟的是例外类型。

断言是一种调试工具（assert）

其后跟的是布尔类型的表达式，如果表达式结果为真不影响程序运行。如果为假系统出现低级错误，在屏幕上出现assert信息。

Assert只是用于调试。在产品编译完成后上线assert代码就被删除了。

方法的覆盖中，如果子类的方法抛出的例外是父类方法抛出的例外的父类型，那么编译就会出错：子类无法覆盖父类。

结论：子类方法不可比父类方法抛出更多的例外。子类抛出的例外或者与父类抛出的例外一致，或者是父类抛出例外的子类型。或者子类型不抛出例外。

如果父类型无throws时，子类型也不允许出现throws。此时只能使用try catch。

练习：写一个方法：int add(int a,int b)

{

return a+b；

}

当a+b=100;抛出100为异常处理。

12.02

集合（从本部分开始涉及API）

集合是指一个对象容纳了多个对象，这个集合对象主要用来管理维护一系列相似的对象。

数组就是一种对象。（练习：如何编写一个数组程序，并进行遍历。）

.*定义了一系列的接口和类，告诉我们用什么类NEW出一个对象，可以进行超越数组的操作。

（注：JAVA1.5对JAVA1.4的最大改进就是增加了对范型的支持）

集合框架接口的分类：（分collection接口 和 map接口）

Collection接口 Map接口

List接口 Set接口 SortedMap接口

SortedSet接口

JAVA中所有与集合有关的实现类都是这六个接口的实现类。

Collection接口：集合中每一个元素为一个对象，这个接口将这些对象组织在一起，形成一维结构。

List接口代表按照元素一定的相关顺序来组织（在这个序列中顺序是主要的），List接口中数据可重复。

Set接口是数学中集合的概念：其元素无序，且不可重复。（正好与List对应）

SortedSet会按照数字将元素排列，为“可排序集合”。

Map接口中每一个元素不是一个对象，而是一个键对象和值对象组成的键值对（Key-Value）。

Key-Value是用一个不可重复的key集合对应可重复的value集合。（典型的例子是字典：通过页码的key值找字的value值）。

例子：

key1—value1;

key2—value2;

key3—value3.

SortedMap：如果一个Map可以根据key值排序，则称其为SortedMap。（如字典）

!!注意数组和集合的区别：数组中只能存简单数据类型。Collection接口和Map接口只能存对象。

以下介绍接口：

List接口：（介绍其下的两个实现类：ArrayList和LinkedList）

ArrayList和数组非常类似，其底层①也用数组组织数据，ArrayList是动态可变数组。

① 底层：指存储格式。说明ArrayList对象都是存在于数组中。

注：数组和集合都是从下标0开始。

ArrayList有一个add(Object o)方法用于插入数组。

ArrayList的使用：（完成这个程序）

先import .*；

用ArrayList在一个数组中添加数据，并遍历。

ArrayList中数组的顺序与添加顺序一致。

只有List可用get和size。而Set则不可用（因其无序）。

Collection接口都是通过Iterator()（即迭代器）来对Set和List遍历。

通过语句：Iterator it=or(); 得到一个迭代器，将集合中所有元素顺序排列。然后可以通过interator方法进行遍历，迭代器有一个游标（指针）指向首位置。

Interator有hasNext()，用于判断元素右边是否还有数据，返回True说明有。然后就可以调用next动作。Next()会将游标移到下一个元素，并把它所跨过的元素返回。（这样就可以对元素进行遍历）

练习：写一个程序，输入对象信息，比较基本信息。

集合中每一个元素都有对象，如有字符串要经过强制类型转换。

Collections是工具类，所有方法均为有用方法，且方法为static。

有Sort方法用于给List排序。

()分为两部分，一部分为排序规则；一部分为排序算法。

规则用来判断对象；算法是考虑如何排序。

对于自定义对象，Sort不知道规则，所以无法比较。这种情况下一定要定义排序规则。方式有两种：

① 下面有一个接口：Comparable（可比较的）

可以让自定义对象实现一个接口，这个接口只有一个方法comparableTo(Object

o)

其规则是当前对象与o对象进行比较，其返回一个int值，系统根据此值来进行排序。

如 当前对象>o对象，则返回值>0；（可将返回值定义为1）

如 当前对象=o对象，则返回值=0；

如 当前对象

看TestArraylist的java代码。

我们通过返回值1和-1位置的调换来实现升序和降序排列的转换。

② 下有一个Comparator(比较器)

它拥有compare()，用来比较两个方法。

要生成比较器，则用Sort中Sort（List,List(Compate)）

第二种方法更灵活，且在运行的时候不用编译。

注意：要想实现comparTo()就必须在主方法中写上implement comparable.