05 面向对象高级程序设计

1、 Weight,height,head, Speak(); Hand,foot 【例5-2】继承不同包中的类的简单例子 / HouseHold.java package xing.house; public class HouseHold /家 protected String address; /地址 public String surnname; /姓 String givenname; /名 public HouseHold(String add) address =add; protected String getAddress()return address; void setMon

2、ey(String newadd) address=newadd; void setAddress（String add）address=add； / Mikey.java: package xing.friend; import xing.house.HouseHold; public class Mikey extends HouseHold public Mikey() super(Star flight street 110); public static void main(String args) Mikey mikey=new Mikey(); /mikey.givenname=

3、“Johnson”; /非法 mikey.surnname=Math; /合法. mikey.address=Star flight street 110; /合法. String m=mikey.getAddress(); /合法 /mikey.setAddress(Star flight street 110); /非法. System.out.println(mikey.surnname+：+m); 程序编译和运行过程如下： 当我们在子类中定义的成员变量和父类中的成员变量同名 时,此时称子类的成员变量隐藏了父类的成员变量。 当子类中定义了一个方法,并且这个方法的名字,返回类型, 参数个数

4、以及类型和父类的某个方法完全相同时,父类的这 个方法将被隐藏，这时我们说重写了父类的方法。 子类通过成员变量的隐藏和方法的重写可以把父类的状态 和行为改变为自身的状态和行为。 例如下面的这段程序就是这样的情况： class SuperClass /父类 int y； void setY() y=0; class SubClass extends SuperClass int y； / 父类变量y被隐藏 void setY() / 重写父类的方法setY() y=1； 子类在隐藏了父类的成员变量或重写了父类的方法后，常 常还要用到父类的成员变量，或在重写的方法中使用父类 中被重写的方法以简化代码

5、的编写，这时就要访问父类的 成员变量或调用父类的方法，Java中通过super来实现对父 类成员的访问。我们知道，this用来引用当前对象，与this 类似，super用来引用当前对象的父类。 super的使用可以分为下面三种情况： 1)用来访问父类被隐藏的成员变量，如： super.variable 2)用来调用父类中被重写的方法，如： super.Method(paramlist)： 3)用来调用父类的构造方法，如： super(paramlist)； 【例5-3】调用父类的构造方法的例子 class A /类A public int n; /公共类型的成员变量 public A() pu

6、blic A(int n) this.n = n; int method() return n; public class B extends A /类B public B() super(15); public static void main(String args) A aInstance = new B( ); int b=aInstance.method(); System.out.println(类A中的成员变量：+b); 假设A 类是B 类的父类, class B extends A 当我们用子类创建一个对象,并把这个对象的引用放 到父类的对象中时,例如 A a; A a=new

7、 B(); 或 A a; B b=new B(); a=b; 称这个父类对象a是子类对象b的上转型对象。 对象的上转型对象的实体是子类负责创建的，但上转型对象 会失去原对象的一些属性和功能。上转型对象具有如下特点： 1）上转型对象不能操作子类新增的成员变量和方法。 2）上转型对象可以操作子类继承或重写的成员变量和方法。 3）如果子类重写了父类的某个方法后，当对象的上转对象 调用这个方法时一定是调用这个重写的方法，因为程序在运行 时知道，这个上转对象的实体是子类创建的，只不过损失了一 些功能而已。 不要将父类创建的对象和子类对象的上转型对象相混淆。 上转型对象在Java编程中是常见的。 可以将对

8、象的上转型对象再强制转换到一个子类对象，这可以将对象的上转型对象再强制转换到一个子类对象，这 时该子类对象又具备了子类所给的所有属性和功能。时该子类对象又具备了子类所给的所有属性和功能。 【例5-5】 上转型对象的使用 class Mammal /哺乳动物类 private int n=40; void crySpeak(String s) System.out.println(s); public class Monkey extends Mammal / 猴子类 void (int aa,int bb) int cc=aa*bb; System.out.println(cc); void

