在Java中类复用有俩种情况，一是类的组合，二是类的继承。组合是指在新类中使用已经产生的类的对象，也就是新类是由现有类对象的组合而成的，此种方法只是复用了现有程序的功能，而非它的形式。继承无需改变现有类的形式，采用现有类的形式并在其中添加新代码。但是在实际开发中并不是只要其中的一种，基本上是混合使用或者只用其中的一种，至于哪种复用方式更合适还需要根据具体的需求进行合理选择。

一、组合

      在组合时无需做一些特殊标记的，当在一个类中创建了另一个类的对象时，组合也就开始了。另外，每一个非基本类型的对象都有一个toString()方法，而且当编译器需要一个String而你却只有一个对象时，该方法便会被调用，实例如下：

class ZuHe{
  private String s;
  ZuHe(){
    s="Hello!";
  }
  public String toString(){ //非基本类型的toString方法
     return s;
  }
}
public class TestZuHe{
   private ZuHe zh=new ZuHe();
   public String toString(){return "ZuHe=" + zh;}
   public static void main(String[] args){
      TestZuHe t = new TestZuHe();
      System.out.print(t);  
   }
}

out:Hello

二、继承

      继承（关键字super表示超类）需要在新类中用extends进行标记，一旦做了这个标记新类就会拥有基类所有的域和方法。在继承中，当我们创建了一个子类对象时，该对象实际已经包含了一个基类的子对象。这个子对象与我们创建的基类对象是一样的，唯一区别是后者来自于外部，而子对象被包装在子类对象内部。关于这层关系可以从下边的实例中看到，通过例子的输出顺序可以看出继承关系的初始化过程是从上而下进行的：

class A{
  public A(){
     System.out.println("This is A");
  }
}
class B extends A{   //A的子类
  public B(){
    System.out.println("This is B")
  }
}
class C extends B{  //B的子类
  public C(){
    System.out.println("This is C")
  }
  public static void main(String[] args){
    C c=new C();   //由于继承关系：此时的对象c中包含着B的子对象，而B的子对象中包含着A的子对象
  }
}

out:
This is A
This is B
This is C

上边的例子实际也包含了基类的初始化，但是如果每个类中的构造器中包含参数又该如何进行初始化呢，此时就需要在子类构造器中通过super()进行参数传递，实例如下：

class A{
  public A(int i){
     System.out.println("This is A");
  }
}
class B extends A{   //A的子类
  public B(int i){
    super(i);//通过此操作将参数i传递到A的构造器中
    System.out.println("This is B")
  }
}
class C extends B{  //B的子类
  public C(){
    super(11);//通过此方法将11传递到B的构造器中
    System.out.println("This is C")
  }
  public static void main(String[] args){
    C c=new C();   //由于继承关系：此时的对象c中包含着B的子对象，而B的子对象中包含着A的子对象
  }
}

另外，在继承中还有一个叫做”向上转型“的概念，向上转型顾名思义就是子类向基类进行转换，由于子类可以看作是基类的一个超集，因为其既包含了基类中的所有方法，同时还拥有属于自己的方法，所以在向上转型中不会丢失基类中的方法，当然也因此称子类与基类为同一类型，具体实现可见如下代码：

class Instrument{
   public void play(){}
   //此处传入的是一个本类的实例
   static void tune(Instruments i){
      i.play();
   }
}
public Test extends Instrument{
   public static void main(String[] args){
    tune(new Test);//传入的是子类的实例，此为向上转型
  }
}

三、代理机制

      在Java中虽然没有明确支持代理，但是在实际开发中仍然会遇到，代理之所以会被使用到是因为继承中的一个不可避免的问题——那就是一旦继承基类所有的方法都会暴露给子类，即使子类不想要也会迫不得已的拥有。此时代理就是一个很好的处理方法，因为代理可以选择基类的部分方法也可以全部，子类只需要通过代理就可以获取到自己想要的那一部分，实例如下：

public class Father{
  private int a;
  private Stirng s;
  void A(){}
  void B(){}
  void C(){}
  void D(){}
}
class Proxy{
  private String name;
  private Father f=new Father();
  public Proxy(String name){
     this.name=name;
  }
  public void A(){f.A();}
  public void B(){f.B();}
  public void C(){f.C();}
  public void D(){f.D();}
}
class UseProxy{
  public static void main(Stirng[] args)
  {
     Proxy p=new Proxy();
     p.A();
     p.B();
  }
}