设计模式学习

最新推荐文章于 2021-03-04 16:10:04 发布
最新推荐文章于 2021-03-04 16:10:04 发布
阅读量113 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39175589/article/details/107584333
版权

构造行设计模式

策略模式

使用场景

一种算法不同的解决方案

非Lambda 实现
  • 定义策略接口
  • 定义多个类实现策略接口
java8 Lambda表达式实现策略模式
  • 定义行为类，类中有策略的引用。
  • 使用Lambda表达式不需要实现接口，只需要把策略的具体实现使用Lambda表达式传进执行的类中即可
public interface Strategy {
    boolean execute(String s);
}

public class Action{
    private Strategy strategy;

    public Action(Strategy strategy) {
        this.strategy = strategy;
    }

    public boolean execute(String s) {
        return strategy.execute(s);
    }
}

   public class Main {
    public static void main(String[] args) {
        Action valiator = new Action(s -> s.matches("[a-z]+"));

        boolean match = valiator.execute("aaa");
        System.out.println(match);

        Action valiator1 = new Action (s -> s.matches("[0-9]+"));

        boolean match1 = valiator1.execute("111");

        System.out.println(match1);
    }
}

模板方法

使用场景

某个算法的部分子流程希望可以自由的修改

非Lambda 实现
public abstract class Template {

    public void compute() {
        method1();
        method2();
    }

    private void method1() {
        System.out.println("do method1");
    }

    protected abstract void method2();
}

public class TemplateImpl1 extends Template {
    @Override
    public void method2() {
        System.out.println("TemplateImpl1 do method2");
    }
}


public class TemplateImpl2 extends Template {

    @Override
    protected void method2() {
        System.out.println("TemplateImpl2 do method2");
    }
}

public class Main {
    public static void main(String[] args) {
        Template template1 = new TemplateImpl1();
        template1.compute();

        Template template2 = new TemplateImpl2();
        template2.compute();

    }
}

do method1
TemplateImpl1 do method2
do method1
TemplateImpl2 do method2
使用Lambda表达式实现模板方法
public class Template {

    public void compute(Consumer<Object> method2, Object o) {
        method1();

        method2.accept(o);
    }

    private void method1() {
        System.out.println("do method1");
    }

}

public class Main {
    public static void main(String[] args) {
        Template template1 = new Template();
        template1.compute(o -> {
            System.out.println(o);
        }, "templateimpl1 do method2");

        Template template2 = new Template();
        template1.compute(o -> {
            System.out.println(o);
        }, "templateimpl2 do method2");

    }
}
do method1
templateimpl1 do method2
do method1
templateimpl2 do method2

接口型设计模式

适配器模式

类适配器

当客户端接口表达其需求时，可以创建一个实现该接口的新类，同时该类继承自现有类。如下代码适配器类OozinozRocket 实现接口Rocket并继承PhysicalRocket。适配器类将客户端的调用转换为对现有类PhysicalRocket的调用。

public interface RocketSim {
    double getMass();

    double getTrust();

    void setSimTime(double d);

}
public class PhysicalRocket {

    public PhysicalRocket(double burnArea, double burnTime, double fuelMass, double totalMass) {
        this.burnArea = burnArea;
        this.burnTime = burnTime;
        this.fuelMass = fuelMass;
        this.totalMass = totalMass;
    }

    private double burnArea;

    private double burnTime;

    private double fuelMass;

    private double totalMass;

    public double getMass() {
        return this.totalMass;
    }

    public double getTrust() {
        return fuelMass;
    }

    public double getBurnTime() {
        return burnTime;
    }

}

//适配器类
public class OozinozRocket extends PhysicalRocket implements RocketSim {

    private double simTime;

    public OozinozRocket(double burnArea, double burnTime, double fuelMass, double totalMass) {
        super(burnArea, burnTime, fuelMass, totalMass);
    }

