Java设计模式实战：单例、工厂模式解析

原创阳光穿透心脏的1/2处 2024-11-14 04:12 0阅读 0赞

Java设计模式是一套被广泛认可的最佳实践，用于解决特定类型的软件设计问题。单例模式和工厂模式是两种非常常见的设计模式，它们在软件开发中有着广泛的应用。下面我将分别对这两种模式进行解析。

###单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式在需要控制资源消耗、控制实例化次数、节约系统资源时非常有用。

**特点：**
-构造函数是私有的，防止外部通过`new`创建多个实例。
- 提供一个静态方法来获取唯一的实例。
-确保线程安全。

**实现方式：**

1. **懒汉式（线程不安全）**
```javapublic class Singleton {
 private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {
if (instance == null) {
 instance = new Singleton();
 }
 return instance;
 }
}
```2. **懒汉式（线程安全）**
```javapublic class Singleton {
 private static Singleton instance;

private Singleton() {}

public static synchronized Singleton getInstance() {
if (instance == null) {
 instance = new Singleton();
 }
 return instance;
 }
}
```3. **饿汉式**
```javapublic class Singleton {
 private static final Singleton instance = new Singleton();

private Singleton() {}

public static Singleton getInstance() {
 return instance;
 }
}
```4. **双重检查锁定（Double-Checked Locking）**
```javapublic 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;
 }
}
```###工厂模式（Factory Pattern）

工厂模式是一种创建型模式，用于处理对象的创建，将对象的创建和使用分离。这种模式在需要创建多个相似对象时非常有用，可以提高代码的模块化和可维护性。

**特点：**
-定义一个创建对象的接口，让子类决定实例化哪一个类。
-工厂模式使一个类的实例化延迟到其子类。

**实现方式：**

1. **简单工厂模式**
```javapublic interface Product {
 void use();
}

public class ConcreteProductA implements Product {
 public void use() {
 System.out.println("Using ConcreteProductA");
 }
}

public class ConcreteProductB implements Product {
 public void use() {
 System.out.println("Using ConcreteProductB");
 }
}

public class SimpleFactory {
 public Product createProduct(String type) {
if ("A".equals(type)) {
 return new ConcreteProductA();
} else if ("B".equals(type)) {
 return new ConcreteProductB();
 }
 return null;
 }
}
```2. **工厂方法模式**
```javapublic interface Product {
 void use();
}

public class ConcreteProductA implements Product {
 public void use() {
 System.out.println("Using ConcreteProductA");
 }
}

public class ConcreteProductB implements Product {
 public void use() {
 System.out.println("Using ConcreteProductB");
 }
}

public interface Factory {
Product createProduct();
}

public class ConcreteFactoryA implements Factory {
 public Product createProduct() {
 return new ConcreteProductA();
 }
}

public class ConcreteFactoryB implements Factory {
 public Product createProduct() {
 return new ConcreteProductB();
 }
}
```3. **抽象工厂模式**
```javapublic interface AbstractProductA {
 void use();
}

public interface AbstractProductB {
 void use();
}

public class ConcreteProductA1 implements AbstractProductA {
 public void use() {
 System.out.println("Using ConcreteProductA1");
 }
}

public class ConcreteProductB1 implements AbstractProductB {
 public void use() {
 System.out.println("Using ConcreteProductB1");
 }
}

public class ConcreteProductA2 implements AbstractProductA {
 public void use() {
 System.out.println("Using ConcreteProductA2");
 }
}

public class ConcreteProductB2 implements AbstractProductB {
 public void use() {
 System.out.println("Using ConcreteProductB2");
 }
}

public interface AbstractFactory {
 AbstractProductA createProductA();
 AbstractProductB createProductB();
}

public class ConcreteFactory1 implements AbstractFactory {
 public AbstractProductA createProductA() {
 return new ConcreteProductA1();
 }

public AbstractProductB createProductB() {
 return new ConcreteProductB1();
 }
}

public class ConcreteFactory2 implements AbstractFactory {
 public AbstractProductA createProductA() {
 return new ConcreteProductA2();
 }