《设计模式之禅》读书笔记（二）

设计模式

这里开始总结设计模式，以代码的方式展现出来：

一.单例模式

/**
 * Created by hyz84 on 16/12/9.
 * 懒汉式
 */
public class SingletonBean1 {
    private String name;
    private static SingletonBean1 bean=null;
    private SingletonBean1(){}
    public static SingletonBean1 getInstance(){
        if(bean ==null){
            bean = new SingletonBean1();
        }
        return  bean;
    }
}

/**
 * Created by hyz84 on 16/12/9.
 * 饿汉式
 */
public class SingletonBean2 {
    private String name;
    private static SingletonBean2 bean=new SingletonBean2();
    private SingletonBean2(){}
    public static SingletonBean2 getInstance(){
        return  bean;
    }
}

二.工厂模式

/**
 * 工厂模式： 定义一个用于创建对象的接口，让子类决定实例化哪一个类。
 * 工厂方法使一个类的实例化延迟到其子类。
 * Created by hyz84 on 16/12/12.
 */

public class FactoryPattern {
    //抽象产品类
    public abstract class Product {
        //公共方法
        public void method1() {
        }

        //产品抽象方法
        public abstract void method2();
    }

    // 具体产品1
    public class Product1 extends Product {

        @Override
        public void method2() {

        }
    }

    // 具体产品2
    public class Product2 extends Product {

        @Override
        public void method2() {

        }
    }

    //抽象工厂类
    public abstract class Creator {
        public abstract <T extends Product> T createProduct(Class<T> c);

    }

    //具体工厂
    public class ConcreteCreator extends Creator {

        @Override
        public <T extends Product> T createProduct(Class<T> c) {
            Product product = null;

            try {
                product = (Product) Class.forName(c.getName()).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }

            return (T) product;
        }
    }

    //场景类
    public class Client {
        Creator mCreator = new ConcreteCreator();

        Product mProduct1 = mCreator.createProduct(Product1.class);
        Product mProduct2 = mCreator.createProduct(Product2.class);
    }
    /**************************************************************************/
    /***************简单工厂类*******************/
    /**
     * 简单工厂类
     */
    public static class ProductFactory {
        public static <T extends Product> T createProduct(Class<T> c) {
            Product product = null;
            try {
                product = (Product) Class.forName(c.getName()).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return (T) product;
        }
    }

    //场景类
    public class Client2 {
        Product mProduct1 = ProductFactory.createProduct(Product1.class);
        Product mProduct2 = ProductFactory.createProduct(Product2.class);
    }
    /**************************************************************************/
    /******************多工厂模式***********************/
    /**
     * 多工厂模式
     */
    public abstract class AbstactProductFactory {
        public abstract Product createProduct();
    }

    public class Product1Factory extends AbstactProductFactory {
        @Override
        public Product createProduct() {
            return new Product1();
        }
    }

    public class Product2Factory extends AbstactProductFactory {

        @Override
        public Product createProduct() {
            return new Product2();
        }
    }

    //场景类
    public class Client3 {
        Product mProduct1 = (new Product1Factory()).createProduct();
        Product mProduct2 = (new Product2Factory()).createProduct();
    }
    /*************************************************************************************************/

    /******************抽象工厂模式********************************/
    /**
     * 产品族A
     */
    public abstract class AbstractProductA {
        public void method1() {
        }

        public abstract void method2();
    }

    public class ProductA1 extends AbstractProductA {
        @Override
        public void method2() {
        }
    }

    public class ProductA2 extends AbstractProductA {
        @Override
        public void method2() {
        }
    }

    /**
     * 产品族B
     */
    public abstract class AbstractProductB {
        public void method1() {
        }

        public abstract void method2();
    }

    public class ProductB1 extends AbstractProductB {
        @Override
        public void method2() {
        }
    }

    public class ProductB2 extends AbstractProductB {
        @Override
        public void method2() {
        }
    }

    /**
     * 抽象工厂
     */
    public abstract class AbstractFactory{
        public abstract AbstractProductA createProductA();
        public abstract AbstractProductB createProductB();
    }

    /**
     * 生产1类产品工厂
     */
    public class Factory1 extends AbstractFactory{

        @Override
        public AbstractProductA createProductA() {
            return new ProductA1();
        }

        @Override
        public AbstractProductB createProductB() {
            return new ProductB1();
        }
    }
    /**
     * 生产2类产品工厂
     */
    public class Factory2 extends AbstractFactory{

        @Override
        public AbstractProductA createProductA() {
            return new ProductA2();
        }

        @Override
        public AbstractProductB createProductB() {
            return new ProductB2();
        }
    }

    //场景类
    public class Client4 {

        AbstractFactory mFactory1 = new Factory1();
        AbstractFactory mFactory2 = new Factory2();

        AbstractProductA a1 = mFactory1.createProductA();
        AbstractProductB b1 = mFactory1.createProductB();

        AbstractProductA a2 = mFactory2.createProductA();
        AbstractProductB b2 = mFactory2.createProductB();


    }
}

三.模板方法模式

/**
 * 模板方法模式： 定义一个操作中的算法的框架，而将一些步骤延迟到子类中。
 * 使得子类可以不改变一个算法结构即可重定义改算法的某些特定步骤。
 * Created by hyz84 on 16/12/12.
 */

public class TemplateMethodPattern {
    /**
     * 抽象模板类
     */
    public abstract class AbstactClass {
        protected abstract void doSomthing();
        protected abstract void doOtherThing();
        public void templateMethod() {
            this.doSomthing();
            this.doOtherThing();
        }
    }

    /**
     * 具体模板类
     */
    public class ConcreteClass1 extends AbstactClass{
        @Override
        protected void doSomthing() {
        }

        @Override
        protected void doOtherThing() {
        }
    }
    /**
     * 具体模板类
     */
    public class ConcreteClass2 extends AbstactClass{
        @Override
        protected void doSomthing() {
        }
        @Override
        protected void doOtherThing() {
        }
    }
    public class Client {
        AbstactClass mClass1 = new ConcreteClass1();
        AbstactClass mClass2 = new ConcreteClass2();
        mClass1.templateMethod();
        mClass2.templateMethod();

    }

    /******************************************************/
    /************模板模式拓展****************/
    /**
     * 抽象模板类
     */
    public abstract class AbstactClassPro {
        protected abstract void doSomthing();
        protected abstract void doOtherThing();
        protected abstract boolean isDoS();
        public void templateMethod() {
            if(this.isDoS()){
                this.doSomthing();
            }
            this.doOtherThing();
        }
    }

    /**
     * 具体模板类
     */
    public class ConcreteClassPro1 extends AbstactClassPro{
        @Override
        protected void doSomthing() {
        }

        @Override
        protected void doOtherThing() {
        }

        @Override
        protected boolean isDoS() {
            return false;
        }
    }
    /**
     * 具体模板类
     */
    public class ConcreteClassPro2 extends AbstactClassPro{
        @Override
        protected void doSomthing() {
        }
        @Override
        protected void doOtherThing() {
        }

        @Override
        protected boolean isDoS() {
            return true;
        }
    }

    public class Client1 {
        AbstactClassPro mClass1 = new ConcreteClassPro1();
        AbstactClassPro mClass2 = new ConcreteClassPro2();
        mClass1.templateMethod();
        mClass2.templateMethod();

    }
}