    @Override
    public void setSimTime(double d) {
        this.simTime = d;
    }
}
对象适配器

当客户端没有指定接口时，可以创建一个新的客户端子类，它将使用现有类的示例。将客户端的调用委托给现有类的实例。OozinozRocket 是一个SkySocket 对象，但是他的实现将调用委托给OozinozRocket 。

public class SkySocket {

    private double mass;

    private double trust;

    protected double simTime;

    public double getMass() {
        return this.mass;
    }

    public double getTrust() {
        return trust;
    }

    public void setSimTime(double d) {
        this.simTime = d;
    }
}
public class PhysicalRocket {

    public PhysicalRocket(double burnArea, double burnTime, double fuelMass, double totalMass) {
        this.burnArea = burnArea;
        this.burnTime = burnTime;
        this.fuelMass = fuelMass;
        this.totalMass = totalMass;
    }

    private double burnArea;

    private double burnTime;

    private double fuelMass;

    private double totalMass;

    public double getMass() {
        return this.totalMass;
    }

    public double getTrust() {
        return fuelMass;
    }

    public double getBurnTime() {
        return burnTime;
    }


}

public class OozinozRocket extends SkySocket {

    private PhysicalRocket physicalRocket;

    public OozinozRocket(PhysicalRocket physicalRocket) {
        this.physicalRocket = physicalRocket;
    }

    public double getTrust() {
        return physicalRocket.getTrust();
    }

    public double getMass() {
        return physicalRocket.getMass();
    }

    public void setSimTime(double d) {
        this.simTime = d;
    }
}

合成（composite）模式

设计合成类可以用于维护合成对象的集合，合成对象既可以支持叶子对象，又支持组合对象。组合对象与单个对象共享同一个接口

public interface Component {
    int operate();

    boolean isTree(Set<Component> visited);
}
public class Leaf implements Component {

    @Override
    public int operate() {
        return 1;
    }

    @Override
    public boolean isTree(Set<Component> visited) {
        visited.add(this);
        return false;
    }

}
public class Composite implements Component {

    private List<Component> component;

    {
        component = new ArrayList<>();
    

    public void add(Component component) {
        this.component.add(component);
    }

    @Override
    public int operate() {

        return component.stream().map(e -> {
            return e.operate();
        }).reduce(0, (a, b) -> a + b);
    }

    @Override
    public boolean isTree(Set<Component> visited) {
        visited.add(this);
        return component.stream().filter(e -> visited.contains(e) || !e.isTree(visited)).findAny().isPresent();
    }

}

public class Main {
    public static void main(String[] args) {
        Composite composite1 = new Composite();
        composite1.add(new Leaf());
        composite1.add(new Leaf());
        Composite composite2 = new Composite();
        composite2.add(new Leaf());
        composite2.add(new Leaf());
        composite1.add(composite2);
        int sum = composite1.operate();
        boolean isTree = composite1.isTree(new HashSet<>());
        System.out.println(sum + "" + isTree);

    }
}

桥接（bridge）模式

桥接模式关注抽象的设计，抽象是指包含了一组抽象方法的类，这些抽象方法可能包含多个实现。
如果想将最初的类层次结构分解为另一种层次结构，既可以使用桥接模式将 抽象方法转移到另一个类层次结构中。
如下代码接口MachineDriver及其实现类为一个类结构。现想再定义出一个类结构对MachineDriver进行管理，MachineManger及其子类 就是新的类结构，他们实现了与MachineDriver类结构的分离。

public interface MachineDriver {
    void startMachine();

    void stopMachine();

    void startProcess();

    void stopProcess();

    void conveyIn();

    void conveyOut();
}
public class FuserDriver implements MachineDriver {
    @Override
    public void startMachine() {
         System.out.println("start machine fuserDriver");
    }

    @Override
    public void stopMachine() {
        System.out.println("stop machine fuserDriver");
    }