9、crySpeak(String s) System.out.println(*+s+*); public static void main(String args) Mammal mammal=new Monkey(); / mammal是Monkey类的对象的上转型对象. mammal.crySpeak(I love this game); / mammal.n=1000; / puter(10,10); Monkey monkey=(Monkey)mammal; /把上转型对象强制转化为子类的对象. puter(10,10); 上述程序的运行结果为： *I love this game*

10、100 在上述例子中,上转对象mammal调用方法: mammal.crySpeak(I love this game); 得到的结果是”*I love this game*”.而不是 ”I love this game”。 因为mammal调用的是子类重写的方法crySpeak. 在main（）中，如果出现下面的两行代码，那将是错误的： mammal.n=1000; /因为子类本来就没有继承n。 puter(10,10); /因为computer方法是子类新增 的方法。 在Java语言中，多态性主要体现在两个方面：由方法重载实现的静态多态性 （编译时多态）和方法重写实现的动态多态性（运行时多

11、态），如下： 1） 编译时多态 在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态 确定调用相应的方法。 2） 运行时多态 由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父 类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个 对象可以通过引用子类的实例来调用子类的方法。 如果子类重写了父类的方法，那么重写方法的调用原则如下：Java运行时系 统根据调用该方法的实例，来决定调用哪个方法。对子类的一个实例，如果子类 重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了父类的方法 （未重写），则运行时系统调用父类的方法。 另外，方法重写时

12、应遵循的原则如下： 改写后的方法不能比被重写的方法有更严格的访问权限。改写后的方法不能比被重写的方法有更严格的访问权限。 改写后的方法不能比被重写的方法产生更多的异常改写后的方法不能比被重写的方法产生更多的异常。 进行方法重写时必须遵从这两个原则，否则编译器会指出程序出错。 【例5-7】方法重写的例子 class Parent public void function() System.out.println(I am in Parent!); class Child extends Parent private void function() System.out.println(I am

13、in Child!); public class Test public static void main(String args) Parent pl=new Parent( ); Parent p2=new Child( ); p1.function( ); p2.function( ); 编译过程如下： D:userchap05javac Test.java Test.java:8: function() in Child cannot override function() in Parent; attempting to assign weaker access privileges

14、; was public private void function() Test.java:16: cannot find symbol symbol : variable p1 location: class RTpolyTest p1.function( ); 2 errors 可以看出，该程序中实例p2调用function()方法时会导致访问权限的冲突。 Java语言中，用abstract关键字来修饰一个类时，这个 类叫做抽象类抽象类。一个abstract 类只关心它的子类是否具有某 种功能,并不关心该功能的具体实现,功能的具体行为由子类 负责实现的。例如： public abstra

15、ct class Drawing public abstract void drawDot(int x, int y); public void drawLine(int x1, int y1,int x2, int y2) 用abstract来修饰一个方法时，该方法叫做抽象方法抽象方法。 与final类和方法相反，abstract类必须被继承，abstract方 法必须被重写。 当一个类的定义完全表示抽象的概念时，它不应该被实例 化为一个对象。例如Java中的Number类就是一个抽象类，它 只表示数字这一抽象概念，只有当它作为整数类Integer或实 数类Float等的父类时才有意义。 定

16、义一个抽象类的格式如下： abstract class abstractClass 由于抽象类不能被实例化，因此下面的语句会产生编译错 误： new abstractClass()； 抽象类中可以包含抽象方法，为所有子类定义一个统一的 接口，对抽象方法只需声明，而不需实现，因此它没有方法 体。其格式如下： abstrac returnType abstractMethod(paramlist)abstrac returnType abstractMethod(paramlist)； 【例5-8】使用abstract的另一例子 abstract class AA abstract void ca

