java 设计模式

六大设计原则

• 开闭原则: 对类的扩展开放，对类的修改关闭。
• 里是替换原则：任何父类出现的地方子类可以替换。
• 依赖倒转原则：要面向接口编程，不要面向具体。
• 迪米特原则：要降低耦合一个类尽量少于其他类相互作用。
• 接口隔离：设计接口要精简单一,降低耦合，接口只做分内的事。
• 合成复用：尽量使用聚合能用聚合就不继承。

创建型模式（5种）：

• 工厂方法模式。

public class SimpleCarFactory {
    public static Car getCarSmall() {
        return new CarSmall();
    }

    public static Car getCarMax() {
        return new CarMax();
    }
    public static void main(String[] args) {
        Car car= SimpleCarFactory.getCarMax();
        System.out.println(car.getCarName());
    }
}

• 抽象工厂模式。

public class FactoryProducer {
    public static AbstractFactory getCarFactory(){
        return new CarFactory();
    }
    public static AbstractFactory getColorFactory(){
        return new ColorFactory();
    }
}

• 单例模式。
• 建造者模式。

/**
 * 定义建造者的模板
 */
public abstract class HouseBuild {
    protected House house = new House();

    protected abstract void setHouseName();

    protected abstract void setHouseColor();

    public House getBuild() {
        return house;
    }
}
// 建造的管理者
public class Director
{
    private HouseBuild builder;
    //1 构造方法的方式注入builder对象
    public Director(HouseBuild builder)
    {
        this.builder=builder;
    }
    //2 set方法注入builder对象
    public void setBuilder(HouseBuild builder)
    {
        this.builder=builder;
    }
    
    public House construct()
    {
        builder.setHouseName();
        builder.setHouseColor();
        return builder.getBuild();
    }
} 

/**
 * 具体的建造者实现建造方法
 */
public  class HouseBuildSmall extends HouseBuild {

    @Override
    public void  setHouseName(){
        house.setName("小房子");
    };
    @Override
    public  void  setHouseColor(){
        house.setColor("红色");
    };

}

• 原型模式。

// 分为深克隆和浅克隆
public class UserDeep implements Cloneable {

    private String name;
    private String age;

    private Car car;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public Object clone() {
        UserDeep o = null;
        try {
            // 浅克隆只需使用用super.clone();
            o = (UserDeep) super.clone();
            // 深度克隆克隆类的每一个引用类型
            o.car=(Car)o.car.clone();


        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
}

注意：工厂方法适合同一类型的，抽象工厂适合不同种族的。

结构型模式（7种）

• 适配器模式

// 继承原来的旧的类 实现新的接口匹配新的额功能
public class New extends Old implements NewInterface {

    // 继承原始旧的类的方法
    @Override
    public void show() {
        super.show();
    }
    // 适配新的接口方法
    @Override
    public void showNew() {

    }
}

• 桥接模式

//定义一个Abstract 基类 基类中有关联类的属性 子类继承基类子类通过基类的
//桥接获得关联类 。如果要增加对关联类的新的操作可以通过新增一个子类实现。
public abstract class AbstractColor {
    protected House house;
    
    protected void setHouse(House house) {
        this.house = house;
    }
	// 子类可以对House类型进行各种操作
    public abstract void color();
}
public class ColorRed extends AbstractColor {
    @Override
    public void color() {
        System.out.println("红色");
        this.house.show();
    }
}
public class HouseMax implements House {
    @Override
    public void show() {
        System.out.println("大房子");
    }
}

    public static void main(String[] args) {
        AbstractColor ab=new ColorRed();
        House house=new HouseMax();
        ab.setHouse(house);
        ab.color();
    }

• 组合模式

//组合模式用来展示树形结构
public class UserTree {
    private String name;
    private List<UserTree> list;
    /*省略get set方法*/
}

• 外观模式

# 通过一个Face提供对外展示
# 降低访问复杂系统的内部子系统时的复杂度，简化客户端与之的接口
# 平时代码对外提供接口或者service也算是外观模式
public class Face {
    CarMax carMax = new CarMax();
    CarSmall carSmall = new CarSmall();

    public void show() {
        carMax.show();
        carSmall.show();
    }
}

• 代理模式

// 分为静态代理和动态代理
// 代理模式可以用于aop
public class MyProxy implements InvocationHandler, Serializable {

   public MyProxy(User target) {
       this.user = target;
   }

   private User user;

   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       System.out.println("------插入前置通知代码-------------");
       //执行相应的目标方法
       Object rs = method.invoke(user,args);
       System.out.println("------插入后置处理代码-------------");
       return rs;
   }
}

• 装饰者模式

//动态地给对象添加一些额外的职责。符合开闭原则对外扩展
//就是弄一个类持有被装饰对象然后与被装饰对象继承统一接口
//然后在实现方法中调用自己的方法去修饰装饰者。
public interface House {
    void show();
}
//被装饰者 
public class HouseInit implements House {
    @Override
    public void show() {
        System.out.println("我是第初始化的房子");
    }
}
//装饰者Abstract 类
public abstract class HouseAbstract implements House {
	//装饰者持有被装饰者对象
    protected House house;
    public HouseAbstract(House house){
        this.house = house;
    }
    public void show(){
        house.show();
    }
}
具体装饰者
public class HouseRed extends HouseAbstract {
    public HouseRed(House house) {
        super(house);
    }
    @Override
    public void show() {
        System.out.println("涂刷红色装饰");
        house.show();
    }
}
  public static void main(String[] args) {
        House house=new HouseInit();
        house=new HouseRed(house);
        house.show();
    }

• 享元模式

// 一个对象多处共享
import java.util.HashMap;
import java.util.Map;

public class UserFactory {
    static Map<String, User> map = new HashMap<>();
    public static Object geUser(String name) {
        User user = map.get(name);
        if (user == null) {
            user = new User(name);
            map.put(name, new User(name));
        }
        return user;
    }
}

行为型模式（11种）

• 责任链模式

// 每个类负责一种类型的处理 本类处理不了的交给下一类 
// 抽象责任链类
public abstract class Handler {
    protected Handler handler;
    public void setHandler(Handler handler){
        this.handler=handler;
    }
    public abstract void execute(int type,String message);
}

// 具体实现类1
public class Handler1 extends Handler {
    public  void execute(int type,String message){
        if(type==1){
            System.out.println("Handler1:"+message);
        }else{
            this.handler.execute(type,message);
        }
    };
}
 //具体实现类2
public class Handler2 extends Handler {
    public  void execute(int type,String message){
        if(type==2){
            System.out.println("Handler2:"+message);
        }else{
            this.handler.execute(type,message);
        }
    };
}
//具体实现类3
public class Handler3 extends Handler {
    public  void execute(int type,String message){
        if(type==3){
            System.out.println("Handler3:"+message);
        }else{
            this.handler.execute(type,message);
        }
    };
}

