23种常用的设计模式

23种设计模式总体可以分为三类：一、创建型模式工厂模式、抽象工厂、单例模式、建造者模式、原型模式二、结构型模式装饰器模式、适配器模式、代理模式、外观模式、

23种设计模式总体可以分为三类：

一、创建型模式

　　工厂模式、抽象工厂、单例模式、建造者模式、原型模式

二、结构型模式

　　装饰器模式、适配器模式、代理模式、外观模式、桥接模式、组合模式、享元模式

三、行为型模式

　　策略模式、观察者模式、模板方法模式、责任链模式、迭代子模式、备忘录模式、命令模式、访问者模式、中介者模式、状态模式、解释器模式

下面主要介绍以上9种红色字体的设计模式。

（1）工厂模式：定义一个创建对象的接口，让子类决定具体实例化哪一个对象。

public interface Sender{
    void sender();
}
public class SenderFactory{   //创建简单工厂
    public Sender produce(String type){
        if(type.equals("mail")){
            return new MailSender();
        }else if(type.equals("msg")){
            return new MsgSender();
        }else{
            return null;
        } 
    }
}

（2）抽象工厂：为一组相关或相互依赖的对象提供一个接口，且无需指定他们的具体实现类。

//定义实现功能的接口
public interface Sender{
    void sender();
}
//定义生产工厂的接口,提供一个返回上面接口功能的方法，比如Sender
public interface Provider{
    Sender produce();
}
//扩展发送邮件的实现类
public class MailSenderFactory implements Provider{
    @Override
    Sender produce(){
        return new MailSender();
    }
}

（3）单例模式：确保一个类只存在一个实例（介绍两种线程安全的单例模式）

1.使用volatile关键字实现线程安全的单例模式

public class SingletonInstance03 {
    private static volatile SingletonInstance03 singletonInstance03= null;   //将这个变量定义为线程可见的
    private SingletonInstance03(){} 
    public static SingletonInstance03 getInstance(){
        if(singletonInstance03 == null){
            //对这个实例加锁
            synchronized (singletonInstance03){
                if(singletonInstance03 == null){
                    singletonInstance03 = new SingletonInstance03();
                }
            }
        }
        return singletonInstance03;
    }
}

2.使用内部类持有单例实例来实现线程安全的单例模式。

public class SingletonInstance04 {
    private SingletonInstance04(){}
    private static class InstanceHolder{
        public  static SingletonInstance04 singletonInstance04 = new SingletonInstance04();
    }
    public static SingletonInstance04 getInstance(){
        return InstanceHolder.singletonInstance04;
    }
}

（4）适配器模式：将一个类的接口转换成客户端所期待的另一个接口。（分为类的适配器模式、对象的适配器模式、接口的适配器模式）

1.类的适配器模式：使用适配器类继承一个类同时实现一个接口。

public class Sourceable{
    public void method1(){System.out.println("sourceable的方法");}
}
public interface Targetable{ 
    void method1();
    void method2();
}
public class Adapter extends Sourceable implements Targetable{
    @Override
    public void method2(){
        System.out.println("类的适配器的method2方法");
    }
}

2.对象的适配器模式：适配器类中拥有被适配类的实例，通过构造器将被适配类的实例传入进来

public class Source{
    public void method1(){
        System.out.println("对象的适配器的method1方法");
    }
}
public interface Targetable{
    void method1();
    void method2();
}
public class Adapter implements Targetable{
    private Source source;
    public Adapter(Source source){
        this.source = source;
    }
     @Override
     void method1(){
         source.method1();
     }
     @Override
     void method2(){
         System.out.println("接口中方法2的实现");
     }
}

3.接口的适配器模式：通过一个抽象类先去实现接口

public interface Sourceable{
    void method1();
    void method2();
}
public abstract class AdapterForInterface implements Sorceable{
    @Override
    void method1(){}
    @Override
    void method2(){}
}
public class SourceSub1 extends AdapterForInterface{
    @Override
    void method1(){
        System.out.println("重写抽象类的方法1");
    }
}

（5）装饰器模式：给一个对象动态的增加新的功能，要求装饰对象和被装饰对象实现共同的接口，并且装饰对象持有被装饰对象的实例。

public class Source{  //被装饰类
    public void decorated(){
        System.out.println("被装饰方法。");
    }
}
public class Decorator{
    private Source souce;
    public Decorator(Source source){
        this.source = source;
    }
    public void decorator(){
        System.out.println("装饰前。。。");
        source.decorated();
        System.out.println("装饰后。。。");
    }
}

（6）代理模式：在不改变源码的情况下，为原对象提供一个代理类，替原对象进行操作。（分类静态代理，JDK动态代理，CGLib动态代理）

