Java中的这些设计模式你一定都知道吧-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45541665/article/details/143813556

前言

为什么我们需要学习设计模式呢？
这很明显，这就跟我们看别人的代码来学习一样，是为了学习里面的精髓。每一本设计模式的书都会告诉你，这些都是在讲究如何对修改封闭，对扩展开放的事情。

我们学设计模式，是为了学习如何合理的组织我们的代码，如何解耦，如何真正的达到对修改封闭对扩展开放的效果。设计模式学会了，你就会发现在写代码的时候，之前感觉复杂且难以排布的代码都有很好的思路去安排了。

在面试中，常遇到的设计模式相关的问题，只有思路理清了，回答才能顺畅起来。

创建型模式

简单工厂


class Factory {
    public static Product createProduct(String type) {
        Product productInstance = null;

        switch (type) {
            case "A":
                productInstance = new ProductA();
                break;
            case "B":
                productInstance = new ProductB();
                break;
            default:
                System.out.println("no this type")
                break;
        }
        return productInstance;
    }
}

abstract class Product {
    public abstract void info();
}

class ProductA extends Product {
    @Override // 方法重写
    public void info() {
        System.out.println("this is AAA")
    }
}

class ProductB extends Product {
    @Override
    public void info() {
        System.out.println("this is BBB")
    }
}

工厂方法


interface Factory{
    public Product createProduct();
}

class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }

}

interface Product {
    public void info();
}

class ProductA implements Product {
    @Override // 方法重写
    public void info() {
        System.out.println("this is AAA")
    }
}

class ProductB implements Product {
    @Override
    public void info() {
        System.out.println("this is BBB")
    }
}

抽象工厂

interface Factory{
    public AbstractProductA CreateProductA();
    public AbstractProductB CreateProductB();
}

class ConcreateFactory1 implements Factory {
    @Override
    public AbstractProductA CreateProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB CreateProductB() {
        return new ProductB1();
    }
}

class ConcreateFactory2 implements Factory {
    @Override
    public AbstractProductA CreateProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB CreateProductB() {
        return new ProductB2();
    }
}

interface AbstractProductA {
    public void info();
}

interface AbstractProductB {
    public void info();
}

class ProductA1 implements AbstractProductA {
    @Override // 方法重写
    public void info() {
        System.out.println("this is A1")
    }
}
class ProductA2 implements AbstractProductA {
    @Override // 方法重写
    public void info() {
        System.out.println("this is A2")
    }
}

class ProductB1 implements AbstractProductB {
    @Override // 方法重写
    public void info() {
        System.out.println("this is B1")
    }
}
class ProductB2 implements AbstractProductB {
    @Override // 方法重写
    public void info() {
        System.out.println("this is B2")
    }
}

生成器

/* 使用：
    Director director = new Director();
    
    Builder builder1 = new Builder1();
    director.Construct(builder1)
*/


class Director {
    public void Construct(Builder builder) {
        builder.BuildPart();
    }
}

abstract class Builder {
    public abstract void BuildPart();
    public abstract Product getResult();
}

class Builder1 extends Builder {
    Product productInstance = new Product();

    @Override
    public void BuildPart() {
        productInstance.SetFeilds("tom", "man") //初始化方案一
    }

    @Override
    public Product getResult() {
        return Product
    }

}

class Builder2 extends Builder {
    Product productInstance = new Product();

    @Override
    public void BuildPart() {
        productInstance.SetFeilds("cat","woman") //初始化方案二
    }

    @Override
    public Product getResult() {
        return Product
    }

}

class Product {
    public String name = "";
    public String sex = "";

    public void SetFeildsOfName(String caller, String gender) {
        this.name = caller
        this.sex = gender
    }

    public void show() {
        System.out.println(this)
    }
}

原型实例

interface Prototype {
    public Object Clone();
}

class Product implements Prototype {
    private int id;
    private double price;

    public Product(int id, double price) {
        this.id = id;
        this.price = price;
    }

    public int getId() {
        return id
    }

    public double getPrice() {
        return price
    }

