面向对象程序设计期末复习

面向对象程序设计

期末考试范围

面向对象部分为主

Chapter8,10,11,13,14

时间2小时，英文题目，熟记每章后面的英文术语(KeyTerms)

变量和方法

变量、方法，如：

〃变量的申明：数据类型变量名

inta;

〃方法的申明：返回类型方法名(参数列表){语句}

intadd(inta,intb){…}

voidsetParameter(inta,intb){…}

注意大小写

main方法

main方法是一个特殊的方法，是程序运行的入口

main方法的形式是固定的。

publicstaticvoidmain(String[]args){//Stringargs[]

inta=10;

intb=12;

intsum=a+b;

}

Java程序构成

Java是一种完全面向对象的程序设计语言，程序中不允许单独出现任

何方法

类是构成Java程序的基本单位，也就是说，前面出现的变量、方法

都必须申明在类的内部。这些变量和方法称为类的成员变量(属性，

Attribute)和成员方法(Method),统称为类的成员(Member)。

一个Java程序可以包含多个类，这些类可以封装在不同的包中

Java类

申明类的语法规则

修饰符class类名{

变量的申明〃成员变量(属性)

方法的申明〃成员方法

}

申明成员变量和申明成员方法的次序无关

一个类可以同时申明多个成员变量和成员方法，也可以不申明任何变

量或者方法，这些都是合法的。

在方法的内部也可以申明变量，这样的变量称为局部变量。

Java类举例

publicclassPerson{

〃属性：name、age>gender

〃方法：setName

〃方法：getName

}

Java程序举例

综合以上知识，我们将前面的main方法申明为类Test的一个成员：

