网站终端制作,js 网站校验,在手机上创建网站,asp建站软件以下是使用 Java 代码分别说明设计模式中的工厂模式、抽象工厂模式#xff08;这里推测你可能想说的是抽象工厂模式而非虚拟工厂模式#xff09;、建造者模式和观察者模式。
一、工厂模式
工厂模式是一种创建对象的设计模式#xff0c;它提供了一种创建对象的方式#xf…以下是使用 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 ListObserver 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();}
}
