第5章面向对象高级特性

测验（20151012）classTest{publicstaticvoidmain(Stringargs[]){

Personp1=newPerson("李娜",1982);

Personp2=newPerson("彭帅",1986);

if(p1.getBirth()<p2.getBirth())

System.out.println(

p1.getName()+"比"+

p2.getName()+"年龄大");

}}请写出Person类的定义。第五章

面向对象高级特性2015-10-135.1变量多态1.变量多态类型为X的参考变量，其指向的对象类型既可以是X，也可以是X的子类如：Studentx=new

Collegian();Studenty=newStudent();【多态例5-1】classStudent{StringstudentNo,name;

Student(Stringsn,Stringnm){studentNo=sn;name=nm;}voidshowInfo(){System.out.println

("学号："+studentNo);System.out.println

("姓名："+name);}}classCollegianextendsStudent{Stringmajor;Collegian

(Stringsn,Stringnm,Stringmj){

super(sn,nm);

major=mj;}voidshowInfo(){super.showInfo();System.out.println("专业："+major);}}【多态例5-1】classtest{publicstaticvoidmain(Stringargsp[]){Students1,s2;s1=newStudent("651003","王五");s1.showInfo();s2=newCollegian("0810123","张三","计算机");System.out.println("姓名："+);System.out.println("专业："+s2.major);s2.showInfo();}}【分析例5-1的问题】出错的语句：

System.out.println("专业："+s2.major);改为：

System.out.println("专业："+((Collegian)s2).major);原因：通过对象名访问成员变量时，取决于该对象声明时的类型，因此s2声明时是Student类型，因此访问major会出错；而通过对象名调用方法时，则取决于该对象实际的类型，因此s2.showInfo()是调用的子类的方法。2.补充几个实例

