设计模式的一些日常记录

内容是看了设计模式之禅，然后自己写个文档总结到一起，便于查看。

单例模式：（程序运行过程中只能有一个类的对象）

　　单例模式主要是对构造方法进行私有化 private，防止外部通过 new方法 创建实体类。针对该类中的方法尽量使用static修饰，便于访问。

public class Singleton {

    private static final Singleton singleton = new  Singleton();

    private Singleton(){ }

    //通过该方法获得实例对象
    public static Singleton getSigleton(){
        return singleton;
    }

    public static void  talk(){
        System.out.println("我被执行了");
    }

}


public class Client {

    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getSigleton();
        Singleton singleton2 = Singleton.getSigleton();
        System.out.println(singleton1 ==  singleton2);
        System.out.println(singleton1.equals(singleton2));
    }
}

执行结果：
true
true

工厂模式：定义：一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使类的实例化延迟到其子类。

　　工厂模式主要是包含：工厂类（可以是抽象类，可以是接口，主要是用来定义有哪些方法），具体工厂类，产品类（可以是抽象类，可以是接口，主要是用来定义产品有哪些方法），产品实现类。只需要知道工厂类，实体类类名，就能获取到实体类对象，然后通过实体类对象调用实体中写的方法。

/**
 * 抽象产品类
 */
public abstract class Human {
    //不同种族的肤色不同
    public abstract void getColor();

    //不同种族语言不同
    public abstract void getTalk();

}

public class BlackHuman extends Human {


    @Override
    public void getColor() {
        System.out.println("黑色人种的皮肤是黑色的");
    }

    @Override
    public void getTalk() {
        System.out.println("黑色人种通用语言英语");
    }
}


public class YellowHuman extends Human {


    @Override
    public void getColor() {
        System.out.println("黄色人种的皮肤是黄色的");
    }

    @Override
    public void getTalk() {
        System.out.println("黄色人种通用语言是普通话");
    }
}


/**
 * 抽象人类创建工厂
 *
 */
public abstract class AbstractFactory {
    //获取人类对象
    public abstract <T extends Human> T createHuman(Class c);

}

/**
 * 具体工厂类
 */
public class HumanFactory extends AbstractFactory {

    @Override
    public <T extends Human> T createHuman(Class c) {
        //定义一个生产的人种
        Human  human = null;
        try {
            human = (T)(Class.forName(c.getName())).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return  (T)human;
    }
}

public class Client {
    public static void main(String[] args) {
        //创建一个人类工厂
        AbstractFactory factory = new HumanFactory();

        BlackHuman blackHuman = factory.createHuman(BlackHuman.class);
        blackHuman.getColor();
        blackHuman.getTalk();

        YellowHuman yellowHuman = factory.createHuman(YellowHuman.class);
        yellowHuman.getColor();
        yellowHuman.getTalk();
    }
}

抽象工厂模式：定义：一个用于创建一组相关或者相互依赖的对象提供一个接口，无需指定他们的具体实现类。

　　在工厂模式的升级版

　　主要是 有N产品族在抽象工厂中就有N个创建方法。有M个产品等级就应该有M个实现工厂类，在每个实现工厂中，实现不同产品族的生产任务。　　

//抽象的产品类
public abstract class AbstractProductA {
    //每个产品都有公共的方法
    public  void getProductName(){
        System.out.println("我是一个产品");
    }

    //每个产品相同方法，不同实现
    public abstract void doSomething();
}


//抽象的产品类
public abstract class AbstractProductB {
    //每个产品都有公共的方法
    public  void getProductName(){
        System.out.println("我是一个产品B");
    }

    //每个产品相同方法，不同实现
    public abstract void doSomething();
}


public class ProductA1 extends AbstractProductA{

    @Override
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}

public class ProductA2 extends AbstractProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A2的实现方法");
    }
}


public class ProductB1 extends AbstractProductB {
    @Override
    public void doSomething() {
        System.out.println("产品B1的实现方法");
    }
}

public class ProductB2 extends AbstractProductB {
    @Override
    public void doSomething() {
        System.out.println("产品B2的实现方法");
    }
}

/**
 * 有多少个产品族，在抽象工厂中就有多少个创建方法
 */
public abstract class AbstractFactory {

    //创建A产品家族
    public abstract AbstractProductA createProductA();
    //创建B产品家族
    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 Client {
    public static void main(String[] args) {
        //创建出两个工厂
        AbstractFactory factory1 = new Factory1();
        AbstractFactory factory2 = new Factory2();
        //产品A对象
        AbstractProductA a1 = factory1.createProductA();
        AbstractProductA a2 = factory2.createProductA();

        //产品B对象
        AbstractProductB b1 = factory1.createProductB();
        AbstractProductB b2 = factory2.createProductB();

        a1.doSomething();
        a2.doSomething();
        b1.doSomething();
        b2.doSomething();
    }
}

运行结果：
产品A1的实现方法
产品A2的实现方法
产品B1的实现方法
产品B2的实现方法

模板模式：

　　主要是抽象模板类定义方法，模板实现类集成模板方法。但是通用的方法写到抽象模板类方法中。（如算法 它的参数可以不同，但是执行的步骤相同。就可以提取出来，放到抽象模板类方法中。）

　　代码待完成

建造者模式：类似于定义了一个算法，然后算法的步骤在于具体实现类，实现步骤不同会生成不同的对象。

　　和工厂模式相似，建造者模式重在零件组装，工厂模式重在零件的创建。一个是组装方法步骤，一个是类的创建，不关注组装。

代理模式：