Java学习-设计模式-装饰器模式

Java学习-设计模式-装饰器模式

概述

**定义： ** 装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

**优点：**装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

**缺点：**多层装饰比较复杂。

理解：

说真的，查找装饰器模式的学习资料的时候，发现这玩意有个长得差不多的兄弟（代理模式），一看，感觉一模一样，但是肯定是由区别的，于是有百度好久，感觉有点模棱两可，这部分待会单独写一下，如果写的不对，麻烦各位大佬指正一下，小弟周末更新的时候会吸取各位大佬的建议，重新修正。

先说装饰器模式：按照查的资料，就是我需要执行一些操作，但是我手上却只有一个类能够做里面的部分操作，然后我需要对其进行装饰，加上部分功能，然后使用装饰后的类来完成的操作。

1. 假设有家水果店的接口A，里面有一个进货的方法
2. 定义一个 A1 类去实现接口 A ，重写进货方法，进橘子。（正常实现）
3. 定义一个 B1 类去实现接口 A ，B1类中包含一个类型为接口 A 的属性，构造方法中初始化这个属性；重写进货方法，先使用初始化好的属性（接口A的实现类，测试这里使用A1）去调用进货方法，然后在写一段进苹果的方法。
4. 在定义一个 B2 类，按照B1类去实现接口A，不过这里进香蕉。
5. 然后进行测试：先创建A1类，在创建B1类（初始化使用A1类），最后创建B2类（这里初始化使用B1类（因为B1类对象已经初始化好了），也可以使用A1类，测试选用B1），最后调用B2类的进货方法，则可以实现进3种水果。

1. 假设有家水果店的接口A，里面有一个进货的方法
2. 定义一个 A1 类去实现接口 A ，重写进货方法，进橘子。（正常实现）
3. 定义一个 A2 类去实现接口 A ，重写进货方法，进苹果。（正常实现）
4. 定义一个抽象类B，实现接口 A ，类中包含一个类型为接口 A 的属性，构造方法中初始化这个属性；并创建一个抽象方法（该方法用于新增功能）（抽象装饰类）
5. 创建一个类B1，继承抽象类B，并重写抽象方法进香蕉，然后重写进货方法，先使用抽象类中的属性（接口A）调用进货方法，再调用重写的私有抽象方法。
6. 测试：先创建一个接口A的实现类（A1、A2都可，测试时使用A1），在创建B1类（使用刚刚创建好的实现类完成初始化），在调用B1的进货方法完成一次进了一种水果和香蕉。

举例：

第一种方式

package Practices.Mode.Decorator_Pattern;
// 1. 先创建一个水果店类
public interface Fruit_Shop {
    public void Purchase();
}

package Practices.Mode.Decorator_Pattern;
// 2. 实现水果店接口，完成进货功能（这里进橘子）。
public class Purchase_Orange implements Fruit_Shop {

    public void Purchase() {
        System.out.println("进货橘子");
    }
}

package Practices.Mode.Decorator_Pattern;
// 3. 创建一个装饰类去实现进多种货（逻辑在理解中）
public class Purchase1 implements Fruit_Shop {
    private Fruit_Shop fruitShop;

    public Purchase1(Fruit_Shop fruitShop) {
        this.fruitShop = fruitShop;
    }

    public void Purchase() {
        fruitShop.Purchase();
        System.out.println("进苹果");
    }
}



package Practices.Mode.Decorator_Pattern;
// 3. 创建一个装饰类去实现进多种货（逻辑在理解中）
public class Purchase2 implements Fruit_Shop {
    private Fruit_Shop fruitShop2;

    public Purchase2(Fruit_Shop fruitShop2) {
        this.fruitShop2 = fruitShop2;
    }

    public void Purchase() {
        fruitShop2.Purchase();
        System.out.println("进香蕉");
    }
}

package Practices.Mode.Decorator_Pattern;
// 4. 测试（逻辑在理解那一栏中）
public class Test_main {
    public static void main(String[] args) {
        Fruit_Shop orange = new Purchase_Orange();
        Purchase1 purchase1 = new Purchase1(orange);
        Purchase2 purchase2 = new Purchase2(purchase1);

        purchase2.Purchase();

    }
}

第二种方式：

package Practices.Mode.Decorator_Pattern;
// 1. 先创建一个水果店类
public interface Fruit_Shop {
    public void Purchase();
}

package Practices.Mode.Decorator_Pattern;
// 2. 实现水果店接口，完成进货功能（这里进橘子）。
public class Purchase_Orange implements Fruit_Shop {

    public void Purchase() {
        System.out.println("进货橘子");
    }
}



package Practices.Mode.Decorator_Pattern;
// 2. 实现水果店接口，完成进货功能（这里进苹果）。
public class Purchase_Apple implements Fruit_Shop {
    public void Purchase() {
        System.out.println("进苹果");
    }
}

package Practices.Mode.Decorator_Pattern;
// 3. 定义一个抽象装饰类来实现多重进货
public abstract class Purchase_abs implements Fruit_Shop {
    protected Fruit_Shop fruitShop;

    public Purchase_abs(Fruit_Shop fruitShop) {
        this.fruitShop = fruitShop;
    }

    public void Purchase_Fruit(){
        fruitShop.Purchase();
    }

}

package Practices.Mode.Decorator_Pattern;
// 4. 实现多重进货
public class Purchase3 extends Purchase_abs {
    public Purchase3(Fruit_Shop fruitShop) {
        super(fruitShop);
    }

    // 这里重写水果店接口的方法，用于进指定的水果
    public void Purchase() {
        fruitShop.Purchase();
        System.out.println("进香蕉");
    }
}

package Practices.Mode.Decorator_Pattern;
// 4. 测试（逻辑在理解那一栏中）
public class Test_main {
    public static void main(String[] args) {
        // 第二种方式
        Fruit_Shop apple = new Purchase_Apple();
        Purchase3 purchase3 = new Purchase3(apple);

        purchase3.Purchase();
    }
}