DesignModel

设计模式

一、单例模式

1.普通单例模式
/**
 * 单例模式
 * Created by Bill on 2017/12/15.
 */
public class SigleInstance {
    public static void main(String[] args) {
        instanceOne();
        enmuSingleton instance = enmuSingleton.INSTANCE;
    }
    /**
     * 实例1
     */
    private static void instanceOne() {
        Company company = new Company();
        // ceo 只能通过getCEO 函数获取
        Staff ceoa1 = CEO.getCeo();
        Staff ceoa2 = CEO.getCeo();
        company.addStaff(ceoa1);
        company.addStaff(ceoa2);
        // 通过new 创建vp对象
        Staff vp1 = new VP();
        Staff vp2 = new VP();
        // 通过new 创建staff对象
        Staff staff1 = new Staff();
        Staff staff2 = new Staff();
        Staff staff3 = new Staff();
        company.addStaff(vp1);
        company.addStaff(vp2);
        company.addStaff(staff1);
        company.addStaff(staff2);
        company.addStaff(staff3);
        company.showAllStaff();
    }
}
2.懒汉和饿汉
    /**
     * CEo
     * 饿汉单例模式
     * 声明对象时就已经初始化了
     */
    public class CEO extends Staff {
        public static final CEO mCeo = new CEO();
        // 构造函数私有化
        private CEO() {
        }
        // 公有的静态方法  对外暴露获取单利的接口
        public static CEO getCeo() {
            return mCeo;
        }
        @Override
        public void work() {
            super.work();
            // 管理vp
        }
    }
    /**
     * 懒汉模式
     * 声明一个静态对象，并且在第一次调用getInstance 方法时进行初始化
     * Created by Bill on 2017/12/15.
     */
    public class LazySingleInstance {
        private static LazySingleInstance lazySingleInstance;
        private LazySingleInstance() {
        }
        // 保证多线程下的安全
        public static synchronized LazySingleInstance getLazySingleInstance() {
            if (lazySingleInstance == null) {
                lazySingleInstance = new LazySingleInstance();
            }
            return lazySingleInstance;
        }
    }