publicclassTest{

publicstaticvoidmain(String[]args){

inta=10;〃变量a是一个局部变量

intb=12;

intsum=a+b;

习惯：类名首字母大写，变量/方法名首字母小写

数据类型

简单数据类型：如int

类也是一种数据类型，称为引用数据类型(复杂数据类型，reference

type)o因此以下变量和方法的申明都是正确的：

inta=10;

Personp;

Testb;

PersongetPerson(){---}

我们有时候也将类称为类型，如变量p的类型为Person类型,注意:

这时候程序中必须已经申明了Person类，否则将产生错误。

Java程序举例

classPerson{}

publicclassTest{

publicstaticvoidmain(---){

inta=10;〃变量a是一个局部变量

intb=12;

intsum=a+b;

Personp;

)

)

该Java程序由Person和Test两个类构成

自定义类和预定义类

Java已经预先定义了很多类，这些类称为预定义类

如:String

与此相对应，由我们自己定义的类则称为自定义类，如前面的Person

类和Test类

如前面所说，类是一种数据类型。因此，无论是预定义类还是自定义

类，在程序中我们都可以用它们来申明变量的数据类型、或者作为方

法的返回类型。

Java类举例

publicclassPerson{

Stringname;

intage;

publicvoidsetName(Stringstr){…}

publicStringgetName(){returnname;}

}

Java源程序

源程序保存在后缀名为Java的文件中。

一个Java源文件可以同时包含多个类的申明，但是其中最多只能有

一个用public修饰的类，即公有类。

源文件的名称必须和公有类的名称相一致，包括大小写

举例：Hello.java

publicclassHello

(

publicstaticvoidmain(Stringargs[])

(

System.out.println(HelloWorld!);

)

}

对象的创建

对象是类的实例

假设程序中申明了Person类，那么我们就可以在程序的任何地方创

建任意的Person类的实例，即Person类型的对象

对象创建的语法形式：

new类名(…)；〃括号中是否有参数，要依据构造方法

比如：newPerson();

Person类

publicclassPerson{

Stringname;

intage;

publicvoidsetAge(inta){

age=a;

}

publicintgetAge(){

returna;

}

}

对象的存在形式

对象存在于内存(堆，heap)

0x3A080x3A5C

name

age

对象的引用

对象由相应类型的变量引用,如:

Personpl=newPerson();

Personp2=newPerson();

0x3A5C

对象的操作

语法形式：对象成员,如:

pl.setAge(18);

p2.setAge(29);

0X3A5C

必须是对象.成员，不能是类.成员，除非该成员是static修饰的

Person.setAge(20),Error

关于方法调用

如方法有返回类型，则必须使用return语句，返回的值必须与返回类

型匹配

void返回类型可以没有return语句，也可以包含一个没有值的return

语句

publicclassPerson{

intage;

publicvoidsetAge(inta){

age=a;

return;

}

}

构造方法(Constructor)

Java中的每个类都有构造方法，构造方法具有和类名相同的名称(包

括大小写)，而且无任何返回值(包括void)。

构造方法一般对成员变量赋一些初值；如果一个类没有声明构造方法,

Java自动为该类生成一个默认的无参的构造方法，并且该默认构造方

法的内容为空。即，Java类可以通过两种方式获得构造方法

使用系统默认的无参构造方法

显式定义一个或多个构造方法

一旦显式定义了构造方法，系统不再提供默认构造方法

一个类至少有一个构造方法，可以有多个构造方法，根据参数的不同

决定执行哪一个(重载)

Person类

publicclassPerson{

Stringname;

intage;

publicPerson(){}〃构造方法

publicvoidsetAge(inta){age=a;}

publicintgetAge(){returna;}

)

引用数据类型

8种基本数据类型

intlongshortbooleanchardoublefloatbyte

除此以外的数据类型称为引用类型

引用类型数据以对象的形式存在

引用类型变量的值是某个对象的句柄(对象在内存中的地址)，而不是

对象本身

声明引用类型变量时，系统只为该变量分配引用空间，并未创建一个

具体的对象，引用类型可赋值为null

类中的变量

属性变量(成员变量)：在方法体外定义的变量，是类的成员，可以是

基本类型、引用类型甚至是类本身，只要对象存在其属性变量就存在。

作用域：类。

局部变量：在方法体内定义的变量，也称为stackvariable,作用域:

方法。方法执行时存在，方法执行完毕后消失

局部变量在使用前必须进行初始化，而属性变量可以不需要显式进行

初始化，因为在创建对象时会进行默认的初始化。

举例：MyDate类

publicclassMyDate{

privateintday=12;

privateintmonth=6;

privateintyear=1900;

publicMydate(intd,intm,inty){

year=y;

month=m;

day=d;

}

publicvoiddisplay(){

System.out.println(year+"/"+month+"/"+day);

}

publicstaticvoidmain(String[]args){

MyDatem;

m=newMyDate(22,9,2001);

m.display();

}

)

对象的构造和初始化(1)

为引用类型变量分配引用空间MyDatem;

mnull

创建新对象-首先为新对象分配内存空间，并进行属性(实例变量)的

默认初始化，new

day

mnullmonth

year

对象的构造和初始化(2)

Java引用类型成员变量默认初始化原则

成员变量类型取值

byte0

short0

int0

long0L

char*\u0000,

float0.0F

double0.00

booleanfalse

所有引用类型null

对象的构造和初始化(3)

进行属性(成员变量)的显式初始化，显式初始化取值来自于类的定义

中属性声明部分

privateintday=12;

privateintmonth=6;

privateintyear=1900;

day

m|null|month

year

对象的构造和初始化(4)

执行构造方法

publicMydate(inty,intm,intd){

year=y;

month=m;

day=d;

}

newMyDate(22,9,2001);

mnull

对象的构造和初始化(5)

为引用类型变量m赋值

m=newMyDate(22,9,2001);

m0x3a478b

封装类

Java编程语言提供wrapper类来操作作为对象的原始数据元素。

每个Java原始数据类型在java.lang包中具有相应的wrapper类。

使用wrapper类的示例:

intpint=420;

Integerwlnt=newInteger(plnt);

//thisiscalledboxing

intp2=Value();

//thisiscalledunboxing

自动装箱与开箱

Integer(]intArray={newInteger(2)rabE-llnteger[)intArray={2,3};

newInteger(4),newInteger(3));

(a)(b)

Integeri=3;

不仅限于Integer,所有wrapper类都可以

Object[]o={3,false};〃合法

转换

Integerintegerobject=lnteger.valueOf("12");

intnumber=Integer.parselnt("12");

注：lnteger.parselnt("xyz")编译时没问题，但运行时会异常

访问权限(Permission)

Public；Protected；缺省(default)；private

ModifierAccessedAccessedAccessedAccessed

onmeirbei'sfromthefromthefromafromadifferent

inaclasssameclasssamepackagesubclasspackage

publicMMM

protectedMM—

defaultMM——

privateM———

数组

数组由一组相同类型的元素构成

元素的个数称为数组的长度，通过数组下标访问元素，下标0代表第一

个元素

数组是一个对象，数组类型属于引用数据类型，可赋值为null.

数组的申明和创建

•数组的申明

inta[];或intQa;

Pointp[];或PointOp;

•数组对象必须通过new关键字创建

数组的初始化

intoa={1,2,3,4,5};

PointQp={StringQusers={

newPoint(1,1),“John”，

newPoint(2,2)“Mary”

}；}；

参数传递1

基本变量传值，引用变量传地址

classMyDate{

privateintday;

privateintmonth;

privateintyear;

publicMyDate(intd,intm,inty){

day=d;month=m;year=y;

)

publicvoidsetDay(intd){day=d;}

publicvoidsetMonth(intm){month=m;}

publicvoidsetYear(inty){year=y;}

publicintgetDay(){returnday;}

publicintgetMonth(){returnmonth;}

publicintgetYear(){returnyear;}

publicvoiddisplay(){

System.out.println(day+"-"+month+"-"+year);

)

)

参数传递2

基本变量传值，引用变量传地址

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

MyDatedl=newMyDate(7,7,1970);

MyDated2=newMyDate(l,1,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

}

publicvoidchangel(inti){i=1234;}

publicvoidchange2(MyDateb){b=newMyDate(22,2,2004);}

publicvoidchange3(MyDateb){b.setDay(22);}

}

参数传递演示1

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7/7/1970);

