java继承和组合

1.继承和组合的概念

在新类里简单地创建原有类的对象。我们把这种方法叫作“组合”，因为新类由现有类的对象合并而成。我们只是简单地重复利用代码的功能，而不是采用它的形式。
第二种方法是创建一个新类，将其作为现有类的一个“类型”。我们可以原样采取现有类的形式，并在其中加入新代码，同时不会对现有的类产生影响。这种魔术般的行为叫作“继承”（Inheritance），涉及的大多数工作都是由编译器完成的。对于面向对象的程序设计，“继承”是最重要的基础概念之一。对于组合和继承这两种方法，大多数语法和行为都是类似的（因为它们都要根据现有的类型生成新类型）。

2.组合也就是一个类的对象是另外一个类的成员，一般的程序都有组合的意味，只不过是基本数据类型是成员变量，下面请看具体的例子

 1 class Head

 2 {

 3        Head(){

 4       System.out.println(" head ");

 5       }

 6 }

 7 class Body

 8 {

 9       Body(){

10       System.out.println(" body ");

11       }

12 }

13 class Person()

14 {

15       Head h=null;

16       Body b=null;

17      Person()                                //人是由头和身体组成的,Head和Body的对象是Person的一部分

18     { 

19       h=new Head();

20       b =new Body();

21     }

22  

23 }

24  

 

3.继承作为面向对象的三个重要特性的一个方面，在面向对象的领域有着及其重要的作用，好像没听说哪个面向对象的语言不支持继承

 1 class Person

 2 {

 3     private String name = null;

 4     private int age = 0;

 5 

 6     public Person(String n, int a)

 7     {

 8         name = n;

 9         age = a;

10     }

11 

12     int getAge()

13     {

14         return age;

15     }

16 

17     String getName()

18     {

19         return name;

20     }

21 

22     void getDescription()

23     {

24         System.out.println("name: " + name + "/t" + "age: " + age);

25     }

26 }

27 

28 class Student extends Person

29 {

30     private String studno = null;

31 

32     public Student(String n, String no, int a)

33     {

34         super(n, a);

35         studno = no;

36     }

37 }

 

 

说明:Student类中有三个成员变量name,age,studno和一个方法getDescription();

注意:子类继承了父类的所有变量和函数，只是子类不能访问父类的private类型的变量和函数，其实privae类型的变量还是继承到子类中的

 

4.

无论还是继承，都允许我们将子对象置于自己的新类中。大家或许会奇怪两者间的差异，以及到底该如何选择。
如果想利用新类内部一个现有类的特性，而不想使用它的接口，通常应选择组合。也就是说，我们可嵌入一个对象，使自己能用它实现新类的特性。但新类的用户会看到我们已定义的接口，而不是来自嵌入对象的接口。考虑到这种效果，我们需在新类里嵌入现有类的private对象。
有些时候，我们想让类用户直接访问新类的组合。也就是说，需要将成员对象的属性变为public。成员对象会将自身隐藏起来，所以这是一种安全的做法。而且在用户知道我们准备合成一系列组件时，接口就更容易理解。car（汽车）对象便是一个很好的例子：

 1 class Engine

 2 {

 3     public void start()

 4     {

 5     }

 6 

 7     public void rev()

 8     {

 9     }

10 

11     public void stop()

12     {

13     }

14 }

15 

16 class Wheel

17 {

18     public void inflate(int psi)

19     {

20     }

21 }

22 

23 class Window

24 {

25     public void rollup()

26     {

27     }

28 

29     public void rolldown()

30     {

31     }

32 }

33 

34 class Door

35 {

36     public Window window = new Window();

37 

38     public void open()

39     {

40     }

41 

42     public void close()

43     {

44     }

45 }

46 

47 public class Car

48 {

49     public Engine engine = new Engine();

50     public Wheel[] wheel = new Wheel[4];

51     public Door left = new Door(), right = new Door(); // 2-door

52 

53     Car()

54     {

55         for (int i = 0; i < 4; i++)

56             wheel[i] = new Wheel();

57     }

58 

59     public static void main(String[] args)

60     {

61         Car car = new Car();

62         car.left.window.rollup();

63         car.wheel[0].inflate(72);

64     }

65 } // /:~

 

由于汽车的装配是故障分析时需要考虑的一项因素（并非只是基础设计简单的一部分），所以有助于客户程序员理解如何使用类，而且类创建者的编程复杂程度也会大幅度降低。
如选择继承，就需要取得一个现成的类，并制作它的一个特殊版本。通常，这意味着我们准备使用一个常规用途的类，并根据特定的需求对其进行定制。只需稍加想象，就知道自己不能用一个车辆对象来组合一辆汽车——汽车并不“包含”车辆；相反，它“属于”车辆的一种类别。“属于”关系是用继承来表达的，而“包含”关系是用组合来表达的。

5. protected
现在我们已理解了继承的概念，protected这个关键字最后终于有了意义。在理想情况下，private成员随时都是“私有”的，任何人不得访问。但在实际应用中，经常想把某些东西深深地藏起来，但同时允许访问衍生类的成员。protected关键字可帮助我们做到这一点。它的意思是“它本身是私有的，但可由从这个类继承的任何东西或者同一个包内的其他任何东西访问”。也就是说，Java中的protected会成为进入“友好”状态。
我们采取的最好的做法是保持成员的private状态——无论如何都应保留对基 础的实施细节进行修改的权利。在这一前提下，可通过protected方法允许类的继承者进行受到控制的访问：

import java.util.*;



class Villain

{

    private int i;



    protected int read()

    {

        return i;

    }



    protected void set(int ii)

    {

        i = ii;

    }



    public Villain(int ii)

    {

        i = ii;

    }



    public int value(int m)

    {

        return m * i;

    }

}



public class Orc extends Villain

{

    private int j;



    public Orc(int jj)

    {

        super(jj);

        j = jj;

    }



    public void change(int x)

    {

        set(x);

    }

} // /:~

 

可以看到，change()拥有对set()的访问权限，因为它的属性是protected（受到保护的）。

 

6. 再论合成与继承
在面向对象的程序设计中，创建和使用代码最可能采取的一种做法是：将数据和方法统一封装到一个类里，并且使用那个类的对象。有些时候，需通过“组合”技术用现成的类来构造新类。而继承是最少见的一种做法。因此，尽管继承在学习OOP的过程中得到了大量的强调，但并不意味着应该尽可能地到处使用它。相反，使用它时要特别慎重。只有在清楚知道继承在所有方法中最有效的前提下，才可考虑它。为判断自己到底应该选用组合还是继承，一个最简单的办法就是考虑是否需要从新类上溯造型回基础类。若必须上溯，就需要继承。但如果不需要上溯造型，就应提醒自己防止继承的滥用。但只要记住经常问自己“我真的需要上溯造型吗”，对于组合还是继承的选择就不应该是个太大的问题