java23种设计模式学习

1、策略模式

理解：就是通过传不同的参数，调用不同的对象

策略模式适用场景在以下情况下可以使用策略模式：

如果在一个系统里面有许多类，它们之间的区别仅在于它们 的行为，那么使用策略模式可以动态地让一个对象在许多行 为中选择一种行为。
一个系统需要动态地在几种算法中选择一种。
如果一个对象有很多的行为，如果不用恰当的模式，这些行 为就只好使用多重的条件选择语句来实现。
不希望客户端知道复杂的、与算法相关的数据结构，在具体 策略类中封装算法和相关的数据结构，提高算法的保密性与 安全性。
在我们生活中比较常见的应用模式有：

1、电商网站支付方式，一般分为银联、微信、支付宝，可以采用策略模式
2、电商网站活动方式，一般分为满减送、限时折扣、包邮活动，拼团等可以采用策略模式

代码实操

public interface IStrategy {
    void operate();
}

public class BackDoor implements IStrategy {
    public void operate() {
        System.out.println("找乔国老帮忙，让吴国太给孙权施加压力");
    }
}

public class GivenGreenLight implements IStrategy {
    public void operate() {
        System.out.println("求吴国太开个绿灯,放行！");
    }
}

public class Context {
    private IStrategy iStrategy;

    public Context(IStrategy iStrategy) {
        this.iStrategy = iStrategy;
    }
    public void operate(){
        this.iStrategy.operate();
    }
}


public class Zhaoyun {
    public static void main(String[] args) {
        Context context=new Context(new BackDoor());
        context.operate();
    }
}

2、代理模式

理解：就是代理类的构造方法设置成接口类型

代码演示：

public interface KindWomen {
    //这种类型的女人能做什么事情呢？
    public void makeEyesWithMan(); //抛媚眼


    public void happyWithMan(); //happy what? You know that!
}


public class PanJinLian implements KindWomen {
    public void happyWithMan() {
        System.out.println("潘金莲在和男人做那个.....");
    }

    public void makeEyesWithMan() {
        System.out.println("潘金莲抛媚眼");
    }
}


public class ProxyClass {
    private KindWomen kindWomen;

    public ProxyClass(KindWomen kindWomen) {
        this.kindWomen = kindWomen;
    }
    public ProxyClass() {
        this.kindWomen = new PanJinLian();
    }
    public void happyWithMan() {
        this.kindWomen.happyWithMan(); //自己老了，干不了，可以让年轻的代替
    }
    public void makeEyesWithMan() {
        this.kindWomen.makeEyesWithMan(); //王婆这么大年龄了，谁看她抛媚眼？！
    }
}


public class Ximenqing {
    public static void main(String[] args) {
        ProxyClass proxyClass=new ProxyClass();
        proxyClass.happyWithMan();

    }
}

3、单例模式

理解：私有化构造方法、提供一个对外的方法来创建对象

代码实现：

public class SingletonPattern {
    private static final SingletonPattern single=new SingletonPattern();

    private SingletonPattern() {
    }
    public synchronized static SingletonPattern getInstance(){
        return single;
    }
}

 4、工厂方法模式

理解：通过反射传递路径的方式产生对象

代码实现：

public interface Human {
//首先定义什么是人类

    //人是愉快的，会笑的，本来是想用smile表示，想了一下laugh更合适，好长时间没有大笑了；
    public void laugh();

    //人类还会哭，代表痛苦
    public void cry();

    //人类会说话
    public void talk();

}


public class YellowHuman implements Human {

    public void cry() {
        System.out.println("黄色人类会哭");
    }

    public void laugh() {
        System.out.println("黄色人类会大笑，幸福呀！");
    }

    public void talk() {
        System.out.println("黄色人类会说话，一般说的都是双字节");

    }
}


public class HumanFactory {
    public static Human createHuman(Class c) {
        Object o;
        try {
            o = Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        return (Human) o;

    }
}

public class NvWa {
    public static void main(String[] args) {
        Human human = HumanFactory.createHuman(new YellowHuman().getClass());
        human.laugh();
       
    }
}

5、原型模式

理解：就是对象的copy

代码实现：

@Data
public class Mail implements Cloneable {
    private String name;
    private Integer age;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Mail mail=null;
       return mail= (Mail) super.clone();
    }