BirthDated2=newBirthDate(l,l,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

)

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=newBirthDate(22,2/2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

}

参数传递演示2

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(lzl,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

}

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=newBirthDate(22,2,2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

}

Jr.

栈内1存-.

___r)

d23547521

dl587934\

main〈..

date——x9——\

[ex|1109251■-1970J

十处内存状态

参数传递演示3

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(l,1,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

}

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=newBirthDate(22,2,2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

}

参数传递演示4

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(l,1,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

)

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=newBirthDate(22,2,2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

}

参数传递演示5

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(l,1,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

}

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=newBirthDate(22,2,2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

}

参数传递演示6

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(l,1,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

}

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){bnew

BirthDate(22,2z2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

)

参数传递演示7

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(l,1,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

}

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=new

BirthDate(22,2,2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

)

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(l,l,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

}

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=newBirthDate(22,2,2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

}

参数传递演示9

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(l,1,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

}

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=newBirthDate(22,272004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

参数传递演示10

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(lzl,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

}

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=newBirthDate(22,2,2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

)

参数传递演示11

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Exampleex=newExample();

intdate=9;

BirthDatedl=newBirthDate(7,7,1970);

BirthDated2=newBirthDate(Ll,2000);

ex.changel(date);

ex.change2(dl);

ex.change3(d2);

System.out.println("date="+date);

dl.display();

d2.display();

)

publicvoidchangel(inti){i=1234;}

publicvoidchange2(BirthDateb){b=newBirthDate(22,2,2004);}

publicvoidchange3(BirthDateb){b.setDay(22);}

}

