java编程思想复用，多态，以及设计模式-复用篇

最近，在看java编程思想，觉得这的确是一本难得的好书。目前已经看到了第12章异常，个人觉得本书的最精华部分是讲述了，类的复用，多态以及几种常见的设计模式（这些其实就是面向的对象的编程思想），所以我就把这些看完了的，加上自己的理解，总结出来给大家分享一下。

Java的复用

大概有三种，继承，组合，以及他们的折衷代理。

先说组合，组合我们最常用了：

下面给出一个简单的代码示例：

class WaterSource {  private String s;  WaterSource() {    System.out.println("WaterSource()");    s = "Constructed";  }  public String toString() { return s; }}public class SprinklerSystem {  private String valve1, valve2;  private WaterSource source = new WaterSource();  private int i;  private float f;  public String toString() {    return      "valve1 = " + valve1 + " " +      "valve2 = " + valve2 + "\n" +      "i = " + i + " " + "f = " + f + " " +      "source = " + source;  }  public static void main(String[] args) {    SprinklerSystem sprinklers = new SprinklerSystem();    System.out.println(sprinklers);  }} /* Output:WaterSource()valve1 = null valve2 = nulli = 0 f = 0.0 source = Constructed

组合，我就不多讲了，下面来说继承

照样给出继承的示例：

import static net.mindview.util.Print.*;class Cleanser {  private String s = "Cleanser";  public void append(String a) { s += a; }  public void dilute() { append(" dilute()"); }  public void apply() { append(" apply()"); }  public void scrub() { append(" scrub()"); }  public String toString() { return s; }  public static void main(String[] args) {    Cleanser x = new Cleanser();    x.dilute(); x.apply(); x.scrub();    print(x);  }}public class Detergent extends Cleanser {  // Change a method:  public void scrub() {    append(" Detergent.scrub()");    super.scrub(); // Call base-class version  }  // Add methods to the interface:  public void foam() { append(" foam()"); }  // Test the new class:  public static void main(String[] args) {    Detergent x = new Detergent();    x.dilute();    x.apply();    x.scrub();    x.foam();    print(x);    print("Testing base class:");    Cleanser.main(args);  }} /* Output:Cleanser dilute() apply() Detergent.scrub() scrub() foam()Testing base class:Cleanser dilute() apply() scrub()

继承我也不多讲了

下面来说说代理

代理可说是继承和组合的中庸之道，因为有时想要把把另一个类放在这个类中而且对外提供接口，而运用继承的话，要知道有时候这个类跟另一类不是is-a的关系，而是has-a的关系，所以代理就正好是我们需要的了，只暴露想要暴露的接口。

下面给出代码示例：PS:SpaceShipControls 是被代理的类。

public class SpaceShipDelegation {  private String name;  private SpaceShipControls controls =    new SpaceShipControls();  public SpaceShipDelegation(String name) {    this.name = name;  }  // Delegated methods:  public void back(int velocity) {    controls.back(velocity);  }  public void down(int velocity) {    controls.down(velocity);  }  public void forward(int velocity) {    controls.forward(velocity);  }  public void left(int velocity) {    controls.left(velocity);  }  public void right(int velocity) {    controls.right(velocity);  }  public void turboBoost() {    controls.turboBoost();  }  public void up(int velocity) {    controls.up(velocity);  }  public static void main(String[] args) {    SpaceShipDelegation protector =      new SpaceShipDelegation("NSEA Protector");    protector.forward(100);  }}

注意，有时我们也把组合和继承一起使用，总之这三种方式要灵活使用。

向上转型：

复用父类的接口并不是继承技术最重要的方面，最重要的是向上转型，这个下一篇将讲述。

最后总结一下：什么时候用继承，什么时候用组合。

组合是将现有的类型作为新类型的底层实现的一部分使用，而继承复用的是接口，还有多态。

在设计系统时，优先选择组合，只有确实需要复用父类接口或向上转型时，才需要使用。