设计模式练习 java

一、创建型模式

1、单例模式

说明：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例

package com.example.design.singleton;

/**
 * TODO 类描述
 *
 * @author WKQ
 * @date 2023/6/21
 */
public class Earth {
    private Earth(){}
    private void earthWay(){
        System.out.println("地球只有一个，我们只能住在地球上");
    }
    private final static Earth earth = new Earth();
    public static Earth getSingletonDemo(){
        return earth;
    }
}

2、简单工厂模式

说明:通过参数构建对象

package com.example.design.factory;

import javafx.scene.chart.PieChart;
import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * TODO 类描述
 *
 *  饮料工厂
 * @author WKQ
 * @date 2023/10/14
 */
public class DrinkFac {
    static Drink create(String type){
        switch (type){
            case "牛奶":
                return  new Milk("牛奶");
            case "奶茶":
                return  new Naicha ("奶茶");
            default:
                return new Drink();
        }

    }
}
class Drink{
}

@Data
@AllArgsConstructor
class Naicha extends Drink {
    private String name;
}
@Data
@AllArgsConstructor
class Milk extends Drink {
    private String name;
}

3、抽象工厂模式

4、建造者模式

说明:有些类的可能有几十个属性，我们通过构造方法传参来构建对象时，你需要保证几十个参数的顺序、类型与构造方法一致，因此容易出错，所有使用建造者模式构建，通过链式调用构建对象

以下两个注解都可开启链式调用，实现建造者模式

@Builder

@Acessors(chain = true)

package com.example.design.build;

import lombok.ToString;

/**
 * TODO 类描述 建造者模式实现链式调用
 *
 * @author WKQ
 * @date 2023/10/13
 */
@ToString
public class Dog {
    private String name;
    private int age;

    public static class Builder2{
        private String name;
        private int age;
        public Builder2 setName(String name){
            this.name = name;
            return this;
        }
        public Builder2 setAge(int age){
            this.age = age;
            return this;
        }
        public Dog build(){
            Dog dog = new Dog();
            dog.age = this.age;
            dog.name = this.name;
            return dog;
        }

    }

    static Builder2 create(){
        return new Builder2();
    }

    public static void main(String[] args) {
        Dog dog = Dog.create().setAge(2).setName("旺财").build();
        System.out.println(dog.toString());
    }
}

5、原型模式

没啥好写就实例深克隆

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

/**
 * TODO 类描述 原型模式
 * 
 * @author WKQ
 * @date 2023/10/25
 */
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("小黑", 2);
        Dog clone = dog.clone();
        // 比较内存地址
        System.out.println(dog == clone);
        // 比较对象内容
        System.out.println(dog.equals(clone));
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
class Dog implements  Prototype{
    private String name;
    private Integer age;

    @Override
    public Dog clone() {
        return new Dog().setAge(this.age).setName(this.name);
    }
}
interface Prototype{
    /**
     * 克隆方法
     * @return Prototype
     */
    Prototype clone();
}

二、行为型模式

1、模板模式

定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤

我们都知道炒菜都是有一套固定流程的，我这里简单分成三个流程，倒油、倒菜、炒菜

模板类

package com.example.design.template;

/**
 * TODO 类描述
 *  炒菜模板
 *  1、定义了一个算法的骨架，将一些步骤延迟到子类中实现。
 *  2、子类可以重写父类中的方法，从而改变算法的行为。
 *  3、父类控制算法的流程，子类实现具体的步骤。
 *  4、可以通过模板方法来封装不变部分，提高代码复用性。
 * @author WKQ
 * @date 2023/10/11
 */
public abstract class ChaocaiTemplate {
    /**
     * 倒菜方法，每次做饭可能炒的菜不一样
     */
    public abstract void pourVegetable();
    public void pourOil() {System.out.println("倒油");}
    public void fry(){System.out.println("炒啊炒");}

    /**
     * 炒菜模板流程
     */
    public final void cookProcess(){
        this.pourOil();
        this.pourVegetable();
        this.fry();
    }


}

