Java设计模式：工厂方法、单例模式等常见模式解析示例

原创 Love The Way You Lie 2024-11-12 10:33 8阅读 0赞

Java设计模式是一套被广泛认可的最佳实践，用于解决特定类型的软件设计问题。以下是一些常见的设计模式及其简单示例：

###工厂方法模式（Factory Method Pattern）

工厂方法模式是一种创建型模式，它定义了一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

**示例代码：**

```java//产品接口interface Product {
 void use();
}

//具体产品Aclass ConcreteProductA implements Product {
 public void use() {
 System.out.println("Using ConcreteProductA");
 }
}

//具体产品Bclass ConcreteProductB implements Product {
 public void use() {
 System.out.println("Using ConcreteProductB");
 }
}

//工厂接口interface Factory {
Product factoryMethod();
}

//具体工厂Aclass ConcreteFactoryA implements Factory {
 public Product factoryMethod() {
 return new ConcreteProductA();
 }
}

//具体工厂Bclass ConcreteFactoryB implements Factory {
 public Product factoryMethod() {
 return new ConcreteProductB();
 }
}

public class FactoryMethodPatternDemo {
 public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.factoryMethod();
 productA.use();

Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.factoryMethod();
 productB.use();
 }
}
```###单例模式（Singleton Pattern）

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

**示例代码：**

```javapublic class Singleton {
//私有构造函数 private Singleton() {}

//静态私有实例 private static Singleton instance = null;

// 提供全局访问点 public static Singleton getInstance() {
if (instance == null) {
 instance = new Singleton();
 }
 return instance;
 }
}

public class SingletonPatternDemo {
 public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
 System.out.println(singleton == singleton2); // 输出 true }
}
```###建造者模式（Builder Pattern）

建造者模式是一种创建型模式，它将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

**示例代码：**

```java//产品类class Product {
 private String partA;
 private String partB;
 private String partC;

private Product(Builder builder) {
 this.partA = builder.partA;
 this.partB = builder.partB;
 this.partC = builder.partC;
 }

public static class Builder {
 private String partA;
 private String partB;
 private String partC;

public Builder partA(String partA) {
 this.partA = partA;
 return this;
 }

public Builder partB(String partB) {
 this.partB = partB;
 return this;
 }

public Builder partC(String partC) {
 this.partC = partC;
 return this;
 }

public Product build() {
 return new Product(this);
 }
 }

public void show() {
 System.out.println("Product parts: " + partA + ", " + partB + ", " + partC);
 }
}

public class BuilderPatternDemo {
 public static void main(String[] args) {
Product product = new Product.Builder()
.partA("PartA")
.partB("PartB")
.partC("PartC")
.build();
 product.show();
 }
}
```这些只是设计模式中的一小部分，每种模式都有其特定的使用场景和优势。理解并掌握这些模式可以帮助你写出更加灵活、可扩展和可维护的代码。