以下是使用 Java 代码分别说明设计模式中的工厂模式、抽象工厂模式（这里推测你可能想说的是抽象工厂模式而非虚拟工厂模式）、建造者模式和观察者模式。
一、工厂模式
工厂模式是一种创建对象的设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离。工厂模式可以分为简单工厂模式和工厂方法模式。
- 简单工厂模式
- 定义一个工厂类，用于创建产品对象。
- 工厂类有一个创建产品对象的方法，根据传入的参数决定创建哪种具体的产品对象。
示例代码：
// 产品接口
interface Product {void operation();
}// 具体产品 A
class ConcreteProductA implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductA operation");}
}// 具体产品 B
class ConcreteProductB implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductB operation");}
}// 简单工厂
class SimpleFactory {public static Product createProduct(String type) {if ("A".equals(type)) {return new ConcreteProductA();} else if ("B".equals(type)) {return new ConcreteProductB();}return null;}
}
使用示例：
public class FactoryPatternExample {public static void main(String[] args) {Product productA = SimpleFactory.createProduct("A");productA.operation();Product productB = SimpleFactory.createProduct("B");productB.operation();}
}
- 工厂方法模式
- 定义一个抽象工厂类，其中包含一个抽象的创建产品对象的方法。
- 具体的工厂类实现抽象工厂类，实现创建具体产品对象的方法。
示例代码：
// 产品接口
interface Product {void operation();
}// 具体产品 A
class ConcreteProductA implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductA operation");}
}// 具体产品 B
class ConcreteProductB implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductB operation");}
}// 抽象工厂
abstract class Factory {abstract Product createProduct();
}// 具体工厂 A
class ConcreteFactoryA extends Factory {@OverrideProduct createProduct() {return new ConcreteProductA();}
}// 具体工厂 B
class ConcreteFactoryB extends Factory {@OverrideProduct createProduct() {return new ConcreteProductB();}
}
使用示例：
public class FactoryMethodPatternExample {public static void main(String[] args) {Factory factoryA = new ConcreteFactoryA();Product productA = factoryA.createProduct();productA.operation();Factory factoryB = new ConcreteFactoryB();Product productB = factoryB.createProduct();productB.operation();}
}
二、抽象工厂模式
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
示例代码：
// 形状接口
interface Shape {void draw();
}// 圆形
class Circle implements Shape {@Overridepublic void draw() {System.out.println("Drawing Circle");}
}// 矩形
class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Drawing Rectangle");}
}// 颜色接口
interface Color {void fill();
}// 红色
class Red implements Color {@Overridepublic void fill() {System.out.println("Filling with Red");}
}// 蓝色
class Blue implements Color {@Overridepublic void fill() {System.out.println("Filling with Blue");}
}// 抽象工厂接口
interface AbstractFactory {Shape createShape();Color createColor();
}// 具体工厂 1
class ConcreteFactory1 implements AbstractFactory {@Overridepublic Shape createShape() {return new Circle();}@Overridepublic Color createColor() {return new Red();}
}// 具体工厂 2
class ConcreteFactory2 implements AbstractFactory {@Overridepublic Shape createShape() {return new Rectangle();}@Overridepublic Color createColor() {return new Blue();}
}
使用示例：
public class AbstractFactoryPatternExample {public static void main(String[] args) {AbstractFactory factory1 = new ConcreteFactory1();Shape shape1 = factory1.createShape();Color color1 = factory1.createColor();shape1.draw();color1.fill();AbstractFactory factory2 = new ConcreteFactory2();Shape shape2 = factory2.createShape();Color color2 = factory2.createColor();shape2.draw();color2.fill();}
}
三、建造者模式
建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
示例代码：
// 产品类
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 void show() {System.out.println("Part A: " + partA);System.out.println("Part B: " + partB);System.out.println("Part C: " + partC);}
}// 抽象建造者
abstract class Builder {abstract void buildPartA();abstract void buildPartB();abstract void buildPartC();abstract Product getResult();
}// 具体建造者
class ConcreteBuilder extends Builder {private Product product = new Product();@Overridevoid buildPartA() {product.setPartA("Part A");}@Overridevoid buildPartB() {product.setPartB("Part B");}@Overridevoid buildPartC() {product.setPartC("Part C");}@OverrideProduct getResult() {return product;}
}// 导演类
class Director {public void construct(Builder builder) {builder.buildPartA();builder.buildPartB();builder.buildPartC();}
}
使用示例：
public class BuilderPatternExample {public static void main(String[] args) {Builder builder = new ConcreteBuilder();Director director = new Director();director.construct(builder);Product product = builder.getResult();product.show();}
}
四、观察者模式
观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。
示例代码：
// 观察者接口
interface Observer {void update();
}// 具体观察者 A
class ConcreteObserverA implements Observer {@Overridepublic void update() {System.out.println("ConcreteObserverA received update.");}
}// 具体观察者 B
class ConcreteObserverB implements Observer {@Overridepublic void update() {System.out.println("ConcreteObserverB received update.");}
}// 被观察对象接口
interface Subject {void registerObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers();
}// 具体被观察对象
class ConcreteSubject implements Subject {private List<Observer> observers = new ArrayList<>();@Overridepublic void registerObserver(Observer observer) {observers.add(observer);}@Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}@Overridepublic void notifyObservers() {for (Observer observer : observers) {observer.update();}}
}
使用示例：
public class ObserverPatternExample {public static void main(String[] args) {Subject subject = new ConcreteSubject();Observer observerA = new ConcreteObserverA();Observer observerB = new ConcreteObserverB();subject.registerObserver(observerA);subject.registerObserver(observerB);subject.notifyObservers();}
}