静态方法

以static关键字申明的方法就称为静态方法，也称为类方法

对于静态方法，可以由类直接调用，当然，也可以通过对象进行调用

静态变量

一个由static关键字修饰的变量，就称为静态变量,也称为类变量,（请对

照实例变量）

如果一个类变量的访问级别为public,那么可以通过类直接访问该静

态变量

静态变量是多个对象间共享的

方法的重载

在同一个类中可以定义多个同名方法--方法重载

publicclassPrintStream{

publicvoidprintln(inti){.......}

publicvoidprintln(floatf){.......}

publicvoidprintln(Strings){.......}

)

重载方法的参数列表必须不同

重载方法的返回值类型可以相同，也可以不同

构造方法重载

构造方法重载举例：

publicclassProject{

publicProject(){.......}

publicProject(Stringcode){.......}

publicProject(Stringcode,Stringname){.......}

}

构造方法重载，参数列表必须不同

可以在构造方法的第一行使用this关键字调用其它(重载的)构造方法

关键字this

指代当前对象自身

publicclassProject{

privateStringproj_code="";

privateStringproj_name="";

publicvoidsetName(Stringname){

j_name=name;〃等价于proj_name=name

}

}

publicclassTest{

publicstaticvoidmain(Stringargs[]){

Projectproj_l=newProject();proj_l.setName("abc");

〃this是proj_l

Projectproj_2=newProject();proj_2.setName("xyz");

//this是proj_2

}

}

publicvoidsetName(Stringproj_name){

j_name=proj_name;〃解决了变量的命名冲突和

不确定性问题

}

调用重载的构造方法

publicclassProject{

privateStringproj_code=

privateStringproj_name=

publicProject(Stringcode){

}

publicProject(){

this("abc");〃this必须是方法中的第一条语句

)

}

this指代当前对象，可以returnthis

this可以调用重载的构造方法，但不能直接用this初始化对象，new

this。是非法的

类的继承

类继承语法规则

<modifier>class<name>[extends<superclass>]

(

<declarations>

)

Object类是所有Java类的最高层父类

Java只支持单继承，不允许多重继承

一个子类只能有一个父类

一个父类可以继承出多个子类

publicclassPerson{

publicStringname;

publicintage;

publicDatebirthDate;

publicStringgetlnfo(){...}

}

为描述和处理学生信息，定义类Student

publicclassStudent{

publicStringname;

publicintage;

publicDatebirthDate;

publicStringschool;

publicStringgetlnfo(){...}

}

通过继承，简化Student类的定义

publicclassPerson{

publicStringname;

publicintage;

publicDatebirthDate;

publicStringgetlnfo(){...}

}

publicclassStudentextendsPerson{

publicStringschool;

}

方法的重写/覆盖

在子类中可以根据需要对从父类中继承来的方法进行改造--方法的

重写

重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值

类型

重写方法不能使用比被重写方法更严格的访问权限

构造方法不能被重写，只能通过super调用

方法重写举例

publicclassPerson{

protectedStringname;

protectedintage;

protectedDatebirthDate;

publicStringgetlnfo(){

return"Name:"+name+"\n"+"age:"+age;

)

}

publicclassStudentextendsPerson{

protectedStringschool;

publicStringgetlnfo(){

return"Name:"+name+"\nage:"+age+"\nschool:"+

school;

}

}

关键字super

在Java类中使用super来引用父类的成分

super可用于访问父类中定义的属性

super可用于调用父类中定义的成员方法

super可用于在子类构造方法中调用父类的构造方法

super的追溯不仅于直接父类

关键字super举例

publicclassPerson{

protectedStringname;

protectedintage;

protectedDatebirthDate;

publicStringgetlnfo(){

return"Name:"+name+"\n"+"age:"+age;

}

}

