设计模式（2）

 

工厂模式：定义了一个创建对象的接口，但由子类决定要实现实例化的类是哪一个，工厂方法让类把实例化推迟到子类。

1、所有的工厂都是用来封装对象的创建。

2、工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象。

3、抽象工厂方法使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中。

4、抽象工厂创建相关的对象家族，而不需要依赖他们的具体类。

5、依赖倒置原则，指导我们避免依赖具体类型，而要尽量依赖抽象。

public class MailSend implements Sender {    public void Send() {        System.out.println("send a mail");    }}public interface Sender {    public void Send();}public class SendFactory {    public Sender produce(String type) {        if ("mail".equals(type)) {            return new MailSend();        } else if ("sms".contains(type)) {            return new SmsSend();        } else {            System.out.print("请输入正确的类型");            return null;        }    }    public Sender SenderMail(){        return new MailSend();    }    public Sender SenderSms(){        return new SmsSend();    }}public class SmsSend implements Sender {    public void Send() {        System.out.println("send a sms");    }}public class TestFactoryDemo {    @Test    public void singleFantoryDemo() {        SendFactory sf = new SendFactory();        Sender sender = sf.produce("sms");        sender.Send();    }    @Test    public void doubleFactoryDemo() {        SendFactory sf = new SendFactory();        Sender sender = sf.SenderMail();        sender.Send();    }}

单件模式：确保一个类只有一个实例，并提供一个全局访问点。

1、确保一个类最多一个实例。

2、实现单例模式需要私有的构造器、一个静态方法和一个静态变量。

3、解决多线程的问题。

public class TestSingleDemo {    @Test    public void Test1() {        Single s1 = Single.getInstance();        Single s2 = Single.getInstance();        s1.setNum(10);        System.out.println("s2.getNum():" + s2.getNum());        // Single s3 = new Single();        // Single s4 = new Single();        // s3.setNum(10);        // System.out.println("s4.getNum():" + s4.getNum());    }    @Test    public void Test2() {        Single1 s1 = Single1.getInstance();        Single1 s2 = Single1.getInstance();        s1.setNum(10);        System.out.println("s2.getNum():" + s2.getNum());    }}/** * @Description:饿汉式，先初始化对象 */class Single1 {    private int num;    public int getNum() {        return num;    }    public void setNum(int num) {        this.num = num;    }    // 1.将构造函数私有化    private Single1() {        System.out.println("对象建立");    }    // 2.在类中创建本类对象    private static Single1 s = new Single1();    // 3.提供一个方法可以获取该对象    public static Single1 getInstance() {        System.out.println("饿汉式，先初始化对象");        return s;    }}/** * @Description:懒汉式,方法被调用时才初始化，延时加载 */class Single {    private int num;    public int getNum() {        return num;    }    public void setNum(int num) {        this.num = num;    }    // 1.将构造函数私有化    private Single() {        System.out.println("对象建立");    }    // 2.在类中创建本类对象    private static Single s = null;    // 3.提供一个方法可以获取该对象    public static Single getInstance() {        if (null == s)            System.out.println("懒汉式延迟加载");        s = new Single();        return s;    }}