本专栏将从基础开始，循序渐进，由浅入深讲解常见的设计模式，希望大家都能够从中有所收获，也请大家多多支持。
专栏地址:设计模式实战
所有代码地址:代码地址
如果文章知识点有错误的地方，请指正！大家一起学习，一起进步。

1 装饰器模式

package design;

public class client {
    
    

    //抽象组件
    static abstract class Component{
    
    
        public abstract void operation();
    }

    //具体组件
    static class ConcreteComponent extends Component{
    
    
        public void operation() {
    
    
            System.out.println("处理业务逻辑");
        }
    }

    static abstract class Decorator extends Component{
    
    
        //装饰的组件
        protected Component component;

        //构造方法传入组件对象
        public Decorator(Component component) {
    
    
            this.component = component;
        }

        public void operation(){
    
    
            //转发请求给组件对象，可以在转发前后执行一些附加动作
            component.operation();
        }
    }

    static class ConcreteDecoratorA extends Decorator{
    
    

        public ConcreteDecoratorA(Component component) {
    
    
            super(component);
        }

        private void operationFirst(){
    
    
            System.out.println("operationFirst");
        }

        private void operationLast(){
    
    
            System.out.println("operationLast");
        }

        public void operation() {
    
    
            operationFirst();
            super.operation();
            operationLast();
        }
    }

    public static void main(String[] args) {
    
    
        Component c1 = new ConcreteComponent();
        Decorator decorator = new ConcreteDecoratorA(c1);
        decorator.operation();
    }
}

2 享元模式（放在map中避免重复创建）

package design;

import java.util.HashMap;
import java.util.Map;

public class Client {
    
    

    interface IFlyweight{
    
    
        void operation(String extrinsicState);
    }
    

    //具体享元角色
    static class ConcreteFlyweight implements IFlyweight{
    
    
        private String intrinsicState;

        public ConcreteFlyweight(String intrinsicState){
    
    
            this.intrinsicState = intrinsicState;
        }

        public void operation(String extrinsicState){
    
    
            System.out.println("Object address:" + System.identityHashCode(this));
            System.out.println("IntrinsicState:" + this.intrinsicState);
            System.out.println("ExtrinsicState:" + extrinsicState);
        }
        
        
    }
    
    //享元工厂
    static class FlyweightFactory{
    
    
        private static Map<String,IFlyweight> pool = new HashMap<String,IFlyweight>();
        
        public static IFlyweight getFlyweight(String intrinsicState){
    
    
            if(!pool.containsKey(intrinsicState)){
    
    
                IFlyweight flyweight = new ConcreteFlyweight(intrinsicState);
                pool.put(intrinsicState,flyweight);
                return flyweight;
            }
            return pool.get(intrinsicState);
        }
    }
}

3 组合模式

组合模式(Composite Pattern）又叫作整体-部分(Part-Whole）模式，它的宗旨是通过将单个对象（叶子节点）和组合对象（树枝节点）用相同的接口进行表示，使得客户对单个对象和组合对象的使用具有一致性，属于结构型设计模式。组合对象和被组合对象都应该有统一的接口实现或者统一的抽象父类。

import java.util.ArrayList;

/**
 * 说明：假如李先生购物，用 1 个红色小袋子装了 2 包婺源特产（单价 7.9 元）、1 张婺源地图（单价 9.9 元）；
 * 用 1 个白色小袋子装了 2 包韶关香藉（单价 68 元）和 3 包韶关红茶（单价 180 元）；用 1 个中袋子装了前面的红色小袋子和 1 个景德镇瓷器（单价 380 元）；
 * 用 1 个大袋子装了前面的中袋子、白色小袋子和 1 双李宁牌运动鞋（单价 198 元）。
 *
 * 最后“大袋子”中的内容有：{ 1 双李宁牌运动鞋（单价 198 元）、
 *　　　　　　　　　　　　　　白色小袋子{ 2 包韶关香菇（单价 68 元）、3 包韶关红茶（单价 180 元）}、
 * 　　　　　　　　　　      中袋子{ 1个景德镇瓷器（单价 380 元）、
 *　　　　　　　　　　　　　　　　　　 红色小袋子{2 包婺源特产（单价 7.9 元）、1 张婺源地图（单价 9.9 元）}}}，
 * 现在要求编程显示李先生放在大袋子中的所有商品信息并计算要支付的总价。
 */
public class CompositeApplying {
    
    
    public static void main(String[] args) {
    
    
        float s = 0;
        Bags BigBag, mediumBag, smallRedBag, smallWhiteBag;
        Goods sp;
        BigBag = new Bags("大袋子");
        mediumBag = new Bags("中袋子");
        smallRedBag = new Bags("红色小袋子");
        smallWhiteBag = new Bags("白色小袋子");
        sp = new Goods("婺源特产", 2, 7.9f);
        smallRedBag.add(sp);
        sp = new Goods("婺源地图", 1, 9.9f);
        smallRedBag.add(sp);
        sp = new Goods("韶关香菇", 2, 68);
        smallWhiteBag.add(sp);
        sp = new Goods("韶关红茶", 3, 180);
        smallWhiteBag.add(sp);
        sp = new Goods("景德镇瓷器", 1, 380);
        mediumBag.add(sp);
        mediumBag.add(smallRedBag);
        sp = new Goods("李宁牌运动鞋", 1, 198);
        BigBag.add(sp);
        BigBag.add(smallWhiteBag);
        BigBag.add(mediumBag);
        System.out.println("您选购的商品有：");
        BigBag.show();
        s = BigBag.calculation();
        System.out.println("要支付的总价是：" + s + "元");
    }
}

//抽象构件：物品
interface Articles {
    
    
    public float calculation(); //计算价钱
    public void show();
}

//树叶构件：商品
class Goods implements Articles {
    
    
    private String name;     //名字
    private int quantity;    //数量
    private float unitPrice; //单价

    public Goods(String name, int quantity, float unitPrice) {
    
    
        this.name = name;
        this.quantity = quantity;
        this.unitPrice = unitPrice;
    }

    public float calculation() {
    
    
        return quantity * unitPrice;
    }

    public void show() {
    
    
        System.out.println(name + "(数量：" + quantity + "，单价：" + unitPrice + "元)");
    }
}

//树枝构件：袋子
class Bags implements Articles {
    
    
    private String name;     //名字
    //袋子里面装的东西，组合模式要求实现同一个接口
    private ArrayList<Articles> bags = new ArrayList<Articles>();

    public Bags(String name) {
    
    
        this.name = name;
    }

    public void add(Articles c) {
    
    
        bags.add(c);
    }

    public void remove(Articles c) {
    
    
        bags.remove(c);
    }

    public Articles getChild(int i) {
    
    
        return bags.get(i);
    }

    public float calculation() {
    
    
        float s = 0;
        for (Object obj : bags) {
    
    
            s += ((Articles) obj).calculation();
        }
        return s;
    }

    public void show() {
    
    
        for (Object obj : bags) {
    
    
            ((Articles) obj).show();
        }
    }
}