第04章java语言面向对象高级程序设计

第4章Java语言面向对象高级程序设 继承 抽象类 抽象方法 接口 内部类与 内部类（Inner this、super和修饰 this..................................................................................................................super关键 Java的修饰 Java的设计模 习题 实验四Java面向对象高级程序设 4章JavaJava修饰符：this、super、final、、static消息通信（CommunicationWith消息的类型可2消息的使用程 4-1: class{privateintID;privateStringname;privateString privateintage;privateStringpublicEmployee(intinID,Stringinname,Stringin ,intinage,Stringindepartment){ID=name= =conversion(in age=inage;department=}publicintgetAge(){returnage;publicvoidsetAge(intage){this.age=age;publicStringgetDepartment(){returndepartment;this.department=}publicintgetID(){returnID;}publicvoidsetID(intid){ID=id;}publicStringgetName(){returnname;}publicvoidsetName(Stringname){=name;publicString (){ ;publicvoid ) = }//下面的“conversion(String privateStringconversion(String )if return"男}}

return"女publicclassMessageDemopublicstaticvoidmain(String[]args)//发送new消息给类Employee，要求创建类Employee的对象employee1Employeeemployee1=newEmployee(10008,"","m",30,"信息中心");//向对象employee1发送修改的的公有消employee1.setName(" //同一对象可接收不同形式的多个消息，产生不同的响应。System.out.println("编号："+employee1.getID()); ："+employee1.getName()); ："+employee1.get ："+employee1.getAge());System.out.println("部门："+employee1.getDepartment());}}运行结果： 控制（AccessJava中的控制主要包括对包、类、接口、类成员和构造方法的控制等方面。除了包的控制由主机系统决定外，其他的控制通过控制符来实现。控制符是一组限定类、接口、类成员（成员变量和成员方法）是否可以被其他类的修饰符。其中类和接口的控制符只有public和默认（default）两种。类成员和构造方法的控制 类控表4-1类的控制符及可见性 默认（default类类的公共控制是指类的控制符为public，它具有跨包性，以支持类的跨Javapublic类（public类public类Java的类是通过包来组织的，定义在同一个程序文件中的所有类都属于同一个包（默认互相和。一般地，处于不同包中的类相互之间是不可见的，而不能互相。只有当某个类的控制符为public时，说明此类作为整体对其他类是可见和可使用的，它才具若跨包public类，则先在它的另一个包中使用import语句引入此public类，然后方能和这个类，以创建这个类的对象，并这个类内部可见的数据成员和它的可见的成员方法。如Java类库中的许多类都是public类，程序员只要在程序中用import语句将其引入后即可。要特别的是，尽管处于不同包中的public类作为整体对其他类只有当public类的数据成员和成员方法的控制符也被为public时，这个类的所public修饰的数据成员和成员方法也同时对其他类是可见的。在程序设计时，若希望某但要的是，当数据成员和成员方法的控制符被为public时，会降低类的封装性程程 4-2:E4_2A.java、package//E4_2A类为public类publicclass{privateintpublicE4_2A()E4_2BobjB1newE4_2B用同一包中的E4_2B类创建对象objB1objB1.setB(100);//objB1对象System.out.println("objB1:b="+objB1.getB());}publicintgetA(){returna;publicvoidsetA(inta){this.a=a;}////classE4_2BprivateintpublicintgetB(){returnb;publicvoidsetB(intb){this.b=b;}packagepublicclassE4_2Demopublicstaticvoidmain(String[]args)E4_2AobjA1newE4_2AE4_2类为public类，能被跨包System.out.println("objA1:a="+E4_2BobjB2newE4_2BE4_2B类为defautl类，不能被跨包E4_2CobjC1=newE4_2C();//同一包中的E4_2C类System.out.println("objC1:c="+}}//E4_2C类为default类，只能在其所在的包中被，而不能被跨classE4_2CprivateintpublicintgetC(){returnc;publicvoidsetC(intc){this.c=c;}运行结果objB1:b=100objA1:a=10objC1:c=1000此它能被已引入p1包中类的p2包中类（如E4_2Demo类和E4_2C）。示例：类的默认控制示例如【例4-2】中的E4_2B类所示，由于p1包中的E4_2B类为default类，而只具有包性，因此它只能被其所在的p1包中的类（如E4_2A类）引用，而不能被尽管已引入p1包中类的p2包中类（如E4_2Demo类和E4_2C）。类成员的控制性）如表4-2所示。表4-2类成员的控制符及可见 域域public类型的类成员可被同一类、同一包中子类与非子类和不同包中的子类与非子类的代码。或者说public类成员可被能够它所在的包的任何代码所，它不受类pubpac1包中publicE4_3A中定义public类型的成员变量和成员方法，然后pubpac2包中引pubpac1包中的类defaultE4_3B中构造方法创建E4_3A类的实例，并其中的public成员，实现对public类成员的跨包，最后在主类PublicDemo中创建E4_3B类的实例后，实现对同包类的public类成员的。其实现程序4-3:E4_3A.java、packagepublicclassE4_3Apublicpublicintpubapublic成员变publicintgetPubareturnpubapublic成员方publicvoidsetPuba(intpubapublic成员this.puba=}}packageimportpubpac1.*;//引入pubpac1包的publicpublicclassPublicDemopublicstaticvoidmain(String[]args)E4_3BobjE4_3BnewE4_3B用同包中的E4_3B类实例化objE4_3BobjE4_3B.pubb=1000;//objE4_3B对象中public成员变量//objE4_3B对象中public成员方法getPubb()System.out.println("objE4_3BpubbobjE4_3B.getPubb());}}classE4_3Bpublicintpubbpublic成员变publicintgetPubbpublic成员方return}publicvoidsetPubb(intpubbpublic成员this.pubb=}publicE4_3BE4_3BE4_3AobjE4_3AnewE4_3A用异包中的public类E4_3A实例化objE4_3AobjE4_3A.setPuba(10);//objE4_3A对象中public成员方法System.out.println("objE4_3A:puba="+objE4_3A.getPuba());objE4_3A.puba=100;//objE4_3A对象中public成员变量System.out.println("objE4_3A:puba="+objE4_3A.getPuba());} 运行结果objE4_3A:puba=10objE4_3A:puba=100objE4_3B:pubb=1000protected类型的类成员可被同一类、同一包中子类与非子类和不同包中的子类的代码访问。或者说protected类成员可被除不同包的非子类以外的其他能够它所在的包的任何代程程 4-4:E4_4A.java、packagepublicclassE4_4ApublicpublicintgetProareturnproapublic成员方protectedvoidsetProa(aproaprotected成员}packageimportpropac1.*;//引入propac1包的publicpublicclassProtectedDemo主publicstaticvoidmain(String[]args)使用同包中default类E4_4B类实例化objE4_4BE4_4BobjE4_4B=newE4_4B(); objE4_4B.prob=10;//允许同一包中的非子类对象objE4_4B中的protected成员方法getProb()System.out.println("objE4_4B:prob="+objE4_4B.getProb());}}classE4_4BprotectedintgetProbprotected成员方return}protectedvoidsetProb(intprobprotected成员方b=}publicE4_4BE4_4B类的构造方 //用异包中的public类E4_4A实例化 E4_4AobjE4_4A=new 不允许不同包中的非子类对象objE4_4A中的protected成员方法// 不允许不同包中的非子类对象objE4_4A中的protected成员变量//objE4_4A.proa=System.out.println("objE4_4A:proa="+} 运行结果objE4_4A:proa=0objE4_4B:prob=propac1publicE4_4Aprotected类型的成员变量和成员propac2propac1defaultE4_4B中构造方法创建E4_4A类的实例，并试图跨包其中的protected成员而不成，最后在主类ProtectedDemo中创建E4_4B类的实例后，实现了对同包类的projected成员的。程 4-5:E4_5A.java、 packagepublicclassE4_5ApublicpublicintgetDefareturndefapublic成员方voidsetDefa(intdefathis.defadefadefault} packageimportdefpac1.*;//引入defpac1包的publicpublicclass emo主publicstaticvoidmain(String[]args)使用同包中default类E4_5B类实例化objE4_5BE4_5BobjE4_5B=newE4_5B(); 允许同一包中的非子类对象objE4_5B中的default成员变量objE4_5B.defb=//允许同一包中的非子类对象objE4_5B中的default成员方法getDefb()System.out.println("objE4_5Bdefb}}classE4_5BintgetDefbreturndefbdefault成员voidsetDefb(intdefbthis.defbdefb;}//default成员方publicE4_5BE4_5B类的构造方使用异包中的public类E4_5A实例化objE4_5AE4_5AobjE4_5A=newE4_5A(); 不允许不同包中的非子类对象objE4_5A中的default成员方法// 不允许不同包中的非子类对象objE4_5A中的default成员变量//objE4_5A.defa=System.out.println("objE4_5A:defa="+} 运行结果objE4_5A:defa=0objE4_5B:defb=法defpac2包中引入defpac1包中的类defaultE4_5B中构造方法E4_5A类的实例，并试图跨包其中的default成员而不成，最后在主类Defauemo中创建E4_5B类的实例后，实现了对同包类的default成员的。程程 4-6:E4_6A.java、packagepublicclassE4_6Apublicprivateintpria46private成员变publicintgetPriareturnpriapublic成员方voidsetPria(intpriathis.priapriaprivate}packageimportpripac1.*;//引入pripac1包的publicpublicclassPrivateDemo主publicstaticvoidmain(String[]args)使用同包中default类E4_6B类实例化objE4_6BE4_6BobjE4_6B=newE4_6B(); 不允许同一包中的非子类对象objE4_6B中的private成员变量与成员方//objE4_6B.prib=////允许同一包中的非子类对象objE4_6B中的private成员方法getPrib()System.out.println("objE4_6Bprib}}classE4_6Bprivateintprib;/private成员变intgetPribreturnpribdefault成员privatevoidsetPrib(intpribprivatethis.prib=}publicE4_6BE4_6B类的构造方使用异包中的public类E4_6A实例化objE4_6AE4_6AobjE4_6A=newE4_6A(); 不允许不同包中的非子类对象objE4_6A中的private成员方法// 不允许不同包中的非子类对象objE4_6A中的private成员变量//objE4_6A.pria=System.out.println("objE4_6A:pria="+} 运行结果objE4_6A:pria=46objE4_6B:prib=0制，请见4.3.3~4.3.4节相关内容。继承的新类。由继承而得到的类称为子类(Subclass)，被直接或间接继承的类称为父类（FatherClass，采用继承的机制来组织、设计系统中的类，可以使得程序结构清晰、降低编码和的Java仅支持单继承，而不支多重继承，即每个子类只允许有一个父类，而不允许有多个父类。但是可以从一个父类中生成若干个子类。继承不改变成员的权限，父类中的公有成员、保护成员和默认成员，在子类中仍然是公有成员、保护成员和默认成员。Java中的多创建子类Java中，通过在类的中加入extends子句来创建一个类的子类，其一般格式是class<子类名>[extends父类名]{ }protected和default的成员变量和成员方法，但是不能继承权限为private的成员变量和方classA类A继承类inta1=privateinta2=publicintgetA2(){returna2;}classBextendsA类B继承类A,间接继承类 类B继承父类A的非私有成员：a1和getA2()，而私有成员a2不能被继 intb1= privateintb2=publicintgetB2(){returnb2; Ajava.lang.ObjectJavaObject类的子类。继承的传递性C应包含类A和类B的非私有成员，以及类C自身的成员。【例4-7】类继承的程 4-7: packagepublicstaticvoidmain(String{Cc=newSystem.out.println("c.a1="+c.a1+"\nc.getA2()="++"\nc.b1="+c.b1+"\nc.getB2="+ //System.out.println("c.a2="+c.a2+"\nc.b2="+}}classA类A继承类inta1=privateinta2=publicintgetA2(){returna2;}classBextendsA类B继承类A,间接继承类 类B继承父类A的非私有成员：a1和getA2()，而私有成员a2不能被继intb1=privateintb2=publicintgetB2(){returnb2;}classCextendsB类B继承类C,间接继承类A和类 运行结果c.a1c.getA2()c.b1c.getB2子类对象的初始化系统规定用this()表示当前类的构造方法，用super()表示直接父类的构造方法。实际上，除super()的构造方法的语句必须放在第一条语句，并且this()super()最多只可调用其中一条。【例4-8】子类对象的初始化，掌握this()和super()程 4-8: packagepublicstaticvoidmain(String{Bb=newB(1,2,System.out.println("a="+b.getA()+"\nb="+b.getB()+"\nc="+}}classA类privateinta私有成publicA无参构造方publicA(inta)this.aa;带一个参数的构publicintgetA(){returna;}classBextendsA类B继承类Ａprivateintb私有成员变量privateintc;publicB无参构造方publicB(intb)this.bb带一个参数的构publicB(inta,intb)带两个参数的构造方 但super()与this()只能取其一，且必须位于所在构造方法的第一//this.b=}publicB(inta,intb,intc)带三个参数this(ab调用类B自身的“publicB(intaintb)”构造方this.c=}publicintgetB(){returnb;publicintgetC(){returnc;}运行结果a=b=c=子类继承父类的规则的成员变量和成员方法，其继承规则如表4-3所示。4-3 public成protected成private成○○○○○量和成员方法private成员。程 4-9: packagepublicstaticvoidmain(Stringargs[])BobjB=newB();//实例化类BobjB.setA1(10);//调用父类A中protected方法objB.setA2(100调用父类A中protected方法objB.setB1(1000);//调用子类B中public方法//类A中的private变量a1不能被子类B//System.out.println(objB.a1);System.out.println(objB.getA1调用父类A中public方法System.out.println(objB.a2);//调用父类A中默认变量//不能直接类B中的被private封装的变//System.out.println(objB.b1);}}classA类privateinta11私有inta22默认变publicintgetA1returna1;公有方protectedvoidsetA1(inta1){this.a1=a1;}//保护方法publicintgetA2(){returna2; }//公有方法protectedvoidsetA2(inta2){this.a2=a2;}//保护方法}classBextendsA同一包中的类B继承类 被继承的有：默认类型的a2、protected类型的setA1()、//和public类型的getA1()、//不能被继承的是：private类型的privateintb1=protectedintgetB1(){returnb1;publicvoidsetB1(intb1){this.b1=b1; 运行结果员方法，将其作为子类的成员，但不能继承父类的默认和private成员。【4-10publicprotected成员，且不同包中的非子类不能调用protected成员，只有子类才能调用protected成员。程 4-10: packagepublicstaticvoidmain(String{BobjB=newB();//实例化类BBobjnewB(objB实例化类B//***objB.setA2(9);//非子类不能调用不同包protected方法objB.setB1(7);//调用子类B中public方法//System.out.println(objB.a1);());////System.out.println(objB.a2);//不能调用父类A中的默认变 调用父类A中public方//不能直接类B中的被private封装的变//System.out.println(objB.b1);}}classBextendsA同一包中的类B继承类//被继承的有：protected类型的a2、setA1()、//和public类型的getA1()、//不能被继承的是：private类型的privateintb1=publicB(){}//无参构造方publicB(BobjB带一个参数的构造方//不同包中的子类可调用父类中protected方//不同包中的子类可调用父类中protected方}protectedintgetB1()return}publicvoidsetB1(intb1)this.b1= }packagepublicclassA类privateinta11私有inta22默认变publicintgetA1公有方return}protectedvoidsetA1(inta1保护方this.a1=}publicintgetA2公有方return}protectedvoidsetA2(inta2保护方this.a2=}}运行结果567上与下对Java允许父类对象和子类对象在一定条件下之间相互转换。其相互转换规则类对象是子类对象的上对象；②强制转换：父类对象赋值给子类对象时，必须将父类对。ABb=new //ab的上转换对象（子类对象可自动转换成父类对象）则称父类对象a是子类对象b的上对象。BAa=newb=(B)a; //ba的下转换对象（父类对象须强制转换成子类对象）则称子类对象b是父类对象a的下对象。上对象的特性是：①上对象不能操作子类新增的成员变量和成员方法。②上对转对象该变量时，的是父类中被隐藏的变量。⑤可以将对象的上对象再强制转【例4-11】上对象的使用程 4-11: packagepublicstaticvoidmain(Stringargs[])Aobja;//类A的对象变量Bobjb;//类B的对象变量obja=newB();//对象obja为子类B对象的 //不论父类中的成员变量被子类隐藏与否,上对象始终父类中的成员变量（包括被隐藏的变量System.out.print("对象obja:\n"a1obja.a1ta2obja.a2obja.arithmeticOperation(10,//objbBobja将上转对象强制转换为子类对System.out.print("\n强制转换对象objb:\na1objb.a1ta2objb.a2objb.arithmeticOperation(10,System.out.println("c1="+}}classA类inta1= inta2=publicvoidarithmeticOperation(intx,int{System.out.println("x+y="+(x+}publicvoidfatherMethod()System.out.println("调用父类A}}classBextendsA类B继类inta21000隐藏（重写）父类的成intc110000子类新增的成员变System.out.println("调用子类B }运行结果a1=10a2= x+y=a1=10a2= x+y=c1=10000对于一个类型的变量，运行时Java虚拟机按照它实际的对象来处理。例例3-2所示。在运行时环境中，通过类型变量来所对象的方法和属性时，Java虚①实例方法与变量实际的对象的方法绑定，这种绑定属于动态绑定，因为是在运行时由Java虚拟机动态决定的。继承的使用方法继承：把类为final类；把此类的所有构造方法为private类型，然后通过一些静态继承与组合区别组合关系和继承关系相比，前者最主要的优势是不会破坏封装。若类A与类C之间为组合关系C封装实现，则其仅A提供接口；若AC之间为继承关系C会向类A部分实现细节。组合关系虽然不会比继承关系减少编码量，但由于组合关系会降多态性多态性的概念示不同的实现。Java的多态性主要表现在三个方面，①方法重载：指可在一个类中定义多个量覆盖，即子类可以隐藏与父类中的同名成员变量。多态性大大提高程序的抽象性和简洁性。Java中的方法重载属于静态多态。Java中的方法覆盖属于动态多态。由于子类继承了父类的非私有属性，所以子类对象可以作为父类对象使用（即上对方法重载（Method例如：add(方法可能有以下三个版本：publicintadd(intx,inty){returnx+}publicdoubleadd(doublex,doubley){//returnx+}publicdoubleadd(doublexdoubleydoublez){//returnx+y+}的是哪个方法。方法重载属于Java的静态多态，当Java在编译阶段调用一个重载方法时，形参【例4-12】方法重载的程 4-12: Packagepublicstaticvoidmain(Stringargs[])inta=10,b=20,z=ArithmeticOperationao=new//ao.add(ab)与add(intx,inty)精确匹配，而不调用add(doublex,doubley)System.out.println("ao.add(a,b)="+ao.add(a,b));ao.add((doubleadoubleb)与add(doublex,doubley)精确匹+ao.add((double)a,(double)//ao.add(a,(double)b)与add(intx,doubley)精确匹配System.out.println("ao.add(adoublebao.add(adoubleb));ao.add((doubleab)与add(doubleyintx)精确匹System.out.println("ao.add((double)a,b)="+ao.add((double)a,////换为doulbe类型，然后与add(doublexdoubley,doublez)精确匹配System.out.println("ao.add(a,b,z)="+ao.add(a,b,z));}}publicintadd(intx,inty)System.out.println("调用：publicintadd(intx,intreturnx+}publicdoubleadd(intx,int{return(double)(x+ publicdoubleadd(doublex,doubley){//参数类型不同重载System.out.println("调用：publicdoubleadd(doublexdoubley)");returnx+y;}publicdoubleadd(intx,doubley){//参数类型不同重载System.out.println("调用：publicdoubleadd(intx,doubley)");return(double)(x+y);}publicdoubleadd(doubley,intx参数顺序不同重System.out.println("调用：publicdoubleadd(doubley,intreturn(double)(x+}publicdoubleadd(doublex,doubleydoublez参数个数不同重returnx+y+} 运行结果调用：publicintadd(intx,inty)ao.add(a,b)=30调用：publicdoubleadd(doublexdoubleao.add((double)a,(double)调用：publicdoubleadd(intx,doubley)ao.add(a,(double)b)=30.0调用：publicdoubleadd(doubleyintao.add((double)a,调用：publicdoubleadd(doublexdoubley,doublez)ao.add(a,b,z)=60.0程 4-13: packagepublicstaticvoidmain(Stringargs[])调用publicStudent()构造方法实例化s1Students1=newStudent();//调用成员方法Student()输出学生对象s1的信调用publicStudent(StringSname)构造方法实例化s2Students2=newStudent("");//调用成员方法Student()输出学生对象s2的信调用publicStudent(StringSnoStringSname构造方法实例化s3Students3=newStudent("9","");//调用成员方法Student()输出学生对象s3的信}}classStudent{//类StudnetprivateStringSno;//学号privateStringSname;//privatestaticintcount0publicvoidStudent(){//此为一般成员方法（因为构造方法无返回值类型）System.out.println("调用方法：publicvoidStudent()显示学生信息！");System.out.println("学号："+Sno+"\t\t："+Sname);}System.out.println("调用构造方法 Sno=new Sname未名}publicStudent(StringSname){//带一个参数的构造方法System.out.println("调用构造方法：publicStudent(StringSname)");Sno=newthis.Sname=}publicStudent(StringSnoStringSname带两个参数的构this.Sno=this.Sname=} 运行结果调用构造方法：public调用方法：publicvoidStudent()显示学生信息！ 调用构造方法：publicStudent(StringSname)调用方法：publicvoidStudent()显示学生信息！ 调用构造方法：publicStudent(StringSnoString调用方法：publicvoidStudent()显示学生信息！ 方法覆盖（Method类中的重写方法、继承自父类的方法（未重写）和子类新增的方法这三种。②若要父类中被覆盖的成员方法，则必须使用super关键字来表示父类对象，其一般调用格式是：super.<方法名>([实参表【 4-14】方法覆盖的使用和父类中被覆盖方法的调用程 4-14: packagepublicclassMethodOverrideDemo publicstaticvoidmain(Stringargs[]) 创建一元二次方程实例：5x^2+6x+1TwoVariableEquationtwe=newTwoVariableEquation(5,6,System.out.println("twe.getX1()="+twe.getX1());System.out.println("twe.getX2()="+twe.getX2());}}doubledoublepublicOneVariableEquation(doublea,doubleb){this.a=a;this.b=b;publicvoidsetAB(doublea,doubleb){this.a=a;this.b=b;doublegetX1(){return-b/a;}//一元二次方程类TwoVariableEquation继承类doublepublicTwoVariableEquation(doublea,doubleb,doublec)super(a,this.c=}publicvoidsetABC(doublea,doubleb,doublec)调用继承自父类的方法publicvoidsetAB(doubleadoubleb)setAB(a,b);this.c=} 此处“getX1()”可为public、protected和默认，而不能为publicdoublegetX1覆盖父类方 用"super.<方法名>([实参表])"调用被子类覆盖的方法returnsuper.getX1()/2+Math.sqrt(Math.pow(b,2)-4*a*}publicdoublegetX2()returnsuper.getX1()/2-Math.sqrt(Math.pow(b,2)-4*a*}}运行结果twe.getX1()=twe.getX2()=-方法覆盖与方法重载的异同：（1）相同点：①二者都要求方法名相同；②二者都可以用变量覆盖（Variablesuper.<父类变量名>程 4-15: packagepublicstaticvoidmain(Stringargs[])ABobjb=newobja=objb;//obja是objb的上对//上对象始终父类成员变System.out.println("obja.a="+//子类的同名变量a隐藏了父类的变量aSystem.out.println("objb.aobjb.a);objb.setAOfB("若子类执行自己定义的操作时，则使用自己定义的变量。//子类的同名变量a隐藏了父类的变量aSystem.out.println("objb.aobjb.a);System.out.println("objb.b="+objb.b);}}classA{//类AStringa;intb100;publicStringgetA(){returna;publicvoidsetA(Stringa){this.a=a;}classBextendsA类B继承类Stringa;//覆盖（隐藏）父类同名变量a，类型可相同doubleb1000覆盖（隐藏）父类同名变量b,类型可不同publicStringgetAOfB(){returna;}publicvoidsetAOfB(Stringa){this.a=a;publicStringgetAOfA(){//用super被隐藏的父类中的成员变量return"super.a="+}publicvoidgetBOfA(){//用super被隐藏的父类中的成员变量bSystem.out.println("super.b="+super.b);} 运行结果objb.a=objb.a=若子类执行自己定义的操作时，则使用自己定义的变量。super.a若子类执行继承父类的操作，则使用继承自父类的变量。objb.b=1000.0super.b=抽象类与抽象方方法为抽象方法，在Java中含有抽象方法的类就叫抽象类。抽象类和抽象方法是抽象类（ class类名 } 见4.5.2 程程 packagepublic ClassDemopublicstaticvoidmain(String{Aobja;//抽象类A只能用来对象objanewA抽象类A不能实例 Bobjb=newB();//只能用实现了抽象类A的子类B实例 obja=objb;//obja是objb的上对obja.add(100,}}classA{//抽象类不能同时为finalpublicvoidadd(intx,inty)add（）为非抽象方}}classBextendsA覆盖抽象类A的方法publicvoidadd(intx,intpublicvoidadd(intx,inty)System.out.println(x+"+"+y+"="+(x+} 运行结果10+10=100+100=抽象方法 抽象方法是指被修饰的成员方法。抽象方法是一种仅有方法头，而无方法体的一class类名}中只需给出抽象方法名，而不必知体调用哪个方法。抽象方法对外提供了一个共同的接 程程 4-17:packagepublic publicstaticvoidmain(String{Aobja;//抽象类A只能用来对象objanewA抽象类A B objbnewB抽象类B不能实例CobjcnewC只能用实现了抽象类的子类Cobja=objb=objc;obja.add(1000,}}classA含有抽象方法的类必须定义为抽象voidadd(intx,inty);//抽象方法voidsubtract(intx,int}classBextendsA类B继承类覆盖抽象类A的方voidadd(intx,intvoidadd(intx,inty)System.out.println(x+"+"+y+"="+(x+}voidMultiply(intxinty)子类B新增的方System.out.println(x+"*"+y+"="+(x*}} intsubtract(intx,intclassCextendsB类C继承类voidsubtract(intx,inty)System.out.println(x+"-"+y+"="+(x-}voidDivide(intxinty)子类C新增的方System.out.println(x+"/"+y+"="+(x/}}运行结果10+10=10-1=10*10=10/10=100+100=100-10=100*100=1000+1000=1000-100=接口接口的概念进接口可有效地将软件设计分离，使开发者分工明确，提高了软件质量，在面向对象Java中的接口有两种意思：①概念性接口，指系统对外提供的所有服务，类的所有能被外部使用者的方法构成了类的接口。②接口类型：指用interface关毽字定义的接口，它Java中的接口类型（简称接口）实际上是由常量和抽象方法构成的特殊类。在接口定义接口的定义[publicinterface接口名extends父接口名列表 ][native]<类型><方法名>([参数表 异常列表]；//抽象方法说)其中，interface是定义接口的关键字。接口名的首字母大写，若多个单词组成接口名则Java的接口既和继承有关又与多态相关，而且是众多面向对象程序设计语言所不支持的，是JavaJava的难中之难。接口与抽象类在表面上有些相似，如两①接口的控制符有public和默认两种，被public修饰的是公有接口，可被所有类和③接口中的成员方法必须是被public和修饰的，默认都是“public 的方法。若接口中存在native方法（方法体使用非Java语言编写），则该接口需加native修饰④接口中只能包含“publicstaticfinal”类型的成员变量和“public 【例4-18】接口的定义与主要特性。程 4-18: packagepublicstaticvoidmain(String{IAobjIA;//接口IA的 IBobjIB;//接口IB的 IShapeobjIShape;//接口IShape的变量objIShapeCirclecircle=newCircle(3);//实例化一个圆objIA=circle;//使用接口变量来调用方法System.out.println("objIA.getAreaobjIA.getArea());Cylindercylinder=newCylinder(3,2);//实例化一个圆柱体objIB=cylinder;//使用接口变量来调用方法System.out.println("objIB.getGirth()="+objIB.getGirth());objIShape=cylinder;//使用接口变量来调用方法}}interfaceIA接口publicstaticfinaldoublePI3.145926PI常 //public}interfaceIB接口 }//接口的继承性：接口IShaple继承接口IA、interfaceIShapeextendsIAIBdoublegetVolume } CircleextendsOutPutimplementsIA,IBvoidshow(实现抽象类OutPut中抽象方法publicdoublegetAreareturn0.0实现接口IA中的抽象方法//接口IB中的抽象方法getGirth()没有被}classCircle Circle圆类publicCircle(doubleradiusthis.radiusradius构造方publicdoublegetAreareturnPI*radius*radius方法//实现接口中的默认方法必定为public方publicdoublegetGirth(){return2*PI*radius;voidshowSystem.out.println("圆的半径="+radius);System.out.println("圆的面积="+getArea());System.out.println("圆的周getGirth());}} classCylinderextendsOutPutimplementsIShapeprivatedoublehigh新增属性:publicCylinder(doubleradiusdoublehigh构造方this.radius=this.high=}publicdoublegetArea(){return2*PI*radius*(radius+high);publicdoublegetGirth(){return(2*PI*radius);//实现接口IShape中新增的抽象方法publicdoublegetVolume(){return(PI*radius*radius*high);voidshow(){//实现抽象类OutPut中抽象方法show()System.out.println("圆柱体的半径="+radius);System.out.println("圆柱体的高度="+high);System.out.println("圆柱体全面积="+getArea());System.out.println("圆柱体腰围长="+getGirth());System.out.println("圆柱体的体getVolume());}}运行结果圆的半圆的面圆的周长=18.875556圆柱体的半径圆柱体的高度圆柱体全面积圆柱体腰围长圆柱体的体积接口的实现例程 4-19: packageimportpublicclassCharStackDemo主publicstaticvoidmain(Stringargs[])throwsjava.io.IOExceptioncharchoice=0,exit='Y',popchar;DynStackds=newDynStack(10);doif(exit=='x'||exit==do{if(choice!=13&&choice!={System.out.println("ForexampleCharacterStackSystem.out.println1.初始化栈 2.栈判空操作 3.入栈操作 4.出栈操作 5.取栈顶元素 6.栈置空操作 9.退出操作");System.out.print("Chooseone:");}choice=(char)}while(choice<'1'||choice>switch(choice)case'1':{ds.inistack();ds.output();break;case'2':ifSystem.out.println("---当前栈为空System.out.println("当前栈不为空}case'3':ds.output();break;}case'4':popchar=if(popchar==System.out.println("---当前栈为空System.out.println("当出栈元素popchar);ds.output();break;}case'5':if(ds.gettop()==0)System.out.println("当前栈顶元素ds.gettop());ds.output();break;}case'6':{ds.clears();ds.output();break;case'7':System.out.println("当前栈中元素个数ds.current_size());ds.output();break;}case'8':{ds.output();break;case'9':{return;}exit=(char)System.in.read();}while(exit!='x'||exit!=}}interfaceICharStackvoidinistack();//1、初始化栈操作booleanisempty2、栈判空操作voidpush();//3、入栈操作charpop();//4、出栈操作chargettop5、取栈顶元素voidclears6、栈置空操voidoutput8、输出栈中全部元}classDynStackimplementsICharStackprivateinttos栈顶指DynStack(intsize构造方法stck=newchar[size];tos=-1;}publicvoidinistack1、初始化charc=System.out.println("Entercharacters,'q'toquit.");do从键盘读入字tryc=(char)}catch(IOExceptionSystem.out.println("读入错误：}if(c!=13&&c!=10)if(tos==stck.length-1)chartemp[]=newchar[stck.length*2];//doublefor(inti=0;i<stck.length;i++)temp[i]=stck[i];stck=temp;stck[++tos]=c;}stck[++tos]=}}while(c!='q');}publicbooleanisempty2、栈判空操if(tos==-returntrue;return}publicvoidpush3、入栈操charc=System.out.println("输入进栈字符串,'q'toquit.");do读入字tryc=(char)}catch(IOExceptionSystem.out.println("读入错误：}if(c!=13&&c!=10)if(tos==stck.length-1)chartempnewchar[stck.length*2双倍扩for(inti=0;i<stck.length;i++)temp[i]=stck[i];stck=stck[++tos]=}stck[++tos]=}}while(c!='q');}publiccharpop4、出栈操if(tos==-return}

publicchargettop5、取栈顶元if(tos==-return}

returnpublicvoidclears6、栈置空操作tos=-1;}publicintcurrent_size7、求当栈中元素个returntos+}publicvoidoutput8、输出栈中全部元素if(tos==-System.out.println("---当前栈为

for(inti=tos;i>=0;i--)System.out.print(stck[i]+""); }运行结果:(初始化栈操作的结果ForexampleChooseone:Entercharacters,'q'toquit.qEDCB接口与抽象类的比较层次从属接口的势所在④在接中只能有的类常字段，抽象类可以象类却不那么容易，因此接口更有利于软件系统的与重构。内部类与内部类（Inner也可以包含（嵌套）另一个类，称这个被包含的类为内部类（InnerClass）或嵌入类（NestedClassClass套在其它类定义中的类称为顶层类（Top-levelClass。与一般的类相同，内部类也具有自己【例4-20】简单内部类的定义。程 packagepublicclassInnerClassDefinepublicstaticvoidmain(Stringagrs[])//创建外部类OuterClass的实例outOuterClassoutnewOuterClass(); OuterClass.InnerClassin=out.newInnerClass();调用内部类InnerClass的实例in的成员方法icm1()}}classOuterClass定义外部类intocx10;外部类的成员变量publicclassInnerClass定义内部类inticx100内部类的成员变量publicvoidicm1(){//内部类的成员方法icm1()System.out.println("icxofInnerClassisicx);System.out.println("ocxofOuterClassis"+}}}运行结果icxofInnerClassis100ocxofOuterClassis10①在另一个类或者一个接口中一个类，即成员类（MemberClass；②在一个方法Class；③口（InnerInterface；④类和接口可嵌套深度没有限制。类进一步分为静态成员类（StaticMemberClass）（InstanceMemberClass。局部类又分为静态

类 4-1内部类ClassClass中的成员；反之，在内部类中则可以直接它所在外部类的成员，包括静态成员、实例成员及私有成员。实际中，根据内部类在外部类中的位置不同，对内部类的也有所不同，成员类（MemberClass：2）像静态方法或静态变量一样，静态成员类有public、protected、private、default控制静态内部类的不需要通过外部类的实例来创建内部类对象，可直接通过外部类名就可以实现，语法格式是：new外部类名.内部类构造方法();静态成员类的BA的辅助类，且只A所用时，则可B定义A的静态成员类。例如JDKLinkedList类就有Entry静态成员类：import //privatestaticclass{Eelement;Entry<E>next;Entry<E>previous;Entry(Eelement,Entry<E>next,Entry<E>previous)this.element=element;this.next=next;this.previous=previous;}}//}【 4-21】静态成员类的定义、控制、约束与程程 4-21:packagepublicclassStaticMemberClass主publicstaticvoidmain(String[]args)//可直接通过外部类名静态成员类：new外部类名.内部类构造方法()Outer.Inner1inner1=newOuter.Inner1();Outer.Inner2inner2=new//不能使用外部类的实例静态成员//Outer.Inner2inner2=newOuter().newnewOuter.Inner3.Inner4inner4=newnew}}classTestpublicTest()//成员类的控制与成员方法、成员变量的控制相同，见表4-Outer.Inner3inner3=new//Outer.Inner5inner5=new}}classOuterprivateintx=privatestaticinty=publicstaticclassInner1公有静态成员publicInner1()System.out.println("外部类Outer的静态变量y//System.out.println("外部类Outer的静态变量xx); }}protectedstaticclassInner2保护静态成员publicInner2()}}staticclassInner3默认静态成员//publicstaticclassInner4publicInner4()}}publicInner3()}}privatestaticclassInner5私有静态成员publicInner5()}}//staticclassInner6{ }Inner3.Inner4inner4=newInner5inner5=new }}运行结果外部类Outer的静态变量yInner1e4_21.Outer$Inner1@d9f9c3Inner2e4_21.Outer$Inner2@1a46e30Inner3e4_21.Outer$Inner3@addbf1外部类Outer的反射编译器编译静态成员类时，会创建一个名称为“OuterClassName$StaticMemberClassName.classOuterClassName是外部类的类名，StaticMemberClassName是静态成员类的类名，上例中编译后会产生的类文件如下：②实例成员类（InstanceMember 实例成员类的约束：1）实例成员类不能与外部类重名；2）不能在实例成员类中定义atc变量、方法和类（sacfnalsac3）（Interfacesac（pc其实例，其语法格式是：new内部类构造方法();例：设类InnerClassOuterClass的一=newInnerClass(·格式一：外部类实例.new内部类构造方法·格式二：new外部类构造方法new内部类构造方法方法一：OuterClassoutnewOuterClassOuterClass.InnerClassin=out.newInnerClass(方法二：OuterClassInnerClassinnewOuterClassnewInnerClass实例成员类的：一个实例成员类的实例必然属于其外部类的一个实例，在实例成员内部类代码中可用this关键字来实例成员类的实例，若需要获得其所属外部类实例，则需要在this关键字前加上外部类的类名，如“OuterClass.this”的形式。以JDK中集合Collection类库为例，每种Collection类必须提供一个与其对应的迭代器 tor实现以便客户端能以统一的方式遍历任一Collection实例。每种Collection类的I 实现就被定义为该Collection类的实例成员类。例如JDK中 List类的代码片断： List<E>extends Collection<E>implementsList<E>privateclassItrimplements tor<E>//}public tor<E> tor(){returnnewItr();}因为定义 List中的实例成员类Itr可List中的任意成员变量和方法所以很方便实现Itor，无需List对外的接口。若没有成员类机制，则只有在AbastractList源码之外定义一个实现ItorItr，该类有一个List实例成员list，为了Itr能获取list的内部信息以便实现遍历，List必然要向Itr开放额外的接口。【 4-22】实例成员类的定义、控制、约束与程 4-22: packagepublicstaticvoidmain(String[]args)new}格式一：外部类实例.new内部类构造方法Outerouter=newOuter();outer.showXY();//用实例调用实例方法Outer.staticMethod();//用类调用类方法Outer.Inner1inner1=outer.newInner1();格式二：new外部类构造方法new内部类构造方法Outer.Inner2inner2=newOuter().newInner2();newOuter().newInner3().new//Outer.Inner5inner5=newOuter().newnewOuter().new}}classOuterprivateintx=10;//实例成员变量privatestaticinty100类变量publicclassInner1公有实例成员privateintprivateint//不能在实例成员类中定义static变//privatestaticintstaticfinalintC=publicInner1()x=y=//外部类的实例成员变Outer.this.x=//外部类的类成员变Outer.this.y=}voidshowXY()System.out.println(this.getClass的privateintx System.out.println(this.getClass()+"的privateinty="+ }}protectedclassInner2保护实例成员publicvoidinner2M1()}//不能在实例成员类中定义static方//publicstaticvoidinner2M2(){}classInner3默认实例成员publicclassInner4publicInner4()System.out.println("实例成员类Inner4的反射是："+this);System.out.println("实例成员类Inner3的反射是：Outer.this);}}//不能在实例成员类中定义static//publicstaticclassInner5_2{}privateclassInner5私有实例成员interfaceInner6内部接 }classInner7implementsInner6实现内部接口publicvoidm1实现抽象方