Java常用的设计模式

1.工厂模式

工厂模式是一种创建型模式，用于创建对象而无需直接使用new关键字。在工厂模式中，一个工厂类负责创建具有相似特征的对象。在Java中，工厂模式通常使用静态方法或抽象工厂类来实现。

//产品接口
public interface Shape {
    void draw();
}

//圆形类
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("圆形类");
    }
}

//矩形类
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("矩形类");
    }
}

//工厂类
public class ShapeFactory {
    public static Shape createShape(String type) {
        if (type.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (type.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        } else {
            throw new IllegalArgumentException("Unsupported shape type: " + type);
        }
    }
}


public class Demo01{
    public static void main(String[] args) {
        Shape circle = ShapeFactory.createShape("circle");
        circle.draw();
        Shape rectangle = ShapeFactory.createShape("rectangle");
        rectangle.draw();
    }
}

      上面这段代码实现了一个工厂模式，其中定义了一个产品接口 Shape，包含一个抽象方法 draw()。然后定义了两个具体的产品类 Circle 和 Rectangle，它们都实现了 Shape 接口，并重写了 draw() 方法。

接着定义了一个工厂类 ShapeFactory，其中定义了一个静态方法 createShape(String type)，根据传入的参数 type 来创建相应的产品。如果 type 为 "circle"，则创建一个 Circle 对象并返回；如果 type 为 "rectangle"，则创建一个 Rectangle 对象并返回；如果 type 不是这两种类型，则抛出 IllegalArgumentException 异常。

最后，在 Demo01 类的 main 方法中，调用 ShapeFactory 的 createShape 方法来创建 Circle 和 Rectangle 对象，并分别调用它们的 draw() 方法来输出相应的信息。

 

 2.单例模式

单例模式是一种创建型模式，确保一个类只有一个实例，并提供全局访问点。在Java中，单例模式可以通过静态变量或者静态方法来实现。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

        上面这段代码中，Singleton类只有一个私有的静态成员变量instance，表示该类的唯一实例。它也有一个私有的构造函数，这意味着不能从类的外部直接创建对象。为了访问该实例，必须调用getInstance方法。

        getInstance方法首先检查instance是否为null，如果是，则创建一个新的Singleton实例并将其分配给instance。如果instance已经存在，则直接返回它。

由于该类只允许创建一个实例，因此getInstance方法始终返回相同的对象。这可以确保所有代码都使用相同的实例，并且不会创建多个实例。

 3.代理模式

     首先，我们定义一个接口Image，表示图片对象

public interface Image {
    void display();
}

然后我们创建一个实现了该接口的具体类RealImage

public class RealImage implements Image {
    private String filename;
    
    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk();
    }
    
    private void loadFromDisk() {
        System.out.println("Loading " + filename);
    }
    
    @Override
    public void display() {
        System.out.println("Displaying " + filename);
    }
}

然后再创建一个代理类ProxyImage，它实现了Image接口

public class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;
    
    public ProxyImage(String filename) {
        this.filename = filename;
    }
    
    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

在这个代理类中，我们只有在需要显示图片时才会实例化RealImage对象，因此可以避免不必要的加载和消耗内存。

测试：

public class Client {
    public static void main(String[] args) {
        Image image1 = new ProxyImage("cat.jpg");
        Image image2 = new ProxyImage("dog.jpg");
        
        image1.display();  
        image1.display(); 
        image2.display();  
    }
}

结果：

 代理模式总结：当我们创建一个ProxyImage对象时，并没有立即加载真正的图片对象，而是在第一次调用display()方法时才加载图片对象，并执行loadFromDisk()方法，打印加载 cat.jpg接着在执行display()方法打印代理 cat.jpg，后续相同的实例再次调用相同的方法时会直接使用加载好的图片，避免了重复加载和消耗资源。