Java中常见的设计模式(持续更新中)-CSDN博客

本文链接：https://blog.csdn.net/m0_69266818/article/details/137525392

介绍

是一套被反复使用，多数人知晓，经过分类编目的，代码设计经验的总结
使用设计模式是为了可重用代码，让代码更容易被他人理解，保证代码可靠性，程序的重用性
简单的说就是一套良好的编码风格，通过众多开发人员，长时间测试，经验总结而来，不同的设计模式也有不同的好处

模板设计模式

介绍

把抽象类整体就可以看做成一个模板，模板中不能决定的东西定义为抽象方法，让使用模板的类（继承抽象类的类）去重写抽象方法实现需求。

优势

模板已经定义了通用结构，使用者只需要关心自己需要实现的功能即可

代码

public abstract class Demo {

    public void writeZuoWen(){

        head();

        middle();

        end();

    }

    private void head(){
        System.out.println("作文的开头");
    }

    private void end(){
        System.out.println("作文的结尾");
    }

    public abstract void middle();
}

装饰者设计模式

介绍

不改变原类，在不继承的基础上，动态的扩展一个对象的功能(功能增强)

套路

装饰类和被装饰类需要共同的父类型
装饰类的构造要接收被装饰类的对象
在装饰类中把要增强扩展的功能进行扩展
对于不要增强的功能直接引用

代码

//介绍BufferReader  提高读的效率

//场景：在使用FileReader类时，发现读的效率低，希望提高效率
//不能修改FileReader类，不能继承FileReader类，要对read(char[] cbuf)方法进行增强

//使用装饰者设计模式
//装饰类：BufferReader  被装饰类：FileReader
//他俩都由共同的父类Reader
public class BufferedReader extends Reader(){

    private FileReader fileReader;

    public BufferedReader(FileReader fileReader){
    this.fileReader = fileReader;
}

//成员变量
private int size = 1024*8;

//缓冲区对象
char[] cbuf = new char[size];

//重写read()方法
public int read(){
    read(cbuf);
}

//重写read(char[] cbuf){
public int read(char[] cbuf){
    ...
}

//重写相关方法
public void close(){
    fileReader.close();//调用原有功能
}



}

单例设计模式

介绍

正常情况下一个类就可以创建多个对象，但是有时候一个对象就能搞定的事情，创建多个对象就会浪费内存
通过单例模式创建的项目的类，这个类只能有一个对象，可以节省内存，共享数据

步骤

将构造方法私有化，使其外部不能通过new关键字创建该类的对象
定义一个静态方法返回这个唯一对象
在该类内部创建一个唯一的实例化对象

代码

public class King1 {

    private static King1 king1 = new King1();

    private King1(){

    }

    public static King1 getInstance(){
        return king1;
    }

}

public class King2 {

    private static King2 king2;

    private King2(){

    }

    public synchronized static King2 getInstance(){
        if (king2 == null){
            king2 = new King2();
        }
        return king2;
    }

}

多例设计模式

介绍

通过多例模式可以保证该类有固定数量的实例
应用：线程池

步骤

创建一个类，将其构造方法实例化，使其不能在类的外部通过new创建对象
在类中定义该类被创建对象的总数量
在类中定义存放类实例的list集合
在类中提供静态代码块，在静态代码块中创建类的实例
提供静态方法让外部获取实例

代码

public class Teacher {

    private Teacher(){

    }

    private static int size = 3;

    private static List<Teacher> teachers = new ArrayList<>();

    static {
        for (int i = 0; i < size; i++) {
            teachers.add(new Teacher());
        }
    }

    public static Teacher getInstance(){

        return teachers.get(new Random().nextInt(teachers.size()));
    }

    //要想像线程池那样
    public static Teacher getInstance(int size){
        int count = teachers.size();
        int result = size - count;
        if (result > 0){
            for (int i = 0; i < result; i++) {
                teachers.add(new Teacher());
            }
        }
       return  getInstance();
    }

}

工厂设计模式

介绍

是Java中最常用的设计模式之一，属于创建型模式，它提供了一种创建对象的最佳方式。
作用：类与类之间进行解耦

步骤

编写一个接口，定义一个方法
编写子类1实现接口，重写其方法
编写子类2实现接口，重写其方法
编写一个接口工厂类
1. 类中私有化构造方法
2. 定义静态方法来让外部创建对象

代码

public interface Car {

    void run();
}

public class Falali implements Car{
    @Override
    public void run() {
        System.out.println("法拉利破百仅需3秒");
    }
}

public class Audi implements Car{
    @Override
    public void run() {
        System.out.println("奥迪RS7破败仅需3.8秒");
    }
}

public class CarFactory {

    private CarFactory() {

    }

    public static Car getInstance(String name) {
        Car car = null;
        if ("Falali".equals(name)){
            car = new Falali();
        }else if ("Audi".equals(name)){
            car = new Audi();
        }

        return car;
    }
}