    @Override
    public Object Clone() {  //有个该方法， 无需 对象 的 类， 也能 创建出一个 新的 对象。
        Product obj =  new Product();
        obj.id = this.id;
        obj.price = this.price;

        return obj;
    }
}

单例

/**
Singleton obj1 = Singleton.getInstance();
Singleton obj2 = Singleton.getInstance();
Singleton obj3 = Singleton.getInstance();

说明： obj1, obj2, obj3 指向 同一个 对象地址， 确保了 只有一个 实例

*/


class Singleton{
    // 这一步是为了确保 只能有一个实例， 即 类名的 同名方法 如果是 private， 则不能通过 new 的方式创建对象
    private Singleton(){}  

    // 静态方法 只能使用 静态变量， 所以这里 将 instance 设置为 静态变量
    private static Singleton instance = new Singleton();

    // 该方法  就是 全局访问点
    public static Singleton getInstance() {
        return instance
    }
}

结构性模式

适配器


/*
    将 TypeC 适配 USB 可用的地方

    USB usb = new Adapter();
    usb.Request();

*/

class USB {
    public void Request() {
        System.out.println("USB")
    }
}

class Adapter extends USB {
    private TypeC typeC = new TypeC();

    @Override
    public void Request() {
        typeC.SpecialRequest();
    }
}

class TypeC {
    public void SpecialRequest() {
        System.out.println("TyoeC")
    }
}

桥接


/**
    调用：

        计算儿童票价
        People kid = new Children();

        Tickets aTickets = new ATickets(kid);
        System.out.println("A景区儿童票=" + aTickets.getMoney());

        Tickets bTikcets = new BTickets(kid);
        System.out.println("B景区儿童票=" + bTikcets.getMoney());



        计算老人票价
        People older = new OlderPeople();

        aTickets = new ATickets(olderPeople);
        System.out.println("A景区老人票=" + aTickets.getMoney());
        
        bTikcets = new BTickets(olderPeople);
        System.out.println("B景区老人票=" + bTikcets.getMoney());
*/

//People接口类
public interface People { 
    String getSale();
}

// 儿童类
public class Children implements People {
    @Override
    public String getSale() {
        return "0.6"; //儿童票6折
    }
}

// 老人类
public class OlderPeople implements People {
    @Override
    public String getSale() {
        return "0.5"; // 老人票5折
    }
}

// 门票接口类
public interface Tickets {
    int getMoney();
}

// A景区门票类
public class ATickets implements Tickets{

    private People people;

    public ATickets(People people) {
        this.people = people;
    }

    @Override
    public int getMoney() {
        String sale = people.getSale(); // 获得折扣
        BigDecimal saleBigDecimal = new BigDecimal(sale); // java小数计算会丢失精度，要用BigDecimal来计算
        BigDecimal ticketsBigDecimal = new BigDecimal("100"); // a景区门票原价100
        return ticketsBigDecimal.multiply(saleBigDecimal).intValue(); // 原价门票乘以折扣
    }
}

// B景区门票类
public class BTickets implements Tickets{

    private People people;

    public BTickets(People people) {
        this.people = people;
    }

    @Override
    public int getMoney() {
        String sale = people.getSale(); // 获得折扣
        BigDecimal saleBigDecimal = new BigDecimal(sale); // java小数计算会丢失精度，要用BigDecimal来计算
        BigDecimal ticketsBigDecimal = new BigDecimal("150"); // b景区门票原价100
        return ticketsBigDecimal.multiply(saleBigDecimal).intValue(); // 原价门票乘以折扣
    }
}

组合

/**
    调用：

    EmployeeA1 employeeA1 = new EmployeeA1(25); // 部门A下的1号员工,假设为 25岁
    EmployeeA2 employeeA2 = new EmployeeA2(26); // 部门A下的2号员工
    EmployeeB1 employeeB1= new EmployeeB1(30); // 部门B下的1号员工
    EmployeeB2 employeeB2= new EmployeeB2(30); // 部门B下的2号员工
    
    DepartmentB departmentB = new DepartmentB(); // 组装部门B
    departmentB.add(employeeB1);
    departmentB.add(employeeB2);
    
    DepartmentA departmentA = new DepartmentA(); // 组装部门A
    departmentA.add(employeeA1);
    departmentA.add(employeeA2);
    departmentA.add(departmentB);// 部门B也属于部门A
    
    // 查看 总的 年龄
    System.out.println(departmentA.getAge())
    
*/