    public static void main(String[] args) {
        Mail mail=new Mail();
        mail.setName("张三");
        for(int i=0;i<=5;i++){

            try {
                Mail clone = (Mail) mail.clone();
                clone.setAge(i);
                System.out.println(clone);
            } catch (CloneNotSupportedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

 

 6、观察者模式

理解：就是发布和订阅的思想，数据改变了，通知所有的监听者

代码逻辑实现

public interface Subject {
//添加观者者
    void addObserver(Observers observer);
//删除观者者
    void removeObserver(Observers observer);
//通知所有观察者
    void notifyObserver();
}


public class SubjectImpl implements Subject{
    List<Observers> observers=new ArrayList<>();
    @Override
    public void addObserver(Observers observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observers observer) {
        observers.remove(observer);

    }

    @Override
    public void notifyObserver() {
        observers.stream().forEach(obj->{
            obj.update("内容更新了");
        });

    }

    public static void main(String[] args) {
        SubjectImpl subject=new SubjectImpl();
   subject.addObserver(new ObserversImpl());
        subject.notifyObserver();
    }
}

public interface Observers {
    void update(String context);
}


public class ObserversImpl implements Observers{
    @Override
    public void update(String context) {
        System.out.println(context);
    }
}

 7、模板方法模式

理解：抽象类定义方法，子类去实现

public abstract class TemplateObject {
    protected abstract void say();
    protected abstract void write();
}


public class TemplateObjectImpl extends TemplateObject{
    @Override
    protected void say() {
        System.out.println("说");
    }

    @Override
    protected void write() {
        System.out.println("写");

    }

    public static void main(String[] args) {
        TemplateObjectImpl templateObject=new TemplateObjectImpl();
        templateObject.say();
    }
}

 8、责任链模式

理解：每个节点都可以看做一个对象，节点包含下一个节点对象，如果出现异常，链路就会中断

应用场景：springmvc、filter和拦截器、mybatis

代码实现：

//定义节点对象抽象实体类，判断使用
@Data
@AllArgsConstructor
public class ApproseRequest {
    private int type=0;
    private float price=0.2f;
    private int id=0;
}

//节点对象，通过抽象方法，子类实现具体的业务逻辑，模板方法模式体现
@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class Approver {
    Approver next;
    String name;

    public Approver(String name) {
        this.name=name;
    }

    public abstract void processApprover(ApproseRequest approver);
}


public class DepartmentApprover extends Approver {
    public DepartmentApprover(String name) {
        super(name);
    }

    @Override
    public void processApprover(ApproseRequest approver) {
        if (approver.getPrice() <= 5000) {
            System.out.println(approver.getId());
        } else {
            this.processApprover(approver);
        }
    }

    public static void main(String[] args) {
        DepartmentApprover departmentApprover=new DepartmentApprover("张三");
        departmentApprover.setNext(departmentApprover);
        departmentApprover.processApprover(new ApproseRequest(1,2.3f,3));
    }
}

 9、建造者模式

理解：

指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

lombok的@bulider注解底层就是建造者模式实现的

package com.liubaihui.lianxi01.controller;

public class TestBean {
    private Integer a;
    private Integer b;

    TestBean(final Integer a, final Integer b) {
        this.a = a;
        this.b = b;
    }

    public static TestBeanBuilder builder() {
        return new TestBeanBuilder();
    }

    public static class TestBeanBuilder {
        private Integer a;
        private Integer b;

        TestBeanBuilder() {
        }

        public TestBeanBuilder a(final Integer a) {
            this.a = a;
            return this;
        }

        public TestBeanBuilder b(final Integer b) {
            this.b = b;
            return this;
        }

        public TestBean build() {
            return new TestBean(this.a, this.b);
        }

        public String toString() {
            return "TestBean.TestBeanBuilder(a=" + this.a + ", b=" + this.b + ")";
        }
    }
}

 10、门面模式

理解：就是对复杂逻辑的封装成一个对外暴露的方法

public interface Human {
    public void say();
    public void eat();
}


public class HumanImpl implements Human{
    @Override
    public void say() {
        System.out.println("说");
    }

    @Override
    public void eat() {
        System.out.println("吃");
    }
}


public class FaceModel {
    public void test(){
        faceModelMethod();
    }

    /**
     * 门面方法
     */
    public void faceModelMethod(){
        HumanImpl human=new HumanImpl();
        human.say();
        human.eat();
    }

}

 

 11、享元模式

理解：共享对象的创建

 12、装饰者模式

理解：扩展类对象的功能，不改变原有功能

 13、迭代器模式

理解：遍历集合，通过接口定义一个迭代器，有hasnext方法和next方法，集合内部实现这个迭代器。

14、访问者模式

理解：结构固定的类，提供一个方法