  public static void main(String[] args) {
        Handler handler1=new Handler1();
        Handler handler2=new Handler2();
        Handler handler3=new Handler3();
        handler2.setHandler(handler3);
        handler1.setHandler(handler2);

        handler1.execute(1,"sss");
        handler1.execute(2,"sss");

    }

• 命令模式

// 一个命令类 一个命令执行者 一个命令调用者
// 抽象命令类
public abstract class Command {
	// 接受命令的执行者
    protected Receiver receiver;
    public void setReceiver(Receiver receiver){
        this.receiver=receiver;
    }
    public abstract void execute();
}

// 具体命令类
public class ConcreteCommand extends Command {
    @Override
    public void execute() {
        this.receiver.execute();
    }
}
// 接受命令去执行的类
public class Receiver {
    String message;
    public Receiver(String message) {
        this.message = message;
    }
    public void execute() {
        System.out.println("执行命令" + message);
    }
}

// 命令的调用者
public class Invoker {

    protected Command command;

    public void setCommand(Command command){
        this.command=command;
    }
    public  void executeCommand(){
        command.execute();
    }
}

    public static void main(String[] args) {
    	//定义执行者
        Receiver receiverDel=new Receiver("命令del");
        //创建命令类
        Command command=new ConcreteCommand();
        //设置命令执行者
        command.setReceiver(receiverDel);
        //创建调用者
        Invoker invoker=new Invoker();
        //调用命令
        invoker.setCommand(command);
        invoker.executeCommand();
    }

• 迭代模式

使用场景：
 1、访问一个聚合对象的内容而无须暴露它的内部表示。
 2、需要为聚合对象提供多种遍历方式。
 3、为遍历不同的聚合结构提供一个统一的接口。

注意事项：迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，
这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据
一个Iterator 接口有hasNext 和 next 方法然后建立个Container接口有getIterator方法。然后再去实现这两个接口就可以了。

public interface Container {
   public Iterator getIterator();
}

public interface Iterator {
   public boolean hasNext();
   public Object next();
}

public class NameRepository implements Container {
    public String names[] = {"张三" , "李四" ,"王五" , "赵六"};

    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator {
        int index;
        @Override
        public boolean hasNext() {
            if(index < names.length){
                return true;
            }
            return false;
        }
        @Override
        public Object next() {
            if(this.hasNext()){
                return names[index++];
            }
            return null;
        }
    }
}

• 观察者模式

// 定义一个观察者类 然后定义一个被观察者类被观察者类中有一个集合保存着观察者
当被观察者发生变化时循环观察者集合通知观察者。
//被观察者接口
public interface SubjectReferee {
    void add(CarObservation c);
    void remove(CarObservation c);
    void notifyExecute();
}
// 被观察者具体实现
public class CarSubjectReferee implements SubjectReferee {
    List<CarObservation> list=new LinkedList<>();
    @Override
    public void add(CarObservation c) {
        list.add(c);
    }
    @Override
    public void remove(CarObservation c) {
        list.remove(c);
    }
    @Override
    public void notifyExecute() {
        list.forEach(x->{
            x.show();
        });
    }
}
/**
 * 定义观察者接口 观察裁判 发号施令
 */
public interface CarObservation {
     void show ();
}

// 定义具体观察者
public class CarSmall implements CarObservation{
    @Override
    public void show() {
        System.out.println("小汽车冲出起跑线");
    }
}
public class CarSmall implements CarObservation{
    @Override
    public void show() {
        System.out.println("小汽车冲出起跑线");
    }
}
 public static void main(String[] args) {
        CarObservation carMax=new CarMax();
        CarObservation carSmall=new CarSmall();

        SubjectReferee csb=new CarSubjectReferee();
        csb.add(carMax);
        csb.add(carSmall);

        csb.notifyExecute();
    }

• 访问者者模式

//访问者模式适合数据结构稳定算法多变的场景。
// 访问者模式符合开闭原则
//被访问者接口 定义一个人类的数据接口 人类数据结构稳定只有男女
public interface Person {
    void accept(ActionAbstract actionAbstract);
}
//访问者的接口。 定义一算法接口有男人和女人
public interface ActionAbstract {
    void getMan(PersonMan person);
    void getWoMan(PersonWoMan person);
}
//数据结构男人
public class PersonMan implements Person {
    @Override
    public void accept(ActionAbstract actionAbstract) {
            actionAbstract.getMan(this);
    }
}
//数据结构女人
public class PersonWoMan implements Person {
    @Override
    public void accept(ActionAbstract actionAbstract) {
        actionAbstract.getWoMan(this);
    }
}
//算法具体实现
public class ActionRun implements ActionAbstract {
    @Override
    public void getMan(PersonMan person) {
        System.out.println("男跑的快");
    }