// 公司接口类
public interface Company {
    int getAge();
}

// 员工类，这里只放员工A1的代码实现，其他员工的代码和这个一样
public class EmployeeA1 implements Company {
    private int age;

    public EmployeeA1(int age) {
        this.age = age;
    }

    @Override
    public int getAge() {
        return this.age;
    }
}

// 部门类，这里只放部门A的代码实现，部门B和这个一样
public class DepartmentA implements Company {

    private List<Company> list = new ArrayList<>();
    private String name;

    public void add(Company company) {
        list.add(company);
    }

    @Override
    public int getAge() { // 统计部门下所有员工的年龄总和
        int age = 0;
        for (Company company : list) {
            age = age + company.getAge();
        }
        return age;
    }
}

代理


interface Subject {
    public void buy();
}

class Proxy implements Subject {
    protected RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void buy() {
        System.out.println("付钱 前 代理要做的一些事");

        System.out.println("付钱");

        System.out.println("付钱 后 代理要做的一些事");
    }
}


class RealSubject implements Subject {
    @Override
    public void buy() {
        System.out.println("付钱");
    }
}

行为性模式

责任链

/**
    调用：
    Handler 辅导员 = new FuDaoYuan();
    Handler 系主任 = new XiZhuRen();
    Handler 校长 = new XiaoZhang();

    // 设计 责任链
    辅导员.setNext(系主任)
    系主任.setNext(校长)

    // 使用 责任链
    int request = 100;  // 100天假 的请求
    辅导员.HandlerRquest(request);

*/


abstract class Handler {
    protected Handler next;

    public void setNext(Handler next) {
        this.next = next;
    }

    public abstract void HandlerRquest(int request);
}

class FuDaoYuan extends Handler {
    @Override
    public void HandlerRquest(int request) {
        if (request  < 7) {
            System.out.println("辅导员 审批通过")
        } else {
            if (next != null) { // 如果责任链 还有 后继， 则向后传递请求
                // 传递 请求
                next.HandlerRquest(request);
            } else {
                System.out.println("无法 处理 该请求")
            }
        }
    }
}


class XiZhuRen extends Handler {
    @Override
    public void HandlerRquest(int request) {
        if (request  < 30) {
            System.out.println("系主任 审批通过")
        } else {
            if (next != null) { // 如果责任链 还有 后继， 则向后传递请求
                // 传递 请求
                next.HandlerRquest(request);
            } else {
                System.out.println("无法 处理 该请求")
            }
        }
    }
}


class XiaoZhang extends Handler {
    @Override
    public void HandlerRquest(int request) {
        if (request  < 300) {
            System.out.println("校长 审批通过")
        } else {
            if (next != null) { // 如果责任链 还有 后继， 则向后传递请求
                // 传递 请求
                next.HandlerRquest(request);
            } else {
                System.out.println("无法 处理 该请求")
            }
        }
    }
}

命令

/**
    调用：
    Tv tv = new Tv();

    Command 开机 = new OnCommand(tv);
    Command 关机 = new OffCommand(tv);

    Invoker invoker = new Invoker();

    invoker.setCommand(onCommand) ;
    invoker.call();

    invoker. setCommand (offCommand) ;
    invoker.call();

*/

class Invoker { 
    private Command command;

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

    public void call() {
        command.Execute();
    }

}


interface Command {
    public void Execute(); // 执行命令
}

class OnCommand implements Command { // 开机命令
    private Tv tv;

    public OnCommand(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void Execute() {
        tv.OnAction();
    }
}

class OffCommand implements Command { // 关机命令
    private Tv tv;

    public OffCommand(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void Execute() {
        tv.OffAction();
    }
}

class Tv {
    public void OnAction() { // 开机行为
        System.out.println("开机了....")
    }

    public void OffAction() { // 关机行为
        System.out.println("关机了....")
    }
}