Java复用类-组合、继承和代理

Java复用代码的方法有三种，组合、继承和代理，从实现的方法来分的话分为两种，第一种是直接在新的类中产生现有类的对象，第二种是按照现有类型来创建新类。

1、组合

假如我们已经有了一个Combination类，如下：

class Combination
{
    public Combination()
    {

    }
    public void test()
    {
        System.out.println("Combination.test()");
    }
}

现在我们希望在新的一个类Combination_test中使用这个类的test方法，那么我们只需将对象引用置于这个新类中即可

public class Combination_test {
    private Combination combination = new Combination();
    public Combination_test()
    {

    }
    public void test1()
    {
        combination.test();
        System.out.println("Combination_test.test()");
    }
    public static void main(String[]args)
    {
        Combination_test ct = new Combination_test();
        ct.test1();
    }
}

2、继承

对于万物皆对象的Java来说，创建一个类的时候总是在继承，如果没有明确指出要从其他类中继承，否则就是在隐式的继承Object类。

对于无参的默认构造函数的类继承：

 

class Test
{
    Test()
    {
        System.out.println("Test constructor");
    }
    public void myprint()
    {
        System.out.println("Test myprint");
    }
}

public class Extends_test extends Test{
    Extends_test()
    {
        System.out.println("Extends constructor");
    }
    public void myprint()
    {
        System.out.println("Extends myprint");
    }
    public static void main(String[]args)
    {
        Extends_test t = new Extends_test(1);
        t.myprint();
    }
}

输出的结果：

Test constructor
Extends constructor
Extends myprint

这里我们看到，在创建一个导出类（Extends_test）对象时会先调用基类的构造函数，实际上，继承并不只是复制基类的接口，当创建一个导出类的对象时，该对象会包含一个基类的子对象，所以即使你不在Extends_test中调用Test的构造函数，编译器你也会为你合成一个默认的构造器，这也就是为什么会调用基类的构造函数的原因，那么如果基类没有无参的构造函数那机器怎么创建基类对象呢，这个时候就需要我们自己来写了，看下面的例子，我们给两个构造函数都加上参数

class Test
{
    Test(int i)
    {
        System.out.println("Test constructor");
    }
    public void myprint()
    {
        System.out.println("Test myprint");
    }
}

public class Extends_test extends Test{
    Extends_test(int i)
    {
        System.out.println("Extends constructor");
    }
    public void myprint()
    {
        System.out.println("Extends myprint");
    }
    public static void main(String[]args)
    {
        Extends_test t = new Extends_test(1);
        t.myprint();
    }
}

报错的意思是Test中没有默认的构造函数，所以要么在基类中写一个默认的构造函数，要么在导出类的构造函数中手动调用基类的构造函数，前者就不说了，第二种的话不是写Test(i)，而是用super方法，Java用super关键字表示超类的意思，当前类就是从超类继承来的，所以我们再导出类的构造函数中添加一句super(i)即可，而我们也可以在导出类中利用super调用基类的方法，比如我们想在Extends_test类中的myprint函数中调用Test的myprint函数，我们就可以用super.myprint()来调用，整体修改过后的代码：

class Test
{
    Test(int i)
    {
        System.out.println("Test constructor");
    }
    public void myprint()
    {
        System.out.println("Test myprint");
    }
}

public class Extends_test extends Test{
    Extends_test(int i)
    {
        super(i);
        System.out.println("Extends constructor");
    }
    public void myprint()
    {
        super.myprint();
        System.out.println("Extends myprint");
    }
    public static void main(String[]args)
    {
        Extends_test t = new Extends_test(1);
        t.myprint();
    }
}

输出结果为：

Test constructor
Extends constructor
Test myprint
Extends myprint

写到这有一点需要提醒的是，一般来说，基类中的方法使用public来修饰，数据成员使用private来修饰

3、代理

代理自我感觉和组合差不太多，我的理解是代理是把我们要实现的某个功能交给另外一个类去做，比如我有一个plane类想实现前进、后退，那么我们就可以把这个功能交给planecontrol类去做

public class PlaneDelegation{    
 2     private PlaneControl planeControl; 
 6     PlaneDelegation(){
 7         planeControl=new PlaneControl();
 8     }
 9     public void forword(){
10         planeControl.forward();
11     }
12     public void back(){
13         planeControl.back();
14     }
18 }
19 
20 class PlaneControl {
21     protected void forword() {}
22     protected void back() {}
25 }

总的来说，组合，是在新类中new 另外一个类的对象，以添加该对象的特性。继承，是从基类继承得到子类，获得基类的特性。代理，是在代理类中创建某功能的类，调用类的一些方法以获得该类的部分特性。