    @Override
    public void startProcess() {
        System.out.println("start process fuserDriver");
    }

    @Override
    public void stopProcess() {
        System.out.println("stop process fuserDriver");
    }

    @Override
    public void conveyIn() {
        System.out.println("conveyIn fuserDriver");
    }

    @Override
    public void conveyOut() {
        System.out.println("conveyOut fuserDriver");
    }
}
public class StarPressDriver implements MachineDriver {
    @Override
    public void startMachine() {
        System.out.println("start machine StarPressDriver");
    }

    @Override
    public void stopMachine() {
        System.out.println("stop machine StarPressDriver");
    }

    @Override
    public void startProcess() {
        System.out.println("start process StarPressDriver");
    }

    @Override
    public void stopProcess() {
        System.out.println("stop process StarPressDriver");
    }

    @Override
    public void conveyIn() {
        System.out.println("conveyIn StarPressDriver");
    }

    @Override
    public void conveyOut() {
        System.out.println("conveyOut StarPressDriver");
    }
}

public abstract class MachineManger {

    protected MachineDriver machineDriver;


    protected double timeOut;

    public MachineManger(MachineDriver machineDriver) {
        this.machineDriver = machineDriver;
    }

    protected abstract void shutdown();

    protected abstract void start();

    protected abstract void setTimeOut(double timeOut);
}
public class HskMachineManger extends MachineManger {

    public HskMachineManger(MachineDriver machineDriver) {
        super(machineDriver);
    }

    @Override
    protected void shutdown() {
        this.machineDriver.stopProcess();
        this.machineDriver.stopMachine();
    }

    @Override
    protected void start() {
        this.machineDriver.startProcess();
        this.machineDriver.startMachine();
    }

    @Override
    protected void setTimeOut(double timeOut) {
        this.timeOut = timeOut;
    }
}
public class Main {
    public static void main(String[] args) {
        MachineDriver fuserDriver = new FuserDriver();
        MachineManger machineManger = new HskMachineManger(fuserDriver);
        machineManger.start();
        machineManger.shutdown();
        machineManger.setTimeOut(100);
    }
}

职责型设计模式

观察者模式

使用场景

某些事件发生时（比如状态转变），如果一个对象（通 常我们称之为主题）需要自动地通知其他多个对象（称为观察者），就会采用该方案

非Lambda 实现
public interface Observer {
    void notify(String tweet);
}

public interface Subject {
    void registerObserver(Observer o);
    void notifyObservers(String tweet);
}
public class Observer1 implements Observer {
    @Override
    public void notify(String tweet) {
        System.out.println(tweet + "1");
    }
}
public class Observer2 implements Observer {
    @Override
    public void notify(String tweet) {
        System.out.println(tweet + "2");
    }
}

public class SubjectImpl implements Subject {

    private List<Observer> observerList = new ArrayList<>();

    @Override
    public void registerObserver(Observer o) {
        observerList.add(o);
    }

    @Override
    public void notifyObservers(String tweet) {
        observerList.stream().forEach(e -> {
            e.notify(tweet);
        });
    }
}

public class Main {
    public static void main(String[] args) {
        Subject f = new SubjectImpl();
        f.registerObserver(new Observer1());
        f.registerObserver(new Observer2());
        f.notifyObservers("notify observer");
    }
}
notify observer1
notify observer2
java8 使用Lambda表达式实现观察者模式
public class Observer1 implements Observer {

    private Consumer<Object> consumer;

    public Observer1(Consumer<Object> consumer) {
        this.consumer = consumer;
    }

    @Override
    public void notify(Object tweet) {
        consumer.accept(tweet);
    }
}
public class Observer2 implements Observer {
    private Consumer<Object> consumer;

    public Observer2(Consumer<Object> consumer) {
        this.consumer = consumer;
    }

    @Override
    public void notify(Object tweet) {
        consumer.accept(tweet);
    }
}