publicclassStudentextendsPerson{

protectedStringschool;

publicStringgetlnfo(){

〃调用父类的方法

returnsuper.getlnfo()+"\nschool:"+school;

}

}

调用父类构造方法

在子类的构造方法中可使用super(argument」ist)语句调用父类的构造

方法，super语句必须是构造方法的第一条语句

如果子类的构造方法中没有显示地调用父类构造方法，也没有使用

this关键字调用重载的其它构造方法，则系统默认调用父类无参数的

构造方法

如果子类构造方法中既未显式调用父类构造方法，而父类中又没有无

参的构造方法，则编译出错

在子类中，不能通过父类的构造方法名调用父类的构造方法，只能通

过super关键字

调用父类构造方法举例

1publicclassPerson{

2

3privateStringname;

4privateintage;

5privateDatebirthDate;

6

7publicPerson(Stringname,intage,Dated){

8=name;

9this.age=age;

10this.birthDate=d;

11}

12publicPerson(Stringname,intage){

13this(name,age,null);

14}

15publicPerson(Stringname,Dated){

16this(namez30,d);

17}

18publicPerson(Stringname){

19thisfname,30);

20)

21//……

22}

1publicclassStudentextendsPerson{

2privateStringschool;

3

4publicStudent(Stringname,intage,Strings){

5super(name,age);

6school=s;

7}

8publicStudent(Stringname,Strings){

9super(name);

10school=s;

11}

12publicStudent(Strings){//编译出错：nosuper。

super();

13school=s;

14)

15}

不能通过this关键字去初始化父类的属性，只能通过super利用父类

的构造方法去初始化父类的属性，不能通过父类构造方法名调用父类

构造方法

1publicclassStudentextendsPerson{

2privateStringschool;

3

4publicStudent(Stringname,intage,Strings){

5=name;this.age=age//error

6school=s;

7)

8publicStudent(Stringname,Strings){

9Pernson(name);//error

10school=s;

11)

12publicStudent(Strings){//编译出错：nosuper。

super();

13school=s;

14}

15}

多态(1)

多态--在Java中，子类的对象可以替代父类的对象使用

一个对象只能有一种确定的数据类型

一个引用类型变量可能指向(引用)多种不同类型的对象，父类的引用

变量可以指向子类实例，反之不成立

Personp=newStudent();

Objecto=newPerson();

o=newStudent();

Object[]o={newPerson。，newStudent()};

Students=newPerson()//error

多态(2)

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象,

那么该变量就不能再访问子类中添加的属性和方法

Studentm=newStudent();

m.school="pku";〃合法

Persone=newStudent();

e.school="pku";〃非法

publicclassPerson{publicintgetlnfo(){}}

Objecto=newPerson();

o.getlnfo()〃非法

动态绑定/虚方法调用

正常的方法调用

Persone=newPerson();e.getlnfo();

Studente=newStudent();e.getlnfo();

动态绑定(多态情况下)

Persone=newStudent();

e.getlnfo();〃此时调用的是Student类中定义的getInfo方法

Person[]a={newPerson。，newStudent()}

Person[0].getlnfo()〃调用Person类中的方法

Person[l].getlnfo()〃调用Student类中的方法

编译时类型和运行时类型

多态性应用举例(1)

同类收集(homogenouscollections)

MyDate[]m=newMyDate[2];

m[0]=newMyDate(22,12,1964);

m[l]=newMyDate(22,1,1964);

异类收集(heterogeneouscollections)

Person[]p=newPerson[3];

p[0]=newStudent();

p[l]=newPerson();

p[2]=newGraduate();

多态性应用举例(2)

方法声明的参数类型为父类类型，可以使用子类的对象作为实参调用

该方法

publicclassTest{

publicvoidmethod(Persor)e){

//……

e.getlnfo();

)

publicstaticvoidmain(Stirngargs[]){

Testt=newTest();

Studentm=newStudent();

t.method(m);

}

}

instanceof操作符

publicclassPersonextendsObject{,•,}

