JAVA后端知识点碎片化整理 基础篇（十八） 设计模式 （手敲加深理解）

目录

 

（1）什么是设计模式

（2）单例设计模式（饿汉模式 懒汉模式）

（3）工厂设计模式

(4)建造者模式（Builder）

(5)适配器设计模式

（6）装饰模式（Decorator）

(7)策略模式（strategy）

(8)观察者模式（Observer） 

这个模式有点小触动！！！之前想写这种来着的，我。。。。。不会

 

---

（1）什么是设计模式

面向对象的设计比较困难，一个设计应该是具有针对性的且对于未来有一定通用性，先找到相关的对象在以适当的粒度对他们归类，在对每个类定义接口和继承层次，最后确定每个对象之间的联系。有经验的设计者的确可以做出很好的设计，然后对没有经验的人面对这些对题却无从下手，而且并不是所有的问题都需要从头开始解决，有些时候可以套用之前的设计方案，这是一种思想的传承也是代码的复用。

所谓模式就是使新手更加简单的使用前人的经验和方案。而将这些经验转换为能够被人们有效利用的形式，这个形式就是模式。每一种模式都描述这不断重复发生的问题以及解决该问题的解决方案的核心。

总体而言设计模式分三大类：

创建型模式：共五种，工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式：七种：适配器模式，装饰器模式，代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问模式、中介者模式、解释器模式。

（2）单例设计模式（饿汉模式 懒汉模式）

//饿汉模式
public class Singleton{
    //直接创建对象
    public static Singleton instance = new Singleton();
    //私有构造函数
    private Singleton(){
    }
    //返回对象实例
}
//懒汉模式
public class Singleton{
    //声明变量
    private static volatile Singleton singleton = null;
    //私有构造函数
    private Singleton(){
    }
    //提供对外方法
    public static Singleton getInstance(){
        if(singleton == null){        //这里的双重判断值得看一下
            synchronized(Singleton.class){
                if(singleton == null){   //这里的双重判断值得看一下  为了防止并发访问
                    singleton = new Singleton();
                }
            }
        }
    }
}

（3）工厂设计模式

工厂模式分为工厂方法模式和抽象工厂模式。

1、工厂方法模式   工厂方法模式分为三种：普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。多个方法工厂模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确的创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。 静态工厂方法模式，将上面的多个工厂方法里置为静态的，不需要创建实例，直接调用即可。

普通工厂模式

//普通工厂模式
//接口类
public interface Sender{
    public void Send();
}
//实现类
public class MailSender implements Sender{
    @Override
    public void Send(){
        System.out.println("this is mail sender");
    }
}
public class SmsSender implements Sender{
    @Override
    public void Send(){
        System.out.println("this is sms sender");
    }
}

public class SenderFactory{
    public Sender produce(String type){
        if("mail".equals(type)){
            return new MailSender();
        }else if("sms".equals(type)){
            return new SmsSender();
        }else{
            System.out.println("输入正确类型")
            return null;
        }
    }
}

多个工厂方法模式

public class SendFactory{
    public Sender produceMail(){
        return new MainlSender();
    }
    public Sender produceSms(){
        reutrn new SmsSender();
    }

    public class Factory{
        public static void main(String[] args){
            SendFactory factory  = new SenderFactory();
            Sender sender = factory.produceMail();
            sender.send;
        }
    }
}

静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

public class SendFactory{
    public static Sender produceMail(){
        return new MailSender();
    }
    public static Sender produceSms(){
        return new SmsSender();
    }

    public class FactoryTest{
        public static void main(String[] args){
            Sender sender = SendFactory.produceMail();
            sender.send();
        }
    }
}

抽象工厂模式：工厂模式有一个问题就是类的创建依赖于工厂类，如果想要扩展程序，必须对工厂类进行修改，这违背了闭包的原则，所以从设计角度考虑，有一定的问题，所以就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了。

//接口抽象工厂基类
public interface Provider{
    public Sender produce();
}
//上述的邮件工厂
public class SendSmsFactory implements Provider{
    @Override
    public Sender produce(){
        return new SmsSender();
    }
}
public class SendMailFactory implements Provieder{
    @Override
    public Sender produce(){
        return new MailSender();
    }
}

//
public class Test{
    public static void main(String[] args){
        Provider provider = new SendMailFactory();
        Sender sender = provider.produce();
        sender.send();
    }
}

(4)建造者模式（Builder）

工厂类是为了提供创建单个类的模式，而构造者模式则是为了将各种产品集中起来进行管理，用来创建符合对象，所谓符合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和test结合的一种实现。

public class Product{
    private List<String> parts = new ArrayList<String>();
    
    public void add(String partName){
        parts.add(partName);
    }
    
    public void show(){
        System.out.println("--产品创建--")；
        for(String part:parts){
            System.out.println(part);
        }
    }
}
//定义Builder抽象类，并定义Product 包括 partA，partB，partC
public abstract class Builder{
    protected abstract void buildPartA();
    protected abstract void buildPartB();
    protected abstract void buildPartC();
    