    public static void main(String[] args) {
        Subject f = new SubjectImpl();
        f.registerObserver(new Observer1(e -> {
            System.out.println(e + "1");
        }));
        f.registerObserver(new Observer2(e -> {
            System.out.println(e + "2");
        }));
        f.notifyObservers("notify observer");
    }
}

责任链模式

使用场景

责任链模式是一种创建处理对象序列（比如操作序列）的通用方案。一个处理对象可能需要 在完成一些工作之后，将结果传递给另一个对象，这个对象接着做一些工作，再转交给下一个处 理对象，以此类推。

非Lambda 实现
public abstract class ProcessingObject<T> {

    private ProcessingObject<T> successor;

    public void setSuccessor(ProcessingObject<T> successor) {
        this.successor = successor;
    }

    public T handle(T t) {
        T t1 = handleWork(t);
        if (successor != null) {
            return successor.handle(t1);
        }
        return t1;
    }

    protected abstract T handleWork(T t);
}


public class ProcessingChain1 extends ProcessingObject<String> {
    @Override
    protected String handleWork(String text) {
        return "hello, " + text;
    }
}

public class ProcessingChain2 extends ProcessingObject<String> {
    @Override
    protected String handleWork(String text) {
         return  text.replace("chai","chain");
    }
}

public class Main {
    public static void main(String[] args) {
        ProcessingObject<String> processingObject1 = new ProcessingChain1();
        ProcessingObject<String> processingObject2 = new ProcessingChain2();
        processingObject1.setSuccessor(processingObject2);
        String res = processingObject1.handle("I am chai of responsibility pattern !");
        System.out.println(res);
    }
}
hello, I am chain of responsibility pattern !
java8 Lambda实现责任链
public class Main {
    public static void main(String[] args) {

        UnaryOperator<String> processingObject1 = (String text) ->text ;

        UnaryOperator<String> processingObject2 = (String text) -> text.replace("chai", "chain");

        Function<String, String> pipeline = processingObject1.andThen(processingObject2);

        String res = pipeline.apply("Hello,I am chai  of reponsibility pattern !");
        System.out.println(res);
    }
    Hello,I am chain  of reponsibility pattern !
}

工厂模式

使用场景

使用工厂模式，不同条件下创建不同实例时，你无需向客户暴露实例化的逻辑就能完成对象的创建。

java8 之前实现方法
public interface Product {
    void product();
}
public class Product1 implements Product {
    @Override
    public void product() {
        System.out.println("I am product1");
    }
}
public class Product2 implements Product {
    @Override
    public void product() {
        System.out.println("I am product2");
    }
}
public class ProductFactory {
    public static Product createProduct(String name) {
        switch (name) {
            case "product1":
                return new Product1();
            case "product2":
                return new Product2();
            default:
                throw new RuntimeException("no such product");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Product product1 = ProductFactory.createProduct("product1");
        product1.product();
        Product product2 = ProductFactory.createProduct("product2");
        product2.product();
    }
}
I am product1
I am product2
Java8 新特性实现
public class ProductFactory {
    private static Map<String, Supplier<Product>> factory = null;

    static {
        factory.put("product1", Product1::new);
        factory.put("product2", Product2::new);
    }

    public static Product createProduct(String name) {
        Supplier<Product> productSupplier = factory.get(name);
        if (productSupplier != null) {
            return productSupplier.get();
        }
        throw new RuntimeException("no such product ");
    }
}

享元（flyweight）模式

public interface Chemical {
     String getName();

     String getSymbol();

}
public class ChemicalFactory {

    private static Map<String, Chemical> chemicalMap = new HashMap<>();

    static {
        ChemicalFactory factory = new ChemicalFactory();
        chemicalMap.put("Carbon", factory.new ChemicalImpl("Carbon", "C"));

    }

     class ChemicalImpl implements Chemical {
        private String name;
        private String symbol;