publicclassStudentextendsPerson{,,,}

publicclassGraduateextendsPerson{,,,}

Personp=newStudent();

pinstanceofStudent;//true

因此从(pinstanceofStudent)不能推断p被声明为Student类型

publicvoidmethodl(Persone){

if(einstanceofStudent){

//处理Student类型及其子类类型对象

}elseif(einstanceofGraduate){

〃处理Graduate类型及其子类类型对象

}else{

〃处理Person类型对象

}

)

==操作符与equals方法

publicbooleanequals(Objectobj){

return(this==obj);

}

Object中的equals。方法利用==实现

Persona=newPerson();Personb=a;b.equals(a)==true;

基本类型使用==时比较值；引用类型使用==时仅比较地址；

如果想要比较引用类型不同实例的值(内容)，必须重写equals方法

举例

publicbooleanequals(Objecto){

if(oinstanceofCircle){

returnradius==((Circle)o).radius;

)

else

returnfalse;

}

Circlea=newCircle(a);

Circleb=newCircle(ulv);

a!=b和a.equals(b)==true同时成立

toString。方法

任何Java类都是Object的子类

Object定义了一个toString()方法，它返回一个实例(对象)所属类的名

称@该对象在内存的地址；

System.out.println(person);

等价于System.out.println(person.toStringO);

同样："Person:"+person;

等价于"Person:"+person.toString();

抽象类

在有些情况下，可以暂时不实现类的某个成员方法，这时可以用

abstract关键字修饰类、以及相应的方法。

以abstract修饰的类称为抽象类，以abstract修饰的方法称为抽象方

法

不能对抽象类直接进行实例化。在子类中可以实现父类的抽象方法,

只有子类实现(覆盖)了父类所有的抽象方法，那么才能创建子类的对

象,否则子类仍然是一个抽象类，也就是说也需要用关键字abstract

修饰

抽象类也可以不包含任何抽象方法，但抽象方法必须在抽象类(或接

口)中

最终类

final修饰的类是最终类，不能被继承，如String,Math

final修饰的方法不能被重写/覆盖

有关final变量的说明：

final变量是常量

可仅设置一次final变量，但是赋值可独立于声明而发生，这称之为

空final变量。即，如果final变量不在其声明中被初始化；其初始

化被延迟：

空final实例变量必须在构造方法中被赋值。

空final局部变量可在方法的主体内随时被设置。

它仅可设置一次。

接口

声明接口

[public]interface（接口名〉[extends（父接口＞]{

[public][static][final]〈数据类型＞（变量＞=＜值＞；

[public][abstract]（数据类型＞＜方法名＞（[＜参数＞]）;

}

声明实现接口的类implements

Java类只支持单继承，但是可以实现多个接口

接口的特点：

接口以及接口中成员的访问权限都是public

接口中的成员方法都是公有的、抽象的

接口中所有的方法都必须被实现接口的类覆盖

接口中的成员变量都是常量，声明时必须赋值

接口不能被实例化

Java异常

错误(Error):JVM系统内部错误、资源耗尽等严重情况

违例(Exception):其它因编程错误或偶然的外在因素导致的一般性问

题，例如：对负数开平方根;访问null;试图读取不存在的文件;网络连

接中断；

Java异常举例

publicclassSamplel{

publicstaticvoidmain(String[]args){

Stringfriends[]={"lisa",''bily","kessy"};

for(inti=0;i<5;i++)

System.out.println(friends[i]);

System.out.println("\nthisistheend");

}

}

Java异常类层次

常见异常

RuntimeException

错误的类型转换

数组下标越界

空指针访问

lOExeption

从一个不存在的文件中读取数据

越过文件结尾继续读取

连接一个不存在的URL

异常处理机制

Java程序的执行过程中如出现异常，会自动生成一个异常类对象，该

异常对象将被提交给Java运行时系统，这个过程称为抛出(thro