    protected abstract Product getResult();
}
//分别定义ConcreateBuilder角色的BuilderA和BuilderB
public class BuilderA extends Builder{
    private Product product = new Product();
    @Override
    protected void buildPartA(){
        product.add("partA");
    }
    @Override
    protect void buildPartB(){
        product.add("partB");
    }
}
public class BuilderB extends Builder{
    private Product product = new Product();
    @Override
    protected void buildPartA(){
        product.add("partX");
    }
    @Override
    protected void buildPartB(){
        protect.add("partY");
    }
    @Override
    protect void buildPartC(){
        product.add(partZ");
    }
    @Override
    protect Product getResult(){
        return product;
    }
}
//下面我们定义指导者角色BuilderDirector，在类中添加Builder的引用，并通过其构造方法初始化builer属性。
public class BuilderDirector{
    private Builder builder = null;

    public BuilderDirector(Builder builder){
        this.builder = builder;
    }
    public Product build(){
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

构建者模式的好处是使建造者模式可以使客户端不必知道产品内部组成的细节，具体的建造者类之间是相互独立的，这有利于系统的扩展。具体的建造者互相独立，因此可以对建造的过程逐步细化，而不可对其他模块产生任何影响。

使用场景：1创建一些复杂对象时，这些对象的内部组成部分之间的建造顺序是稳定的，但对象内部组成构建面临复杂的变化，2、创建的复杂对象的算法，独立于该对象的组成部分。

(5)适配器设计模式

适配器模式将某个类的接口转换为客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题，主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

我们通常用的比较多是接口的适配器模式， 有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处是为了解决这个问题，我们引入了接口的适配器模式，借助一个抽象类，该抽象类实现了该接口，实现了了所有的方法，而我们不和原始的接口打交道，只是和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。

（6）装饰模式（Decorator）

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

public interface Sourceable{
    public void method();
}
public class Source implements Sourceable{
    @Override
    public void method{
        System.out.println("the original method");
    }
}
----------------------------------------------------
public class Decorator implements Sourceable{
    private Sourceable source;
    public Decorator(Sourceable source){
        super();
        this.source = source;
    }
    @Override
    public void method(){
        System.our.println("before decorator!");
        source.method();
        System.out.println("after decorator!");
    }
    public class DecoratorTest{
        public static void main(String[] args){
            Sourceable source = new Source();
            Sourceable obj = new Decorator(source);
            obj.method();
        }
    }
}

(7)策略模式（strategy）

策略模式定义一系列算法，并将每个算法封装起来，使他们可以互相替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。                    策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定哪个算法即可。

public interface ICalculator{
    public int calculate(String exp);
}
public class Minus extends AbstractCalculator implements ICalculator{
    @Override
    public int calculate(String exp){
        int arrayInt[] = split(exp,"-");
        return arrayInt[0] - arrayInt[1];
    }
}
public class Plus extends AbstractCalculator implements ICalculator{
    @Override
    public int calculate(String exp){
        int arrayInt[] = split(exp,"\\+");
        return arrayInt[0] + arrayInt[1];    
    }
}
public class AbstractCalculator{
    public int[] split(String exp,String opt){
        String array[] = exp.split(opt);
        int arrayInt[] = new int[2];
        arrayInt[0] = Integer.parseInt(array[0]);
        arrayInt[1] = Integer.parseInt(array[1]);
        return arrayInt;
    }
}

(8)观察者模式（Observer） 

这个模式有点小触动！！！之前想写这种来着的，我。。。。。不会

观察者模式，类似于邮件订阅和Rss订阅，当我们要浏览一个博客或者wiki时候，经常会看到RSS图标，就是这个意思，当你订阅了该文章，如果后续有更新的话，会即时通知你。其实，简单来说的话：当一个对象变化时，其他依赖该对象的对象会收到通知，并随之变化！对象是一种一对多的关系。

public interface Observer{
    public void update();
}
public class Observer1 implements Observer{
    @Override
    public void update(){
        System.out.println("oberver1 has received!");
    }
}
public class Observer2 implements Observer{
    @Override
    public void update(){
        System.out.println("observer2 has received!");
    }
}
/
public interface Subject{//观察者对象接口
    //增加观察者
    public void add(Observer observer);
    //删除观察者
    public void del(Observer oberver);
    //通知所有观察者
    public void notifyObservers();
    //自身的操作
    public void operation();
}
/
public abstract class AbstractSubject implements Subject{//固定要实现的几个方法
    private Vector<Observer> vertor = new Vector<Observer>();
    @Override
    public void add(Observer observer){
        vector.add(observer);
    }
    @Override
    public void del(Observer observer){
        vector.add(observer);
    }
    @Override
    public void notifyObservers(){
        Enumeration<Observer> enumo = vector.elements();
        while(enumo.hasMoreElements()){
            enumo.nextElement().update();
        }
    }
}
/
public class MySubject extends AbstractSubject{//这里继承的是Subject的operation
    @Override
    public void operation(){
        System.out.println("update self");
        this.notifyObservers();
    }
}

public class ObserverTest{
    public static void main(String[] args){
        Subject sub = new MySubject();
        sub.add(new Observer1());
        sub.add(new Observer2());
        sub.operation();
    }
}