设计模式

设计模式

单例模式

/**
 * 饥饿式 推荐
 */
public class Singleton {
    private static Singleton singleton = new Singleton();

    private Singleton() { }

    public static Singleton getSingleton(){
        return singleton;
    }
}

/**
 * 懒汉式
 */
public class Singleton1 {
    //声明私有静态修饰的本类型的对象引用
    private static Singleton1 singleton1 = null;
    //私有构造
    private Singleton1(){}
    //公共get方法获取单例对象
    public static /*synchronized*/ Singleton1 getSingleton1(){
        //加锁，多线程同步操作的处理
        if (null == singleton1){
            synchronized (Singleton1.class){
                if (null == singleton1){
                    singleton1 = new Singleton1();
                }
            }
        }
        return singleton1;
    }
}

工厂模式

普通工厂方法模式就是建立一个工厂类，对实现了同一接口的不同实现类进行实例的创建。

/**
 * 发送接口
 */
public interface Sender {
    void send();
}
//邮件发送
public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("邮件正在发送...");
    }
}
//sms发送
public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("SMS正在发送...");
    }
}

/**
 * 工厂
 */
public class SendFactory {
    //根据传入的type生产对象
    public Sender produce(String type){
        if ("mail".equals(type)){
            return new MailSender();
        }
        if ("sms".equals(type)){
            return new SmsSender();
        }
        return null;
    }
    
    public /*static*/ Sender produceMail(){
        return new MailSender();
    }

    public /*static*/ Sender produceSms(){
        return new SmsSender();
    }
}

public class SendFactoryTest {
    public static void main(String[] args) {
        SendFactory sendFactory = new SendFactory();
//      普通工厂方法
        Sender mail = sendFactory.produce("mail");
        mail.send();
        Sender sms = sendFactory.produce("sms");
        sms.send();
//      多个工厂方法
        Sender sender = sendFactory.produceMail();
        sender.send();
//      静态工厂方法
        SendFactory.produceMail().send();
    }
}

在普通（简单）工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常。

在多个工厂方法模式中，为了能够正确创建对象，先需要创建工厂类的对象才能调用工厂类中的生产方法。

静态工厂模式解决了创建工厂类的对象的问题

实际意义:

​ 工厂方法模式适合：凡是出现了大量的产品需要创建且具有共同的接口时，可以通过工厂方法模式进行创建。

主要缺点:

​ 工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序生产新的产品，就必须对工厂类的代码进行修改，这就违背了开闭原则。

抽象工厂模式

/**
 * 工厂接口
 */
public interface Provider {
    //自定义生产方法
    Sender produce();
}
public class MailProvider implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}
public class SmsProvider implements Provider {
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

/**
 * 发送接口
 */
public interface Sender {
    void send();
}
public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("邮件正在发送...");
    }
}
public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("SMS正在发送...");
    }
}

//扩展
public class PacketProvider implements Provider {
    @Override
    public Sender produce() {
        return new PacketSender();
    }
}
public class PacketSender implements Sender {
    @Override
    public void send() {
        System.out.println("包裹正在发送...");
    }
}


public class SendFactoryTest {
    public static void main(String[] args) {
//      抽象工厂方法
        Provider provider = new MailProvider();
        Sender sender1 = provider.produce();
        sender1.send();
//      扩展应用，包裹发送
        Provider provider1 = new PacketProvider();
        Sender sender2 = provider1.produce();
        sender2.send();
    }

抽象工厂模式扩展功能时，没有改变原有的代码，符合开闭原则

装饰器模式

装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

public interface Sourceable {
    void method();
}

public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("原本内容");
    }
}

/**
 * 装饰类
 */
public class Decorator implements Sourceable {
    private Sourceable sourceable;

    public Decorator(Sourceable sourceable) {
        this.sourceable = sourceable;
    }

    @Override
    public void method() {
        sourceable.method();//保证原有功能
        System.out.println("增加装饰");
    }
}

public class SourceableTest {
    public static void main(String[] args) {
        Sourceable sourceable = new Source();
        sourceable.method();
        System.out.println("------------------------------");

        Sourceable sourceable1 = new Decorator(sourceable);
        sourceable1.method();
    }
}

优点和缺点：

• 可以实现一个类功能的扩展。
• 可以动态的增加功能，而且还能动态撤销（继承不行）。
• 缺点：产生过多相似的对象，不易排错。

代理模式

代理模式就是找一个代理类替原对象进行一些操作。

public class Proxy implements Sourceable {
    private Source source;

    public Proxy() {
        this.source = new Source();
    }

    @Override
    public void method() {
        source.method();
        System.out.println("与装饰器不一样");
    }
}

public class SourceableTest {
    public static void main(String[] args) {
        Sourceable sourceable2 = new Proxy();
        sourceable2.method();
    }
}

优点：

• 如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的结果进行控制，这种方式就是代理模式。
• 使用代理模式，可以将功能划分的更加清晰，有助于后期维护。

代理模式和装饰器模式的比较:

• 装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象。
• 装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。

模板方法模式

模板方法模式主要指一个抽象类中封装了一个固定流程，流程中的具体步骤可以由不同子类进行不同的实现，通过抽象类让固定的流程产生不同的结果。

/**
 * 计算器，抽象类
 */
public abstract class AbstractCalculator {
//    将表达式按照指定的规则分割,调用运算方法计算
    public int splitExpression(String exp,String op){
        String[] split = exp.split(op);
        return calculate(Integer.valueOf(split[0]),Integer.valueOf(split[1]));
    }
//    运算方法
    public abstract int calculate(int ia,int ib);
}

//加
public class Plus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia + ib;
    }
}

//减
public class Minus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia - ib;
    }
}

public class AbstractCalculatorTest {
    public static void main(String[] args) {
        AbstractCalculator abstractCalculator = new Plus();
        int i = abstractCalculator.splitExpression("1+1", "\\+");
        System.out.println("最终的结果是"+i);//2

        AbstractCalculator abstractCalculator1 = new Minus();
        int i1 = abstractCalculator1.splitExpression("2-1", "\\-");
        System.out.println("最终的结果是"+i1);//1
    }
}

优点：

• 将多个子类共有且逻辑基本相同的内容提取出来实现代码复用。
• 不同的子类实现不同的效果形成多态，有助于后期维护。