17、llme( ); void metoo( ) System.out.println(InsideAs metoo() method); class BB extends AA void callme( ) System.out.println(Inside Bs callme() method); public class AAbstract public static void main(String args) AA cc=new BB(); /cc为上转型对象 cc.callme(); cc.metoo(); Java 不支持多继承性,即一个类只能有一个父类。单继承性使得Java类 层次

18、简单,易于程序的管理。为了克服单继承的缺点，Java使用了接口,一个 类可以实现多个接口。接口的定义和类的定义很相似,分为接口声明和接口体 两部分。 1 1、 接口声明接口声明 我们曾使用class关键字来声明类，接口通过使用关键自interface 来声 明。完整的接口定义格式如下： public interface interfaceName extends listOfSuperInterfacepublic interface interfaceName extends listOfSuperInterface 其中public修饰符指明任意类均可以使用这个接口，缺省情况下，只有 与该

19、接口定义在同一个包中的类才可以访问这个接口。extends子句与类声明 中的extends子句基本相同，不同的是一个接口可以有多个父接口，用逗号隔 开，而一个类只能有一个父类。子接口继承父接口中所有的常量和方法。 通常接口名称以able或ible结尾，表明接口能完成一定的行为，例如 Runnable、Serializable。 2 2、 接口体接口体 接口体中包含常量定义和方法定义两部分。在接口中定义的常量均具有 public、static和final属性。其格式如下: returnType methodName(paramlist);returnType methodName(paramli

20、st); 接口中只能进行方法的声明，而不提供方法的实现，所以，方法定义没 有方法体，且用分号(;)结尾，在接口中声明的方法具有public和abstract属 性。另外，如果在子接口中定义了和父接口同名的常量，则父接口中的常量 被隐藏。 例如： interface Summaryable final int MAX=50; / MAX具有public、static、final属性 void printone(float x); float sum(float x ,float y); 上面这段程序可以以Summaryable.java来保存，也可以写入其它Java程 序中。 3 3、接口的使用

21、、接口的使用 一个类通过使用关键字implements 声明自己使用（或实现）一个或多 个接口。如果使用多个接口,用逗号隔开接口名。如 class Calculate extends Computer implements Summary, Substractable 类Calculate使用了Summary 和Substractable接口,继承了Computer类。 如果一个类使用了某个接口,那么这个类必须实现该接口的所有方法,即为这 些方法提供方法体。需要注意的如下： 1）在类中实现接口的方法时,方法的名字,返回类型,参数个数及类型必须与 接口中的完全一致。 2）接口中的方法被默认是pu

22、blic ,所以类在实现接口方法时,一定要用 public 来修饰。 3）另外,如果接口的方法的返回类型如果不是void 的,那么在类中实现该接 口方法时,方法体至少要有一个return 语句。如果是void 型,类体除了两个 大括号外,也可以没有任何语句. 【例例5-9】 使用多重接口的例子 / MultInterfaces.java interface I1 abstract void test(int i); interface I2 abstract void test(String s); public class MultInterfaces implements I1, I2 p

23、ublic void test(int i) System.out.println(In MultInterfaces.I1.test); public void test(String s) System.out.println(In MultInterfaces.I2.test); public static void main(String a) MultInterfaces t = new MultInterfaces(); t.test(42); t.test(Hello); 简单地说，一个类被嵌套定义于另一个类中，称为嵌套嵌套 类类。在大多数情况下，嵌套类（ 静态的嵌套类除外)就是

24、内内 部类部类（inner class）。包含内部类的类称为外部类。与一 般的类相同，内部类具有自己的成员变量和成员方法。通过 建立内部类的对象，可以存取其成员变量和调用其成员方法。 例如下面的例子： pubic class GroupOne int count； /外部类的成员变量 public class Student public class Student /声明内部类声明内部类 String nameString name； /内部类的成员变量内部类的成员变量 public void output() public void output() /内部类的成员方法内部类的成员方法 System.out.println(+ )System.out.println(+ )； 内部类可以在如