理解覆盖和隐藏的区别(2.1)——实例方法能够被覆盖classSuper{

Stringname(){return“mother";}}classSubextendsSuper{

Stringname(){return“baby";}}

(2.1)——实例方法能够被覆盖classTest{publicstaticvoidmain(String[]args){

Super

s=new

Sub();System.out.println(());}}输出:baby(2.2)——静态方法不能被覆盖classSuper{

staticStringname(){return“mother";}}classSubextendsSuper{

staticStringname(){return“baby";}}(2.2)——静态方法不能被覆盖classTest{publicstaticvoidmain(String[]args){

Super

s=new

Sub();System.out.println(());}}输出:mother原因静态方法在编译时根据调用该方法的类或对象所属的类决定实例方法在运行时根据对象所属的类决定例如：Supers=newSub();编译时s是Super类的对象，而运行时s指向Sub类的对象(2.3)——属性的隐藏classBase{intx=1;staticinty=2;}classSubclassextendsBase{intx=4;inty=5;}(2.3)——属性的隐藏publicclassTest{publicstaticvoidmain(String[]args){

Subclass

s=newSubclass();System.out.println(s.x+""+s.y);}}输出什么？修改(2.3)：(2.3')publicclassTest{publicstaticvoidmain(String[]args){Base

s=newSubclass();System.out.println(s.x+""+s.y);}}输出什么？原因：编译时根据类或对象类型决定总结父类的实例方法被子类的同名实例方法覆盖父类的静态方法被子类的同名静态方法隐藏父类的实例变量和类变量(static)可以被子类的实例变量和类变量隐藏(2.4)classBase{intx=1;staticinty=2;Stringname(){return"mother";}staticStringstaticname(){return"staticmother";}}classSubclassextendsBase{intx=4;inty=5;Stringname(){return"baby";}staticStringstaticname(){return"staticbaby";}}(2.4)publicclassTest{publicstaticvoidmain(String[]args){Subclasss=newSubclass();System.out.println(s.x+""+s.y);System.out.println(());System.out.println(s.staticname());Basess=s;System.out.println(ss.x+""+ss.y);System.out.println(());System.out.println(ss.staticname());}}隐藏和覆盖的区别将子类对象转换为父类对象(直接赋值)后，可以访问被隐藏的变量和方法(编译时根据类型决定)，但是不能访问被覆盖的变量和方法(运行时根据类型决定)。3.instanceof操作符

修改(2.4)可以根据对象所属的类进行不同的处理：

publicstaticvoidmain(String[]args){Basess=newSubclass();if(ssinstanceofSubclass){System.out.print(ss.x+""+ss.y);System.out.print(());System.out.print(ss.staticname());}}还存在问题？classBase{intx=1;staticinty=2;}classSubclassextendsBase{intx=4;inty=5;intz=9;}编译出错publicstaticvoidmain(String[]args){Basess=newSubclass();if(ssinstanceofSubclass){System.out.print(ss.z);}}解决方法——对象类型转换publicstaticvoidmain(String[]args){Basess=newSubclass();if(ssinstanceofSubclass){System.out.print(((Subclass)ss).z);}}对象类型转换

——对(2.2)的修改classSuper{staticStringname(){return"mother";}}classSubextendsSuper{staticStringname(){return"baby";}}对象类型转换

——对(2.2)的修改classTest{publicstaticvoidmain(String[]args){Supers=newSub();System.out.println(((Sub)s).name());}}对象类型转换

——对(2.3’)的修改classBase{intx=1;staticinty=2;}classSubclassextendsBase{intx=4;inty=5;}对象类型转换

——对(2.3’)的修改publicclassTest{publicstaticvoidmain(String[]args){Bases=newSubclass();System.out.println(((Subclass)s).x+""+

((Subclass)s).y);}}对(2.4)的修改publicstaticvoidmain(String[]args){Basess=newSubclass();if(ssinstanceofSubclass){System.out.print(ss.x+""+

ss.y);System.out.print(());System.out.print(ss.staticname());}}将红色的ss都改为((Subclass)ss)，才可以得到子类的x和y，调用子类的静态方法staticname()5.1.2多态的用途1——异类收集classAnimal{publicvoideat(){}}classDogextendsAnimal{publicvoideat(){System.out.println("狗吃骨头");}}classCatextendsAnimal{publicvoideat(){System.out.println("猫吃老鼠");}}classWolfextendsAnimal{publicvoideat(){System.out.println("吃喜羊羊");}}5.1.2多态的用途1——异类收集classTest{publicstaticvoidmain(Stringargs[]){

Animalaa[]=newAnimal[3];aa[0]=newDog();aa[1]=newCat();aa[2]=newWolf();for(inti=0;i<3;i++){aa[i].eat();}}}5.1.2多态的用途1——参数传递classAnimal{publicintlegs;publicAnimal(intlegs){this.legs=legs;}}classDogextendsAnimal{publicStringname;publicDog(Stringname){super(4);=name;}}classWolfextendsAnimal{publicWolf(){super(4);}}5.1.2多态的用途1——参数传递classtest{publicstaticvoidmain(Stringargs[]){Animalaa[]=newAnimal[2];aa[0]=new

Dog("mike");aa[1]=new

Wolf();for(inti=0;i<2;i++)showInfo(aa[i]);}staticvoidshowInfo(Animala){System.out.println(a.legs);if(ainstanceofDog)System.out.println(((Dog)a).name);}}5.2非访问控制符5.2.1static

1.类变量/静态变量【例5-8】publicclassscope{staticinta;intb;publicstaticvoidmain(Stringargs[]){a++;scopes1=newscope();s1.a++;s1.b++;scopes2=newscope();s2.a++;s2.b++;scope.a++;}}1a1bs12a1bs23a4a【补充实例】publicclassPerson{privateintperson_No;//人员编号public

static

intnextperson_No=1000;//下一个编号publicPerson(){person_No=++nextperson_No;

}}【补充实例】

classTest{publicstaticvoidmain(Stringargs[]){Personc1=newPerson();Personc2=newPerson();}}【补充实例】publicclassPerson{privateintperson_No;publicstatic

intnextperson_No=1000;publicPerson(){person_No=++nextperson_No;

}publicintgetPerson_No(){returnperson_No;}}【补充实例】classTest{publicstaticvoidmain(Stringargs[]){Personc1=newPerson();Personc2=newPerson();System.out.println(“c1:nextperson_No”);System.out.println(c1.nextperson_No);System.out.println(“c1:person_No”);System.out.println(c1.

getPerson_No());…}}Person+nextperson_No:int=1000-person_No:intc1:Clerkperson_No=1001c2:Clerkperson_No=1002《实例》《实例》在这个示例中，为创建的每个对象分配了一个唯一的序列号，从1000开始向上递增。变量nextperson_No在所有实例间共享，因此当一个对象的构造器增加nextperson_No的值时，下一个创建的对象就可接收到这个增加的值。类属性说明使用static来标记的变量是共享于类的所有实例的变量。例如：可以使用该变量作为实例间通信的基础，或者跟踪已创建的实例数。如果static变量未被标记为private，那么可从类外访问它。这样，不需要类的实例，就可通过类名引用它。publicclassOtherClass{publicvoidincrementNumber(){Person.nextperson_No++;}}类属性的使用API中：如Math.PI(不用创建Math类的对象就可以使用PI这个类属性)作为全局变量，即只想用一个存储区域来保存特定的数据。无论创建多少个对象，甚至不创建对象都可以使用。思考：1.银行卡的年费2.排队机银行卡举例publicclassBankCard{privateStringCardNO;//卡号…

publicstaticdoubleannual_fee;//年费}补充实例

classPerson{privateintperson_No;privatedoubleperson_salary;publicstaticintnextperson_No=1000;

publicstaticdoubleperson_lowsalary=280;//最低工资

publicPerson(doublesalary){person_No=++nextperson_No;person_salary=person_lowsalary+salary;}publicintgetPerson_No(){returnperson_No;}}2.类方法/静态方法类方法示例

classPerson{privateintperson_No;

publicstaticintnextperson_No=1000;

publicPerson(){person_No=++nextperson_No;}publicintgetPerson_No(){returnperson_No;}

publicstaticintgetNextperson_No(){returnnextperson_No;}}使用类名访问静态方法publicclassTest{publicstaticvoidmain(Stringargs[]){System.out.println(“Numberofpersonis”+Person.getNextperson_No());

Personc1=newPerson();System.out.println(“Numberofpersonis”+Person.getNextperson_No());}}static方法说明main()方法是static方法，因为执行main方法时，JVM并不创建类的实例。因此如果有成员数据，必须创建对象来访问它。如：Math类的运算方法都定义为static，可以直接通过Math.方法名()来访问。static方法说明除了局部变量、static属性及其参数外，static方法不能访问任何变量。如果试图访问非static属性会引起编译器错误。非static属性绑定到一个实例上并且只有通过实例引用才能访问。错误的例子

classPerson{privateintperson_No;publicstaticintnextperson_No=1000;publicPerson(){person_No=++nextperson_No;}publicintgetPerson_No(){returnperson_No;}

publicstaticintgetNextperson_No(){returnperson_No;//编译错误}}判断哪些语句错误？

classTest{staticintnum;intc;publicstaticvoidmain(Stringargs[]){num=100;c=100;}staticvoidss(){num=100;c=100;}voidtt(){num=100;c=100;}}正确的写法classTest{staticintnum;intc;publicstaticvoidmain(Stringargs[]){num=100;

Testt=newTest();t.c=100;}}分析该例，找出错在哪儿？classInstanceTest{intVariable;staticpublicintmethod(){returnVariable;}staticpublicvoidmethod2(intvariable){this.Variable=variable;}}静态初始化器静态初始化一个类可以在“静态块”中（而非方法体内）包含代码静态块代码仅在加载类时执行一次如果类中包含多个静态块，它们将被按照在类中出现的顺序执行示例1

classCount{publicstaticintcounter;static{counter=10;}}publicclassTest{publicstaticvoidmain(Stringargs[]){System.out.println(“counter=”+Count.counter);}}

示例2

classss{static{System.out.println(“hi”);}}publicclassTest{publicstaticvoidmain(Stringargs[]){sst1=newss();sst2=newss();sst3=newss();}}初始化实例变量的初始化——构造函数类变量(static变量)的初始化——静态初始化器作业编写一个例子，实现多态，内容自选：如图形类的例子、学生类的例子等等。5.2.2final1.最终类final类不能被子类化。如：类java.lang.String是final类，这样做是出于安全的考虑。如果方法引用一个字符串，那么它就是一个String类的串，而不是String修改后的可能已经改变的子类的串。final类不能有子类

finalclassVeryVeryGoodClass{}classGeneralextendsVeryVeryGoodClass{}编译错误2.最终方法标记为final的方法不能被覆盖。出于安全的考虑，如果方法的实现不应改变，而且对对象的一致性状态很重要，则可以创建一个final方法。final方法不能被覆盖

classparent{publicfinalvoidtt(){}}classchildextendsparent{publicvoidtt(){}}编译错误3.最终变量final类型的变量代表常量，只能一次赋值。如：publicclasstest{publicstaticvoidmain(Stringargs[]){finalintx;x=100;x=200;//出错}}5.2.3abstract1.抽象类抽象类：只能被继承，不能实例化的类。定义格式：abstractclass类名{}2.抽象方法abstract修饰的方法是抽象方法，也就是只定义了方法头部，没有方法体。定义格式为：

abstract返回值类型方法名([参数表]);改写动物例子1abstractclassAnimal{publicabstractvoideat();}classDogextendsAnimal{publicvoideat(){System.out.println("狗吃骨头");}}classCatextendsAnimal{publicvoideat(){System.out.println("猫吃老鼠");}}classWolfextendsAnimal{publicvoideat(){System.out.println("吃喜羊羊");}}3.抽象类和抽象方法的关系抽象类不一定含有抽象方法，但含有抽象方法的类一定是抽象类。如下例：abstractclassfather{

abstractvoidtt();voidtt1(){System.out.println("father"); }}3.抽象类和抽象方法的关系如果子类没有实现抽象类中所有的抽象方法，那么子类要定义为抽象类。如下例的son就应该定义为抽象类。abstractclassfather{abstractvoidtt();

abstractvoidtt1();}classsonextendsfather{voidtt(){System.out.println("son"); }}5.3接口5.3.1说明Java通过接口来弥补它单重继承的不足接口之间是多重继承一个接口可以有多个父接口一个类可以实现多个接口5.3.2接口的定义接口使用interface关键字声明接口中只能包含：抽象方法：publicabstract常量：publicstaticfinal常量和方法的修饰符均可以省略【补充实例】假设一组对象有相同的能力：它们都能飞。可以构造一个公有接口，称为Flyer，它支持三个操作：takeOff、land和fly。《接口》Flyer+takeOff()+land()+fly()+takeOff()+land()+fly()AirplaneFlyer接口的定义publicinterfaceFlyer{publicvoidtakeOff();publicvoidland();publicvoidfly();}5.3.3接口的实现class类名implements接口名列表{类体}类实现接口——首先要继承接口，然后再重写方法体(必须实现接口中每个方法)如果一个类同时实现多个接口，接口名之间用逗号隔开【Airplane实现Flyer接口】publicclassAirplaneimplementsFlyer{publicvoidtakeOff(){...}publicvoidland(){...}publicvoidfly(){...}}Flyer接口的多重实现《接口》Flyer+takeOff()+land()+fly()+takeOff()+land()+fly()Airplane+takeOff()+land()+fly()+buildNest()+layEggs()Bird+takeOff()+land()+fly()+leapBuilding()+stopBullet()Superman【说明1】接口支持多重继承，一个子接口可以有多个父接口。如：interfacexx{publicvoidtt();publicvoidss();}interfaceyy{publicvoidmm();}interfacezzextendsxx,yy{}【说明2】实现接口时必须将接口中的所有方法都加以实现。否则该类还是抽象类一个类可以实现多个接口扩展子句(extends)必须在实现子句(implements)前示例

classaaimplementsxx,yy{publicvoidtt(){}publicvoidss(){}publicvoidmm(){}}《接口》Flyer+takeOff()+land()+fly()+takeOff()+land()+fly()Airplane+takeOff()+land()+fly()+buildNest()+layEggs()+eat()Bird+takeOff()+land()+fly()+leapBuilding()+stopBullet()+eat()Superman+eat()AnimalVehicle继承和实现的混合Bird类publicclassBirdextendsAnimal

implementsFlyer{publicvoidtakeOff(){/*实现takeOff()方法*/}publicvoidland(){/*实现land()方法*/}publicvoidfly(){/*实现fly()方法*/}publicvoidbuildNest(){/*行为*/}publicvoidlayEggs(){/*行为*/}publicvoideat(){/*覆盖eat()方法*/}}机场类

classAirport{voidgivePermissionToLand(Flyerf){f.land();}publicstaticvoidmain(Stringargs[]){

Flyers1=newAirplane();

Flyers2=newSuperman();Airportaa=newAirport();aa.givePermissionToLand(s1);aa.givePermissionToLand(s2);}}【说明3】接口可以捕获无关联类之间的相似性，而无需强加类关系5.4访问控制符访问控制类中的成员(变量和方法)有四种访问限制：public、protected、default和private类可以是public或default类中成员的四种访问性准则访问控制例1——错误

只能访问同一个类中的private成员importjava.util.Date;classEmployee{

privateStringname;

privatedoublesalary;

privateDatebirthDate;

publicStringgetDetails(){returnname+salary;}}

publicclassTest1{publicstaticvoidmain

(Stringargs[]){Employeex=newEmployee();="Jack";x.salary=5000;System.out.println(x.getDetails());}}Test1.java访问控制例2——

可以访问其他包中的public成员packagexx;importjava.util.Date;publicclassEmployee{publicStringname;publicdoublesalary;publicDatebirthDate;

publicStringgetDetails(){returnname+salary;}}i