Java代码说明设计模式
以下是使用 Java 代码分别说明设计模式中的工厂模式、抽象工厂模式（这里推测你可能想说的是抽象工厂模式而非虚拟工厂模式）、建造者模式和观察者模式。
一、工厂模式
工厂模式是一种创建对象的设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离。工厂模式可以分为简单工厂模式和工厂方法模式。
- 简单工厂模式
- 定义一个工厂类，用于创建产品对象。
- 工厂类有一个创建产品对象的方法，根据传入的参数决定创建哪种具体的产品对象。
示例代码：
// 产品接口
interface Product {
void operation();
}
// 具体产品 A
class ConcreteProductA implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductA operation");
}
}
// 具体产品 B
class ConcreteProductB implements Product {
@Override
public 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 {
@Override
public void operation() {
System.out.println("ConcreteProductA operation");
}
}
// 具体产品 B
class ConcreteProductB implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductB operation");
}
}
// 抽象工厂
abstract class Factory {
abstract Product createProduct();
}
// 具体工厂 A
class ConcreteFactoryA extends Factory {
@Override
Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂 B
class ConcreteFactoryB extends Factory {
@Override
Product 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 {
@Override
public void draw() {
System.out.println("Drawing Circle");
}
}
// 矩形
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing Rectangle");
}
}
// 颜色接口
interface Color {
void fill();
}
// 红色
class Red implements Color {
@Override
public void fill() {
System.out.println("Filling with Red");
}
}
// 蓝色
class Blue implements Color {
@Override
public void fill() {
System.out.println("Filling with Blue");
}
}
// 抽象工厂接口
interface AbstractFactory {
Shape createShape();
Color createColor();
}
// 具体工厂 1
class ConcreteFactory1 implements AbstractFactory {
@Override
public Shape createShape() {
return new Circle();
}
@Override
public Color createColor() {
return new Red();
}
}
// 具体工厂 2
class ConcreteFactory2 implements AbstractFactory {
@Override
public Shape createShape() {
return new Rectangle();
}
@Override
public 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();
@Override
void buildPartA() {
product.setPartA("Part A");
}
@Override
void buildPartB() {
product.setPartB("Part B");
}
@Override
void buildPartC() {
product.setPartC("Part C");
}
@Override
Product 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 {
@Override
public void update() {
System.out.println("ConcreteObserverA received update.");
}
}
// 具体观察者 B
class ConcreteObserverB implements Observer {
@Override
public 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<>();
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public 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();
}
}