    @Override
    public void getWoMan(PersonWoMan person) {
        System.out.println("女跑的慢");
    }
}
// 结构对象类
public class ObjectStructrue {
    private List<Person> list=new LinkedList<>();
    public void add(Person p){
        list.add(p);
    }
    public void show(ActionAbstract a){
        list.stream().forEach(x->x.accept(a));
    }
}

  public static void main(String[] args) {
        Person man=new PersonMan();
        Person woMan=new PersonWoMan();
        // 数据结构类
        ObjectStructrue objectStructrue=new ObjectStructrue();
        //添加数据结构
        objectStructrue.add(man);
        objectStructrue.add(woMan);
        ActionAbstract a1=new ActionRun();
        ActionAbstract a2=new ActionEat();
        //运行算法
        objectStructrue.show(a1);
        objectStructrue.show(a2);
   }

• 解释器模式

解释器接口
public interface Expression {
   public String interpret(Context context);
}
解释器具体实现
public class JavaExpression  implements Expression {
    @Override
    public String interpret(Context context) {
        if(context.getMessage().contains("java")){
            return "java";
        }
        return "";
    }
}
public class PhpExpression implements Expression {
    @Override
    public String interpret(Context context) {
        if(context.getMessage().contains("php")){
            return "php";
        }
        return "";
    }
}

//测试
 public static void main(String[] args) {
        Context context=new Context();
        context.setMessage("java");
        List<Expression> list=new LinkedList<>();
        list.add(new JavaExpression());
        list.add(new PhpExpression());
        list.stream().forEach(x->{
            System.out.println( x.interpret(context));
        });
    }     

• 模板模式

// 模板模式提供一个固定的模板并且把共性代码提到模板类里减少代码昂余
// 模板接口
public interface TemplateIntface {
    void openConnection();
    void selectSql(String sql);
    void closeConnection();
    void executeSelectSql(String sql);
}
//abstract实现  (把共性的代码提到这个类)
public abstract class TemplateAbstract implements TemplateIntface {
    public abstract void openConnection();
    public abstract void selectSql(String sql);
    public abstract void closeConnection();
    @Override
    public final void executeSelectSql(String sql) {
        openConnection();
        selectSql(sql);
        closeConnection();
    }
}
// 具体实现
public class TemplateJpa  extends TemplateAbstract{
    @Override
    public void openConnection() {
        System.out.println("jpa 打开连接");
    }

    @Override
    public void selectSql(String sql) {
        System.out.println("jpa 查询sql");
    }

