模式

单例模式

适用于只用来创建一个对象的使用单例模式可以减少资源消耗比如 UUID 生成器自己写的某些静态方法等等

思路是创建一个类类的属性是它本身使用static private修饰保证只有一份类的初始化方法使用 static 修饰保证可以被外部直接调用而不用创建方法

//懒汉式
public class Singleton {

    private static Singleton singleton=new Singleton();
    private Singleton(){
    }
    public  static Singleton getInstance(){
        return singleton;
    }
}

//饿汉式
public class Singleton {

    private static Singleton singleton;
    private Singleton(){
    }
    public  static Singleton getInstance(){
        if(singleton==null){
            singleton=new Singleton();
        }
    }
    return singleton;
}


//多线程饿汉式
public class Singleton {

    private static Singleton singleton;
    private Singleton(){
    }
    public synchronized static Singleton getInstance(){
        if(singleton==null){
            if(singleton==null){
                singleton=new Singleton();
            }
        }
        return singleton;
    }
}


//优化多线程饿汉式
/**
 * Main
 */
class Main {
    Singleton singleton=Singleton.getInstance();
}

public class Singleton {

    private static Singleton singleton;
    private Singleton(){
    }
    public  static Singleton getInstance(){
        if(singleton==null){
            synchronized(Singleton.class){
                if(singleton==null){
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

简单工厂模式

就像一个工厂给他不同的参数他会为你创建不同的对象, 不用我们手动创建了

比如DateFormat()类根据传入参数的不同从而进行不同的创建方法

手动写一个工厂类创建对象的时候校验传入的参数根据参数的不同返回不同的对象

使用 接口 或者抽象类 来保证调用和返回值的通用性

//使用抽象类的
abstract class Re {
    public void speak() {
    }
}

// 实现类1
class Dog extends Re{
    public void speak() {
        System.out.println("汪汪汪");
    }
}

// 实现类2
class Cat extends Re{
    public void speak() {
        System.out.println("喵喵喵");
    }
}

// 工厂类
class AnimalFactory {
    public Re createAnimal(String type) {
        if ("dog".equalsIgnoreCase(type)) {
            return new Dog();
        } else if ("cat".equalsIgnoreCase(type)) {
            return new Cat();
        } else {
            throw new IllegalArgumentException("Invalid animal type");
        }
    }
}

// 使用工厂方法创建对象
public class Main {
    public static void main(String[] args) {
        AnimalFactory factory = new AnimalFactory();
        
        Re dog = factory.createAnimal("dog");
        dog.speak(); // 输出：汪汪汪
        
        Re cat = factory.createAnimal("cat");
        cat.speak(); // 输出：喵喵喵
    }
}

抽象工厂

一般使用抽象类来实现抽象类可以提供一些通用的方法和属性而接口通常用于定义一组方法的规范一个抽象父类工厂多个子类工厂

抽象工厂模式旨在提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体类。抽象工厂可以避免简单工厂违法开闭模式的问题

装饰着模式

BufferedInputStream BufferedOutputStream

适配器模式

原来的接口对当前不太试用但是我们不想修改原来的接口

用于接口不兼容 或者拓展功能使用

使用装饰者模式会修改原来的接口

// 目标接口
interface Target {
    void request();
}



// 需要适配的类
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee's specific request");
    }
}


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

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

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

public class Main {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        
        target.request();
    }
}

观察者模式 (发布订阅模式)

原则

开闭原则

里氏替换

子类可以替换父类子类的行为是可以预期的不建议抛出父类没有的异常这样使用父类的话还要学习子类增加代码的复杂度

接口隔离

接口尽量细化，同时接口中的方法尽量少

依赖倒置

其他

高内聚提高接口、类、模块的处理能力，减少对外的交互

低耦合类接口方法之间的耦合成都要降低易于维护和拓展

java-设计模式.md 4.8 KB Permalink Histórico Raw

模式