Java复用

1.复用的概念

复用代码是Java众多引人注目的功能之一

但是很多人并不能确切的知道复用是什么？

从语文的角度上把复用两字拆开进行组词，就是复制和使用.但是在Java语言中这只是最简单的一种用法，作为一种面向对象的语言，java有着更多更高级的复用方法。

2. 复用的方法

1.第一种方法很简单粗暴，当你创建了一个类后，想要在新的类中使用你现用的类，你便需要在新的类中创建一个现有类的对象，这个新的类便是由现有类的对象所组成，这种方法成为组合，简单的说这就是一种复制粘贴。

2.第二种方法更细致一些，你按照现有类的类型去创建一个新的类，并让这个类的类型与现用类型相同，只是在新的类中添加了一些新的代码，这种方式称为继承。

3.复用的几种具体实现

3.1组合

组合的实现很简单，只需要将对象引用放到新类中即可，如下：

class WaterSource{
    private String s;
    WaterSource(){
        System.out.println("WaterSource()");
        s = "Constructed";
    }
    public String toString(){
        return s;
    }
}

public class Demo {
    private  String valve1,valve2,valve3,valve4;
    private WaterSource source = new WaterSource();
    private int i;
    private float f;
    public String toString(){
        return "value1 = " +valve1+ " " +
               "valve2 = " +valve2+ " " +
               "valve3 = " +valve3+ " " +
               "valve4 = " +valve4+ " " +
               "i = " + i + " " + "f = " + f + " " +
                "source = " + source;
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println(demo);
    }
}

输出结果：

WaterSource()
value1 = null valve2 = null valve3 = null valve4 = null i = 0 f = 0.0 source = Constructed

至于为什么没有给基本数据类型和对象赋值时输出为空的原因可以看前面的文章

(1条消息) java类的初始化顺序_Chen+7的博客-CSDN博客

3.2继承

继承是所有面向对象的语言不可缺少的部分，在java中继承只能实现单一继承，而在C++中继承可

以实现多继承，如果没有显示的表明继承了其他类，那么Java将会隐式的对其继承Object类。

继承要用关键字extends实现，继承后会得到基类的所有域和方法（包括私有方法）。

原因可以看(1条消息) final关键字的多种用法_Chen+7的博客-CSDN博客

继承代码如下：

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();
        System.out.println(x);
    }
}
public class Detergent extends Cleanser{
    public void scrub(){
        append(" Detergent.scrub()");
        super.scrub();
    }
    public void foam(){append(" foam()");}

    public static void main(String[] args) {
        Detergent x = new Detergent();
        x.dilute();
        x.apply();
        x.scrub();
        x.foam();
        System.out.println(x);
        System.out.println("Testing base class");
        Cleanser.main(args);
    }
}

输出结果：

Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class
Cleanser dilute() apply() scrub()

在继承中，一般的规则是将所有的数据成员都指定为private，将所有的方法都指定为public

3.3代理

定义:为其他对象提供一种代理以控制对这个对象的访问。

代理模式的本质上是对开闭原则的直接支持。

代码如下：

//一个代表支付的接口
interface PayFor{
    void submit(int money);
    void order();
}
//小明买房
class XiaoMing implements PayFor{
    @Override
    public void submit(int money) {
        System.out.println(String.format("预计花%d元买房",money));
    }

    @Override
    public void order() {
        System.out.println(String.format("找到喜欢的房子，支付中介%d元",1100));
    }
}
//房地产中介
class Intermediary implements PayFor{
    PayFor payFor;
    public Intermediary (PayFor payFor){
        this.payFor = payFor;
    }
    @Override
    public void submit(int money) {
        payFor.submit(money);
    }

    @Override
    public void order() {
        payFor.order();
    }
}
//中介公司
class IntermediaryFactory{
    public static PayFor getIntermediary(){
        return new Intermediary(new XiaoMing());
    }
}

public class Demo2{
    public static void main(String[] args) {
        IntermediaryFactory.getIntermediary().submit(1500000);
        IntermediaryFactory.getIntermediary().order();
    }
}

输出结果：

预计花1500000元买房
找到喜欢的房子，支付中介1100元

从代理的代码中我们可以看到代理和组合有一点的相似性，在代理中，当我们访问实际对象时，时

通过代理对象来访问的，代理模式就是在访问实际对象时引入一定的间接性，因为这种间接性又可

以附加多种用途。

3.4结合使用组合和继承

就是上面两种的结合体，但是会更复杂一些

代码如下：

class Plate{
    Plate(int i){
        System.out.println("Plate constructor");
    }
}
class DinnerPlate extends Plate{
    DinnerPlate(int i){
        super(i);
        System.out.println("DinnerPlate constructor");
    }
}
class Utensil{
    Utensil(int i){
        System.out.println("Utensil constructor");
    }
}
class Spoon extends Utensil{
    Spoon(int i){
        super(i);
        System.out.println("Spoon constructor");
    }
}
class Fork extends Utensil{
    Fork(int i){
        super(i);
        System.out.println("Fork constructor");
    }
}
class Knife extends Utensil{
    Knife(int i){
        super(i);
        System.out.println("Knife constructor");
    }
}
class Custom{
    Custom(int i){
        System.out.println("Custom constructor");
    }
}
public class Demo4 extends Custom{
    private DinnerPlate dinnerPlate;
    private Spoon spoon;
    private Fork fork;
    private Knife knife;
    public Demo4(int i){
        super(i);
        dinnerPlate = new DinnerPlate(i+1);
        spoon = new Spoon(i+2);
        fork = new Fork(i+3);
        knife = new Knife(i+4);
        System.out.println("Demo4 constructor");
    }
    public static void main(String[] args) {
        Demo4 demo4 = new Demo4(9);
    }

}

输出结果：

Custom constructor
Plate constructor
DinnerPlate constructor
Utensil constructor
Spoon constructor
Utensil constructor
Fork constructor
Utensil constructor
Knife constructor
Demo4 constructor

参考：java编程思想