    @Override
    public void closeConnection() {
        System.out.println("jpa 关闭连接");
    }
}

• 策略模式

// 策略接口
public interface StrategyInterface {
    int get(int num1,int num2);
}
// 策略控制器
public class Context {
    private StrategyInterface strategy;
    public Context(StrategyInterface strategy){
        this.strategy = strategy;
    }
    public int executeStrategy(int num1, int num2){
        return strategy.get(num1, num2);
    }
}
// 测试
public class TestMain {
    public static void main(String[] args) {
        Context c=new Context(new StrategyAdd());
        System.out.println(c.executeStrategy(1,2));
    }
}

• 中介者模式

//多个类相互耦合，形成了网状结构。可以使用中介者模式减少耦合度。
// 抽象人类 持有中介者对象
public abstract class Person {
    protected String name;
    protected Mediator mediator;
    public Person(String name,Mediator mediator){
        this.name = name;
        this.mediator = mediator;
    }
}
// 房主
public class HouseOwner extends Person{
    public HouseOwner(String name, Mediator mediator) {
        super(name, mediator);
    }
    public void constact(String message){
        mediator.constact(message, this);
    }
    public void getMessage(String message){
        System.out.println("房主:" + name +",获得信息：" + message);
    }
}

// 购房者
public class Tenant extends Person{
    Tenant(String name, Mediator mediator) {
        super(name, mediator);
    }
    public void constact(String message){
        mediator.constact(message, this);
    }
    public void getMessage(String message){
        System.out.println("租房者:" + name +",获得信息：" + message);
    }
}
// 中介者接口提供一个双方联系的方法
public abstract class Mediator {
    public abstract void constact(String message,Person person);
}
// 中介者具体实现 中介者拥有房主和购房者
public class MediatorStructure extends Mediator{

    private HouseOwner houseOwner;
    private Tenant tenant;

    public HouseOwner getHouseOwner() {
        return houseOwner;
    }

    public void setHouseOwner(HouseOwner houseOwner) {
        this.houseOwner = houseOwner;
    }

    public Tenant getTenant() {
        return tenant;
    }

    public void setTenant(Tenant tenant) {
        this.tenant = tenant;
    }

    public void constact(String message, Person person) {
        if(person == houseOwner){          //房主 发送给购房者信息
            tenant.getMessage(message);
        }
        else{       //购房者 发送给 房主信息
            houseOwner.getMessage(message);
        }
    }
}
// 测试
    public static void main(String[] args) {
        //中介
        MediatorStructure mediator = new MediatorStructure();
        //房主和购房者
        HouseOwner houseOwner = new HouseOwner("房主", mediator);
        Tenant tenant = new Tenant("购房者", mediator);
        //中介注册房主和购房者
        mediator.setHouseOwner(houseOwner);
        mediator.setTenant(tenant);
        tenant.constact("我要买房");
        houseOwner.constact("我要卖房子");
    }

• 状态模式

// 代码中包含大量与对象状态有关的条件语句时使用
// 定义状态接口
public interface State {
   public void doAction(Context context);
}
// 开始状态 运行完并设置为结束
public class StartState implements State {
   public void doAction(Context context) {
      System.out.println("状态:开始");
      context.setState(new StopState());
   }
}
// 结束状态 运行完并设置为开始
public class StopState implements State {
   public void doAction(Context context) {
      System.out.println("状态:结束");
      context.setState(new StopState());
   }
}

//控制类
public class Context {
   private State state;
   public void setState(State state){
      this.state = state;     
   }
   public void execute(){
      state.doAction(this);
   }
}
//测试
public class TestMain {
   public static void main(String[] args) {
      Context context = new Context();
      context.setState(new StartState());
      context.execute();
      context.execute();
   }
}

• 备忘录模式

// 1、需要保存/恢复数据的相关状态场景。 2、提供一个可回滚的操作。
// 备忘录类
public class Memento {
    private String state;
    public Memento(String state) {
        this.state = state;
    }
    public String getState() {
        return state;
    }
}
// 状态保存发起人
public class Originator {
	private String state; 	 //需要保存的数据属性，可以是多个
 
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
	// 创建备忘录
	public Memento CreateMemento(){
		return new Memento(this.state);
	}
	public void SetMemento(Memento memento){
		this.state = memento.getState();
	}
	public void show(){
		System.out.println("state = "+ this.state);
	}
}
// 状态管理者
public class Caretaker {
    private Memento memento;
    public Memento getMemento() {
        return memento;
    }
    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}
// 测试
public static void main(String[] args) {
    // 初始化
    Originator o=new Originator();
    o.setState("开始");
    o.show();
    // 备忘状态
    Caretaker c=new Caretaker();
    c.setMemento(o.CreateMemento());
    // 设置状态为结束
    o.setState("结束");
    o.show();
    // 恢复状态
    o.SetMemento(c.getMemento());
    o.show();
}