java设计模式

创建型模式：

用于处理对象的创建，包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、原型模式和建造者模式。

简单工厂模式通过一个工厂类来创建不同类型的对象，客户端只需要提供相应的参数就可以获取所需的对象。

// 抽象产品类
public abstract class Product {
    public abstract void use();
}
 
// 具体产品类A
public class ProductA extends Product {
    public void use() {
        System.out.println("Product A in use");
    }
}
 
// 具体产品类B
public class ProductB extends Product {
    public void use() {
        System.out.println("Product B in use");
    }
}
 
// 工厂类
public class Factory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Invalid product type: " + type);
        }
    }
}
 
// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = Factory.createProduct("A");
        productA.use();
 
        Product productB = Factory.createProduct("B");
        productB.use();
    }
}

工厂方法模式把具体对象的创建推迟到子类中实现，在客户端中只关心抽象产品和工厂接口，而不关心具体实现。

// 抽象产品类
public abstract class Product {
    public abstract void use();
}
 
// 具体产品类A
public class ProductA extends Product {
    public void use() {
        System.out.println("Product A in use");
    }
}
 
// 具体产品类B
public class ProductB extends Product {
    public void use() {
        System.out.println("Product B in use");
    }
}
 
// 抽象工厂接口
public interface Factory {
    Product createProduct();
}
 
// 具体工厂实现A
public class FactoryA implements Factory {
    public Product createProduct() {
        return new ProductA();
    }
}
 
// 具体工厂实现B
public class FactoryB implements Factory {
    public Product createProduct() {
        return new ProductB();
    }
}
 
// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.use();
 
        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

抽象工厂模式通过一个抽象工厂接口来创建一组相关的对象，客户端不需要知道具体实现。

// 抽象工厂接口
public interface AbstractFactory {
    Product createProduct();
    Part createPart();
}
 
// 具体工厂实现A
public class ConcreteFactoryA implements AbstractFactory {
    public Product createProduct() {
        return new ProductA();
    }
 
    public Part createPart() {
        return new PartA();
    }
}
 
// 具体工厂实现B
public class ConcreteFactoryB implements AbstractFactory {
    public Product createProduct() {
        return new ProductB();
    }
 
    public Part createPart() {
        return new PartB();
    }
}
 
// 抽象产品类
public abstract class Product {
    public abstract void use();
}
 
// 具体产品类A
public class ProductA extends Product {
    public void use() {
        System.out.println("Product A in use");
    }
}
 
// 具体产品类B
public class ProductB extends Product {
    public void use() {
        System.out.println("Product B in use");
    }
}
 
// 抽象零件类
public abstract class Part {
    public abstract void operate();
}
 
// 具体零件类A
public class PartA extends Part {
    public void operate() {
        System.out.println("Part A is operating");
    }
}
 
// 具体零件类B
public class PartB extends Part {
    public void operate() {
        System.out.println("Part B is operating");
    }
}
 
// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        Part partA = factoryA.createPart();
        productA.use();
        partA.operate();
 
        AbstractFactory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        Part partB = factoryB.createPart();
        productB.use();
        partB.operate();
    }
}

单例模式用于保证一个类只有一个实例并提供全局访问点。

// 饿汉式单例模式
public class Singleton {
    private static final Singleton instance = new Singleton();
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        return instance;
    }
}
 
// 懒汉式单例模式
public class Singleton {
    private static volatile Singleton instance;
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

原型模式通过复制现有的对象来创建新的对象，可以避免重复创建相似的对象，提高系统性能。

// 抽象原型类
public abstract class Prototype implements Cloneable {
    public abstract Prototype clone();
}
 
// 具体原型类A
public class ConcretePrototypeA extends Prototype {
    public Prototype clone() {
        try {
            return (ConcretePrototypeA) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}
 
// 具体原型类B
public class ConcretePrototypeB extends Prototype {
    public Prototype clone() {
        try {
            return (ConcretePrototypeB) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}
 
// 客户端代码
public class Client {
    public static void main(String[] args) {
        Prototype prototypeA = new ConcretePrototypeA();
        Prototype prototypeB = new ConcretePrototypeB();
 
        Prototype clonedA = prototypeA.clone();
        Prototype clonedB = prototypeB.clone();
 
        System.out.println(clonedA.getClass().getName());
        System.out.println(clonedB.getClass().getName());
    }
}

建造者模式通过一个复杂对象的构建过程和表示方式，让用户在不同的构建方式下，能够得到不同的对象表示结果。

// 产品类
public class Product {
    private String partA;
    private String partB;
    private String partC;
 
    public void setPartA(String partA) {
        this.partA = partA;
    }
 
    public void setPartB(String partB) {
        this.partB = partB;
    }
 
    public void setPartC(String partC) {
        this.partC = partC;
    }
 
    // 省略其他方法
}
 
// 抽象建造者类
public abstract class Builder {
    protected Product product = new Product();
 
    public abstract void buildPartA();
 
    public abstract void buildPartB();
 
    public abstract void buildPartC();
 
    public Product getProduct() {
        return product;
    }
}
 
// 具体建造者类A
public class ConcreteBuilderA extends Builder {
    public void buildPartA() {
        product.setPartA("part A from builder A");
    }
 
    public void buildPartB() {
        product.setPartB("part B from builder A");
    }
 
    public void buildPartC() {
        product.setPartC("part C from builder A");
    }
}
 
// 具体建造者类B
public class ConcreteBuilderB extends Builder {
    public void buildPartA() {
        product.setPartA("part A from builder B");
    }
 
    public void buildPartB() {
        product.setPartB("part B from builder B");
    }
 
    public void buildPartC() {
        product.setPartC("part C from builder B");
    }
}
 
// 指挥者类
public class Director {
    private Builder builder;
 
    public Director(Builder builder) {
        this.builder = builder;
    }
 
    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}
 
// 客户端代码
public class Client {
    public static void main(String[] args) {
        Builder builderA = new ConcreteBuilderA();
        Director directorA = new Director(builderA);
        directorA.construct();
        Product productA = builderA.getProduct();
        System.out.println(productA.toString());
 
        Builder builderB = new ConcreteBuilderB();
        Director directorB = new Director(builderB);
        directorB.construct();
        Product productB = builderB.getProduct();
        System.out.println(productB.toString());
    }
}

结构型模式：

用于设计类和对象的结构，包括适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式。

行为型模式：

用于描述对象之间的通信方式和协作方式，包括责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式。

并发模式：

用于解决多线程编程中的并发问题，包括读写锁模式、生产者消费者模式、线程池模式、并行算法模式、响应者模式等。