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();
}
}