1.静态代理：在代理前已经知道了被代理的类，代理类重写了被代理类的接口的方法

public interface UserService{
    void addUser(User user);
}
public class UserServiceImpl{
    void addUser(User user){
        System.out.println("添加用户成功！");
    }
}
public class UserServiceImplProxy implements UserService{
    private UserService userService;
    public UseServiceImpProxy(UserService userService){
        this.userService = userService;
    }    
    @Override
    void addUser(User user){
        System.out.println("进行添加用户前的操作...");
        userService.addUser(user);
        System.out.println("进行添加用户后的操作...");
    }
}

2.JDK动态代理：使用JavaJDK中自带的方式实现动态代理，关键点用到了Proxy类中的newInstanceProxy方法，并且代理类需要实现InvocationHandler接口。

public class UserServiceProxyFactory implements InvocationHandler{
    private UserService userService;
    public UserService(UserService userService){
        this.userService = userService;
    }    
    public UserServiceImp getUserServiceImp(){
        return (UserServiceImp )Proxy.newInstanceProxy(userService.getClass().getClassLoader(),
                            userService.getClass().getInterfaces(),
                            this);
    }
    public Object invoke(Object proxy,Method method,Object[] args){
        Object obj = method.invoke(proxy,args);       
        return obj;
    }
}

3.CGLib动态代理：需要实现MethodInterceptor接口，重写intercept方法。

public class SayHello{
    public void say(){
        System.out.println("请先说你好！");
    }
}
public class CgLibProxy implements MethodInterceptor{
    public SayHello getProxy(){
       Enchance en = new Enchance();
       en.setSuperClass(SayHello.class);  //设置被代理的类
      en.setCallback(this);
      SayHello  sayHello  = (SayHello)en.create(); //创建被代理的类
      return sayHello;
    }
    @Override
    public Object intercept(Object proxy,Method method,Object[] objs,MethodProxy methodProxy){
        System.out.println("被代理前做的事...");
        Object result = methodProxy.intercept(proxy,objs);
        System.out.println("被代理后做的事...");
        return result;
    }      
}

动态代理与CGLib代理的区别：使用动态代理是被代理类实现了接口，使用Cglib代理时被代理类没有实现接口，如上的UserServiceImp和SayHello类。

　　　　　　　　　　　　　　JDK动态代理产生对象的效率比Cglib高，但是由于CGLib采用ASM字节码生成框架操作起来效率比JDK动态代理高。

（7）策略模式：定义了一些列算法，并将它们封装起来，是的它们之间可以相互替换

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

（8）模板方法模式：定义一个算法的骨架，并将一些步骤延迟到子类中，使得子类可以不改变算法的结构就能重定义算法的某些步骤。（比如JDK中经典的AQS框架）

public abstract class AbstractCalculate{
    public int[] split(String exp,String opt){
        int[] ops = new int[2];
        String opts = exp.split(opt);
        ops[0] = Integer.parseInt(opts[0]);
        ops[1] = Integer.parseInt(opts[1]);
        return ops;
    }
    abstract int calculateHelper(int num1,int num2){}
    public final int calculate(String exp,String opt){
        int[] ints = split(exp,opt);
        return calculateHelper(ints[0],ints[1]);
    }
}
public class Plus extends AbstractCalculate{
    @Override
    int calculateHelper(int num1,int num2){
        return num1 + num2;
    }
}

（9）观察者模式：定义对象间一种一对多的依赖关系，使得每一个对象的状态改变，每一个依赖它的对象都能得到通知并被自动更新。

public interface Observe{
    void update();
}
public class Observe1 implements Observe{
    @Override
    public void update(){
        System.out.println("依赖的对象1接收到了改变的通知");
    }
}
public class Observe2 implements Observe{
    @Override
    public void update(){
        System.out.println("依赖的对象2接收到了改变的通知");
    }
}
public interface Subject{
    void addObserve(Observe observe);
    void remObserve(Observe observe);
    void notifyObserve();
    void operation();
}
public abstract class AbstractSubject implements Subject{
    private Vector<Observe> vector = new Vector<>();
    @Override
    void addObserve(Observe observe){
        vector.add(observe);
    }
    @Override
    void remObserve(Observe observe){
        vector.remove(observe);
    }
    @Override
    void notifyObserve(){
        Enumeration<Observe> elements = vector.elements();
        while(elements.hasMoreElements()){
            elements.nextElements().update();
        }
    }
}
public class MySubject extends AbstractSubject{
    @Override
   public void operation() {
       System.out.println("update itself");
       notifyObserve();
    }
}

为您推荐

Java设计模式：23种设计模式全面解析（超级详细）

23种设计模式之单例模式（C++版）

23种设计模式娓娓道来

23种设计模式(常见)

设计模式概念总结

设计模式最新文章