         ChemicalImpl(String name, String symbol) {
            this.name = name;
            this.symbol = symbol;
        }

        public String getName() {
            return name;
        }

        public String getSymbol() {
            return symbol;
        }
    }


    public static Chemical getChemical(String name) {
        return chemicalMap.get(name);
    }
}

public class Main {

    public static void main(String[] args) {
        Chemical chemical = ChemicalFactory.getChemical("Carbon");
        System.out.println(chemical.getName());
    }
}

构建者模式（builder）

构建者模式将复杂对象的构建逻辑从对象本身抽离出来，这样可以简化复杂的对象。构建者关注目标类的构建过程，目标类关注合法的实例业务本身。

Zane.J
关注
专栏目录
设计模式学习之策略模式
一个码农的博客
04-11 7万+
写代码时总会出很多的if…else，或者case。如果在一个条件语句中又包含了多个条件语句就会使得代码变得臃肿，维护的成本也会加大，而策略模式就能较好的解决这个问题，本篇博客就带你详细了解策略模式。策略模式的定义和使用场景定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化。分析下定义，策略模式定义和封装了一系列的算法，它们是可以相互替
设计模式学习之访问者模式
热门推荐
一个码农的博客
04-23 3万+
访问者模式，是行为型设计模式之一。访问者模式是一种将数据操作与数据结构分离的设计模式，它可以算是 23 中设计模式中最复杂的一个，但它的使用频率并不是很高，大多数情况下，你并不需要使用访问者模式，但是当你一旦需要使用它时，那你就是需要使用它了。 访问者模式的基本想法是，软件系统中拥有一个由许多对象构成的、比较稳定的对象结构，这些对象的类都拥有一个 accept 方法用来接受访问者对象的访问。访问者是
Java设计模式学习总结
Java技术江湖
07-08 5704
设计模式 创建型模式 创建型模式 创建型模式的作用就是创建对象，说到创建一个对象，最熟悉的就是 new 一个对象，然后 set 相关属性。但是，在很多场景下，我们需要给客户端提供更加友好的创建对象的方式，尤其是那种我们定义了类，但是需要提供给其他开发者用的时候。 单例 单例模式保证全局的单例类只有一个实例，这样的话使用的时候直接获取即可，比如数据库的一个连接，Spring里的be...
【Java设计模式】设计模式学习引导
明月沉江春雾晓
10-06 1722
其实关于UML、7种软件设计原则和23种设计模式相关的文章，我之前都已经写过了，但是因为创作仓促，质量没有达到我的预期，都被我设置成了私密，接下来的日子里，打算再依次打磨打磨，发表出来。 截止目前，唯一放出来的只有 【Java设计模式】软件设计七大原则，阅读量两万多，看来大家都热衷于将代码写得更加优质，有水平呀~ 这篇文章主要起到小地图的作用，不涉及具体的设计模式的探讨以及设计模式的发展历程。 ...
设计模式学习汇总
大鱼的博客
03-04 1万+
设计模式学习汇总 设计模式——工厂模式 持续更新！！！！！ 写作不易，如果您觉得写的不错，欢迎给博主点赞、收藏、评论、收藏来一波~让博主更有动力吧！ 路漫漫其修远兮，吾必将上下求索~ ...
设计模式学习心得
01-11 2675
最近看了点设计模式，以前就听说各种设计模式看了以后会觉得他们非常像，别说还真是，看到现在也是感觉脑子一团浆糊，真是觉得各种模式很像，比如说适配器模式和代理模式，都是持有目标对象然后去调用他们的方法，中间的区别就在于，适配器模式和目标对象不用实现同一个接口，而代理模式和被代理对象是需要实现同一个接口，不仅感慨设计模式这个东西还真是一个细致的东西，学习了一阵之后最大的一个感悟就是，设计模式最终的目的就
swift设计模式学习 - 原型模式
W_C__L的博客
02-20 2756
移动端访问不佳，请访问我的个人博客 设计模式学习的demo地址，欢迎大家学习交流 原型模式用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。定义用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。Prototype原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给
Java设计模式学习
Java笔记虾
08-08 1570
设计模式是什么鬼（初探） 设计模式是什么鬼（单例） 设计模式是什么鬼（原型） 设计模式是什么鬼（策略） 设计模式是什么鬼（状态）   未完待续................
设计模式学习书籍推荐（设计模式书籍你读过哪几本）
qq_36075612的博客
07-17 1万+
概述 想成为大神级别的攻城狮，就读以下这些书籍吧！让你从小白到大佬，写出有灵魂程序。让你成为大神中的大神。 一、C C现代编程 集成开发环境 设计模式 极限编程 测试驱动开发 重构 C Qt设计模式电子工业出版社9787121168901[美]艾朱斯特 C嵌入式设计模式 二、C++ 道法自然-面向对象实践指南 设计模式：可复用面向对象软件的基础（典藏版） 三、C# C#设计模式（第2版） .NET与设计模式 深入浅出设计模式(C#/Java版) 四...
设计模式学习笔记—简单工厂模式
_ZeroKing的博客
03-01 2204
1.简单工厂模式 1.1 介绍 简单工厂模式属于创建型设计模式，由一个工厂对象的静态方法决定创建出哪一个具体实例。 1.2 优缺点 1.2.1 优点 工厂类负责处理根据不同条件创建具体实例，实例消费类不再需要通过复杂的逻辑创建实例，只需要给工厂类必要的判断条件。明确了各个类的职责，将实例和实例消费类完全解耦。 1.2.2 缺点 所有实例的创建逻辑全部集中在工厂类中，违反了高内聚责任分配原则。当实例...
设计模式学习资料设计模式学习资料
07-09
设计模式学习资料设计模式学习资料
基于《大话设计模式》的Java设计模式学习源码实战
10-04
该项目是一个基于《大话设计模式》的Java设计模式学习源码实战，包含41个文件，其中36个为Java源文件，4个为Markdown文档，以及1个LICENSE文件。通过实际编码实践，帮助开发者深入理解并掌握设计模式的应用。
设计模式学习资料
03-01
Java设计模式，解说通俗易懂，推荐新手学习使用，文档中包含类图
C++20设计模式学习笔记-第7章桥接模式学习代码
02-06
C++20设计模式学习笔记-第7章桥接模式学习代码
基于龙伯格（Luenberger）观测器的无感FOC电机矢量控制MATLAB Simulink仿真模型
10-06
基于龙伯格（Luenberger）观测器的无感FOC电机矢量控制MATLAB Simulink仿真模型 通过龙伯格观测器，我们可以在不直接测量转子角度的情况下，通过已知的电机电流、电压来估算转子角度。这种方法在控制理论和实际电机控制中具有广泛的应用，尤其是在无传感器的情况下。
web端实现《别踩白块》小游戏
10-06
通过JS实现web的《别踩白块》小游戏
python经典实例代码汇总+100例
最新发布
10-06
python经典实例代码汇总+100例
阵列天线泰勒综合法降低副瓣电平的matlab源代码
10-06
clear clc % 参数设置 Freq =30*(1e9); %频率 v_0=3*10^8;%光速 lamda = v_0/Freq ; % 波长 d = lamda * 0.6; % d为阵元间距 theta0 = (90/180)*pi; % 扫描角度 theta = 0: 0.01 : pi; % Θ为方向角 u = pi*d*(cos(theta)-cos(theta0))/lamda; %T = Chebyshev; % T为切比雪夫恒等式系数矩阵 N = 16; % N为直线阵的阵元数量，M为一侧的单元数(对称) R0dB = 20; % R0dB为副瓣电平 nbar=9; %相等电平副瓣数目 if (mod(N,2)==0) M = N / 2; parity = 0; % parity为奇偶性，0为偶数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值