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 } // /:~

 

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