设计模式（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;
    }
}