炒包菜实现类

package com.example.design.template;

/**
 * TODO 类描述
 *
 * @author WKQ
 * @date 2023/10/11
 */
public class Baocai extends ChaocaiTemplate {
    @Override
    public void pourVegetable() {
        System.out.println("倒入包菜");
    }

    @Override
    public void pourOil(){
        System.out.println("抄包菜当然要用猪油抄啦");
        System.out.println("倒猪油");
    }
}

炒青菜实现类

package com.example.design.template;

/**
 * TODO 类描述
 *
 * @author WKQ
 * @date 2023/10/11
 */
public class Qingcai extends ChaocaiTemplate {
    @Override
    public void pourVegetable() {
        System.out.println("倒入青菜");
    }
}

准备运行环境测试

package com.example.design.template;

/**
 * TODO 类描述
 *
 * @author WKQ
 * @date 2023/10/11
 */
public class TemplateTest {
    public static void main(String[] args){
        Baocai baocai = new Baocai();
        Qingcai qingcai = new Qingcai();
        baocai.cookProcess();
        qingcai.cookProcess();
    }
}

2、策略模式

说明：定义一系列算法，将每个算法封装起来，使它们可以替换（同一个功能的不同实现）

我们每天都会回家，但是选择什么策略回家呢，步行、骑车、开车

定义策略接口

package com.example.design.strategy;

/**
 * TODO 类描述
 *  导航策略接口
 * @author WKQ
 * @date 2023/10/11
 */
public interface Navigation {
    void plan();
}

策略接口的各种实现类

package com.example.design.strategy;

/**
 * TODO 类描述
 *  骑车导航方案
 *
 * @author WKQ
 * @date 2023/10/11
 */
public class BikeStrategy implements Navigation {

    @Override
    public void plan() {
        System.out.println("靓仔选择骑车回家");
    }
}

/**
 * TODO 类描述
 *  步行方案
 * @author WKQ
 * @date 2023/10/11
 */
class WalkStrategy implements Navigation{
    @Override
    public void plan() {
        System.out.println("扑街选择步行回家");
    }
}

/**
 * TODO 类描述
 *  开车方案
 * @author WKQ
 * @date 2023/10/11
 */
class CarStrategy implements Navigation{
    @Override
    public void plan() {
        System.out.println("大哥选择开车回家");
    }
}

准备策略模式测试环境

package com.example.design.strategy;

/**
 * TODO 类描述
 *  策略模式测试上下文
 * @author WKQ
 * @date 2023/10/11
 */
public class StrategyModeContext {

    /**
     * 声明接口对象
     */
    private final Navigation navigation;

    public void goHome(){
        this.navigation.plan();
    }

    /**
     *  通过构造方法 注入具体策略类
     * @param navigation 回家策略
     */
    public StrategyModeContext(Navigation navigation){
        this.navigation = navigation;
    }
    public static void main(String[] args){
        StrategyModeContext car = new StrategyModeContext(new CarStrategy());
        StrategyModeContext bike = new StrategyModeContext(new BikeStrategy());
        StrategyModeContext walk = new StrategyModeContext(new WalkStrategy());
        car.goHome();
        bike.goHome();
        walk.goHome();

    }
}

三、结构性模式

1、适配器模式

/**
 * TODO 类描述
 *  适配器模式是一种结构型设计模式，它允许你将一个类的接口转换成客户端期望的另一个接口
 * @author WKQ
 * @date 2023/12/14
 */
public class AdapterTest {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.request();
    }
}
interface Target {
    /**
     * 目标对象处理逻辑
     */
    void request();
}

/**
 * 适配器类
 */
class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        // 原接口处理逻辑没有变动
        adaptee.specificRequest();
        // 新添处理逻辑
        System.out.println("Adapter: 新添逻辑");
    }
}

/**
 * 需要适配的类
 */
class Adaptee {
    /**
     * 原接口处理逻辑
     */
    public void specificRequest() {
        System.out.println("Adaptee: 原本处理逻辑");
    }
}