3.double check lock
    /**
     * double check lock
     * <p>
     * 优点：资源利用高，第一次执行getInstance()方法才会实例化对象，效率高。
     * 缺点：第一次加载反应稍慢，也由于Java内存模型的原因偶尔会失败。
     * Created by Bill on 2017/12/16.
     */
    public class Singleton {
        private static Singleton singleton = null;
        private Singleton() {
        }
        public static Singleton getSingleton() {
            if (singleton == null) {
                synchronized (Singleton.class) { // 避免不必要的同步
                    if (singleton == null) { // 在null的情况下创建实例
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }
4.枚举单例
    /**
     * 枚举单例
     * 写法简单  默认枚举都是线程安全的  在任何情况下都是单例
     * Created by Bill on 2017/12/16.
     */
    public enum enmuSingleton {
        INSTANCE;
        public void doSomething() {
            System.out.println("do it!!!");
        }
    }
5.静态内部类
    /**
     * 静态内部类
     * Created by Bill on 2017/12/16.
     */
    public class InnerClassSingleton {
        private InnerClassSingleton() {
        }
        public static InnerClassSingleton getInstance() {
            return SingletonHolder.innerInstance;
        }
        /**
         * 静态内部类
         * 保证线程安全，也能保证单例对象的唯一性，同事也延迟加载了单利的实例化
         */
        private static class SingletonHolder {
            private static final InnerClassSingleton innerInstance = new InnerClassSingleton();
        }
    }
6.容器实现单例
    /**
     * 容器管理单例
     * <p>
     * 在程序初始化的时候，将多种单例模式注入到一个统一的管理类中，在使用的时候根据key获取对象对应类型的单例对像。
     * 这种方式是得我们可以管理多种单例，并且在使用的时候通过统一的接口进行获取操作，降低了用户的使用成本；
     * <p>
     * Created by Bill on 2017/12/16.
     */
    public class SingletonManger {
        private static Map<String, Object> objectMap = new HashMap<>();
        private SingletonManger() {
        }
        public static void registerService(String key, Object instance) {
            if (!objectMap.containsKey(key)) {
                objectMap.put(key, instance);
            }
        }
        public static Object getService(String key) {
            return objectMap.get(key);
        }
    }

二、Builder 模式

    1.Product 产品类
       /**
        * 计算机抽象类
        * product角色
        * Created by Bill on 2017/12/16.
        */
       public abstract class Computer {
           private String mBoard;
           private String mDisplay;
           String mOS;
           protected Computer() {
           }
           // 设置CPU核心数
           public void setBoard(String board) {
               mBoard = board;
           }
           // 设置内存
           public void setDisplay(String display) {
               mDisplay = display;
           }
           // 设置操作系统
           public abstract void setOS();
           @Override
           public String toString() {
               return " My Computer:[ mBoard == " + mBoard + " ,mDisplay == " + mDisplay + " ,mOS" + mOS + "]";
           }
       }
       /**
        * 具体的Computer类
        * Created by Bill on 2017/12/16.
        */
       public class MacBook extends Computer {
           public MacBook() {
           }
           @Override
           public void setOS() {
               mOS = "Mac OS X 10.13";
           }
       }
     2.Builder
        /**
         * 抽象Builder类
         * Created by Bill on 2017/12/16.
         */
        public abstract class Builder {
            public abstract void buildBoard(String board);
            public abstract void buildDisplay(String display);
            public abstract void buildOS();
            public abstract Computer create();
        }
        /**
         * 具体的Builder类
         * Created by Bill on 2017/12/16.
         */
        public class MacBookBuilder extends Builder {
            private Computer mComputer = new MacBook();
            @Override
            public void buildBoard(String board) {
                mComputer.setBoard(board);
            }
            @Override
            public void buildDisplay(String display) {
                mComputer.setDisplay(display);
            }
            @Override
            public void buildOS() {
                mComputer.setOS();
            }
            @Override
            public Computer create() {
                return mComputer;
            }
        }
     3.Director类
        /**
         * Director类，负责构建computer
         * Created by Bill on 2017/12/16.
         */
        public class Director {
            Builder mBuilder = null;
            public Director(Builder builder) {
                mBuilder = builder;
            }
            public void construct(String board, String display) {
                mBuilder.buildBoard(board);
                mBuilder.buildDisplay(display);
                mBuilder.buildOS();
            }
        }
     4.使用
        /**
         * Builder 模式
         * <p>
         * 通过具体的MacBookBuilder来构建MacBook对像，而Director封装了构建复杂产品的过程，对外隐藏了细节。
         * Builder和Director一起，将一个复杂对象的构建和表示分开，使得同样的构建过程  可以创建不同的对对象。
         * <p>
         * Created by Bill on 2017/12/15.
         */
        public class BuilderModel {
            public static void main(String[] args) {
                // 实例1
                // 构建器
                MacBookBuilder builder = new MacBookBuilder();
                // Director 表示器
                Director director = new Director(builder);
                director.construct("英特尔主板", "Retina显示器");
                Computer computer = builder.create();
                System.out.println("Computer Info:" + computer.toString());
                // 例子2
                HuaShuoBuilder builder1 = new HuaShuoBuilder();
                Director director1 = new Director(builder1);
                director1.construct("华硕主板", "4K高端显示器");
                Computer computer1 = builder1.create();
                System.out.println("Computer Info:" + computer1.toString());
            }
        }

三、原型模式

/**
 * 文档类型
 * WordDocument扮演的是concreatePrototype角色（具体的原型类）
 * 而cloneable是代表的prototype角色(抽象类或者接口，声明具备clone能力)
 * Created by Bill on 2017/12/20.
 */
public class WordDocument implements Cloneable {
    private String mText;
    private ArrayList<String> mImages = new ArrayList<String>();
    public WordDocument() {
        System.out.println("==========  WordDocument 构造函数  ==========");
    }
    @Override
    protected WordDocument clone() {
        WordDocument document = null;
        try {
            document = (WordDocument) super.clone();
            document.mText = this.mText;
            // 1.浅拷贝
            // document.mImages = this.mImages;
            // 2.深拷贝  拷贝对象时，对于引用形的字段，也采用拷贝的形式  而不是单纯的引用
            document.mImages = (ArrayList<String>) this.mImages.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return document;
    }
    public void showDocu() {
        System.out.println("==========  WordDocument start  ==========");
        System.out.println("text: " + mText);
        System.out.println("image list: ");
        for (String image : mImages) {
            System.out.println("image name: " + image);
        }
        System.out.println("==========  WordDocument end  ==========");
    }
    public String getText() {
        return mText;
    }
    public void setText(String text) {
        mText = text;
    }
    public ArrayList<String> getImages() {
        return mImages;
    }
    public void setImages(String images) {
        this.mImages.add(images);
    }
}
/**
 * 客户端
 * 浅拷贝：副文档的字段引用了原始文档的字段；  其中任何一个的修改，都会对另一个产生影响；
 * 深拷贝：拷贝对象时，对于引用形的字段，也采用拷贝的形式  而不是单纯的引用
 * <p>
 * Created by Bill on 2017/12/20.
 */
public class Client {
    public static void main(String[] args) {
       /* // 1、浅拷贝
        // 构建对象
        WordDocument originDocument = new WordDocument();
        originDocument.setText("这是一篇文档");
        originDocument.setImages("图片1");
        originDocument.setImages("图片2");
        originDocument.setImages("图片3");
        originDocument.showDocu();
        // 以原始文档为对象  拷贝一份
        WordDocument cloneDocument1 = originDocument.clone();
        originDocument.showDocu();
        // 修改备份文档  不会影响原始文档
        cloneDocument1.setText("这是修改过的文档2");
        //cloneDocument1.setImages("哈哈.jpg");
        cloneDocument1.showDocu();
        originDocument.showDocu();*/
        // 2.深拷贝  拷贝对象时，对于引用形的字段，也采用拷贝的形式  而不是单纯的引用
        WordDocument originDocument = new WordDocument();
        originDocument.setText("这是一篇文档");
        originDocument.setImages("图片1");
        originDocument.setImages("图片2");
        originDocument.setImages("图片3");
        originDocument.showDocu();
        // 以原始文档为对象  拷贝一份
        WordDocument cloneDocument1 = originDocument.clone();
        originDocument.showDocu();
        // 修改备份文档  不会影响原始文档
        cloneDocument1.setText("这是修改过的文档2");
        cloneDocument1.setImages("哈哈.jpg");
        cloneDocument1.showDocu();
        originDocument.showDocu();
    }
}

四、工厂方法模式

/**
 * 具体工厂类
 * <p>
 * 也可以给某个产品设置自己的工厂类  各司其职
 * Created by Bill on 2017/12/23.
 */
public class ConcreateFactory extends Factory {
    /**
     * 静态方法
     *
     * @return
     */
    @Override
    public Product createProduct() {
        //  return new ConcreteProductA();
        return new ConcreteProductB();
    }
    /**
     * 需要什么对爱那个  传入那个对象的类型即可
     *
     * @param tClass
     * @param <T>
     * @return
     */
    @Override
    public <T extends Product> T createProduct(Class<T> tClass) {
        Product p = null;
        try {
            p = (Product) Class.forName(tClass.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) p;
    }
}
package com.zhao.bill.designmodel.factorymodel.one;
/**
 * 具体的产品A
 * Created by Bill on 2017/12/23.
 */
public class ConcreteProductA extends Product {
    @Override
    public void method() {
        System.out.println("我是具体的产品A");
    }
}
package com.zhao.bill.designmodel.factorymodel.one;
/**
 * 抽象工厂类
 * Created by Bill on 2017/12/23.
 */
public abstract class Factory {
    /**
     * 抽象工厂方法
     *
     * @return
     */
    public abstract <T extends Product> T createProduct(Class<T> tClass);
    public abstract Product createProduct();
}
package com.zhao.bill.designmodel.factorymodel.one;
/**
 * 抽象产品类
 * Created by Bill on 2017/12/23.
 */
public abstract class Product {
    /**
     * 抽象方法
     */
    public abstract void method();
}

五、抽象工厂方法模式

/**
 * 客户类
 * Created by Bill on 2018/1/12.
 */
public class CarBuilderClient {
    public static void main(String[] args) {
        Q3Factory factory = new Q3Factory();
        factory.createBrake().brake();
        factory.createEngine().engine();
        factory.createTire().tire();
        System.out.println("=======================");
        Q7Factory q7Factory = new Q7Factory();
        q7Factory.createBrake().brake();
        q7Factory.createEngine().engine();
        q7Factory.createTire().tire();
    }
}

六、观察者模式

1、编写观察者和被观测者抽象接口
    /**
     * desc: 观测者 抽象接口
     * author：Bill
     * date: 2018/1/31
     */
    public interface Observer {
        void update(int edition, float cost);
    }
    /**
     * desc:被观察者 抽象接口
     * author：Bill
     * date: 2018/1/31
     */
    public interface Observerable {
        // 注册
        void registerObserver(Observer o);
        // 解绑
        void removeObserver(Observer o);
        // 通知观测者
        void notifyObservers();
    }
2、实现被观察者接口
    /**
     * desc: 被观测者
     * author：Bill
     * date: 2018/1/31
     */
    public class MagazineData implements Observerable {
        private List<Observer> mObservers;
        private int edition;
        private float cost;
        public MagazineData() {
            mObservers = new ArrayList<>();
        }
        /**
         * 注册观察者
         *
         * @param o
         */
        @Override
        public void registerObserver(Observer o) {
            mObservers.add(o);
        }
        /**
         * 移除观察者
         *
         * @param o
         */
        @Override
        public void removeObserver(Observer o) {
            int i = mObservers.indexOf(o);
            if (i >= 0) {
                mObservers.remove(i);
            }
        }
        /**
         * 通知观察者
         */
        @Override
        public void notifyObservers() {
            // 遍历观察者 发送通知
            for (int i = 0; i < mObservers.size(); i++) {
                Observer observer = mObservers.get(i);
                observer.update(edition, cost);
            }
        }
        public void setInformation(int edition, float cost) {
            this.edition = edition;
            this.cost = cost;
            //信息更新完毕，通知所有观察者
            notifyObservers();
        }
    }
3、实现观察者接口
    /**
     * desc: 具体的观察者  实现观察者抽象接口Observer
     * author：Bill
     * date: 2018/1/31
     */
    public class Customer implements Observer {
        private String name;
        private int edition;
        private float cost;
        Customer(String name) {
            this.name = name;
        }
        @Override
        public void update(int edition, float cost) {
            this.edition = edition;
            this.cost = cost;
            buy();
        }
        private void buy() {
            System.out.println(name + "购买了第" + edition + "期的杂志，花费了" + cost + "元。");
        }
    }
4、编写测试类
    public class Test {
        public static void main(String[] args) {
            //创建被观察者
            MagazineData magazine = new MagazineData();
            //创建三个不同的观察者
            Observer customerA = new Customer("A");
            Observer customerB = new Customer("B");
            Observer customerC = new Customer("C");
            //将观察者注册到被观察者中
            magazine.registerObserver(customerA);
            magazine.registerObserver(customerB);
            magazine.registerObserver(customerC);
            //更新被观察者中的数据，当数据更新后，会自动通知所有已注册的观察者
            magazine.setInfomation(5, 12);
        }
    }