工厂模式和发布订阅者模式的区别
时间: 2023-11-30 15:11:34 浏览: 35
工厂模式和发布订阅者模式是两种不同的设计模式。
工厂模式是一种创建型模式,旨在通过工厂类创建对象实例,而不是通过直接调用构造函数。这种模式通常使用一个工厂类,该类包含一个方法,该方法接受参数并返回新创建的对象。这个方法可以根据传递的参数来决定创建哪个对象。
发布订阅者模式是一种行为模式,通过解耦发布者和订阅者来实现松散耦合。在这种模式下,一个对象(发布者)发布一个事件,而其他对象(订阅者)订阅该事件。当事件被触发时,所有订阅者都会收到通知并执行相应的操作。
因此,工厂模式和发布订阅者模式是两种完全不同的模式,旨在解决不同的问题。工厂模式用于创建对象,而发布订阅者模式用于解耦发布者和订阅者。
相关问题
工厂模式和发布订阅者模式的区别?
工厂模式和发布订阅者模式是两种不同的设计模式。
工厂模式是一种创建对象的模式,它提供了一种创建对象的最佳方式,而无需暴露对象的创建逻辑。通过工厂模式,我们可以将对象的创建过程封装在一个工厂类中,使得代码更加灵活、可扩展、易于维护。工厂模式有多种实现方式,包括简单工厂模式、工厂方法模式和抽象工厂模式等。
发布订阅者模式是一种消息传递模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。当主题对象发生改变时,它会通知所有的观察者对象,让它们能够自动更新自己的状态。发布订阅者模式可以增强系统的可扩展性、灵活性和可维护性,也可以降低组件之间的耦合度。常见的实现方式包括事件驱动模型、消息队列模型等。
总的来说,工厂模式和发布订阅者模式都是常用的设计模式,但它们的目的和应用场景是不同的。工厂模式用于对象的创建,发布订阅者模式用于消息的传递和处理。
单例模式、工厂模式、代理模式、适配模式、发布订阅模式、中介者模式用java怎么写
1. 单例模式
饿汉式单例模式:
```java
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return instance;
}
}
```
懒汉式单例模式:
```java
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static synchronized Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
```
2. 工厂模式
简单工厂模式:
```java
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public class ShapeFactory {
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
```
工厂方法模式:
```java
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public interface ShapeFactory {
Shape getShape();
}
public class RectangleFactory implements ShapeFactory {
@Override
public Shape getShape() {
return new Rectangle();
}
}
public class SquareFactory implements ShapeFactory {
@Override
public Shape getShape() {
return new Square();
}
}
```
3. 代理模式
静态代理:
```java
public interface Image {
void display();
}
public class RealImage implements Image {
private String fileName;
public RealImage(String fileName){
this.fileName = fileName;
loadFromDisk(fileName);
}
@Override
public void display() {
System.out.println("Displaying " + fileName);
}
private void loadFromDisk(String fileName){
System.out.println("Loading " + fileName);
}
}
public class ProxyImage implements Image{
private RealImage realImage;
private String fileName;
public ProxyImage(String fileName){
this.fileName = fileName;
}
@Override
public void display() {
if(realImage == null){
realImage = new RealImage(fileName);
}
realImage.display();
}
}
```
动态代理:
```java
public interface Subject {
void request();
}
public class RealSubject implements Subject {
@Override
public void request() {
System.out.println("Real Subject Request");
}
}
public class DynamicProxy implements InvocationHandler {
private Object object;
public DynamicProxy(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before Request");
Object result = method.invoke(object, args);
System.out.println("After Request");
return result;
}
}
public class Client {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
InvocationHandler handler = new DynamicProxy(realSubject);
Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
realSubject.getClass().getInterfaces(), handler);
subject.request();
}
}
```
4. 适配模式
类适配器模式:
```java
public interface Target {
void request();
}
public class Adaptee {
public void specificRequest() {
System.out.println("Adaptee Specific Request");
}
}
public class ClassAdapter extends Adaptee implements Target {
@Override
public void request() {
specificRequest();
}
}
```
对象适配器模式:
```java
public interface Target {
void request();
}
public class Adaptee {
public void specificRequest() {
System.out.println("Adaptee Specific Request");
}
}
public class ObjectAdapter implements Target {
private Adaptee adaptee;
public ObjectAdapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void request() {
adaptee.specificRequest();
}
}
```
5. 发布订阅模式
```java
public interface Observer {
void update(String message);
}
public interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notify(String message);
}
public class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override
public void attach(Observer observer) {
observers.add(observer);
}
@Override
public void detach(Observer observer) {
observers.remove(observer);
}
@Override
public void notify(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
public class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " receive message: " + message);
}
}
public class Client {
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver("Observer1");
Observer observer2 = new ConcreteObserver("Observer2");
subject.attach(observer1);
subject.attach(observer2);
subject.notify("Hello World!");
}
}
```
6. 中介者模式
```java
public interface Mediator {
void sendMessage(String message, Colleague colleague);
}
public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public abstract void send(String message);
public abstract void receive(String message);
}
public class ConcreteMediator implements Mediator {
private Colleague colleague1;
private Colleague colleague2;
public void setColleague1(Colleague colleague1) {
this.colleague1 = colleague1;
}
public void setColleague2(Colleague colleague2) {
this.colleague2 = colleague2;
}
@Override
public void sendMessage(String message, Colleague colleague) {
if (colleague == colleague1) {
colleague2.receive(message);
} else {
colleague1.receive(message);
}
}
}
public class ConcreteColleague1 extends Colleague {
public ConcreteColleague1(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.sendMessage(message, this);
}
@Override
public void receive(String message) {
System.out.println("Concrete Colleague 1 receive message: " + message);
}
}
public class ConcreteColleague2 extends Colleague {
public ConcreteColleague2(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.sendMessage(message, this);
}
@Override
public void receive(String message) {
System.out.println("Concrete Colleague 2 receive message: " + message);
}
}
public class Client {
public static void main(String[] args) {
Mediator mediator = new ConcreteMediator();
Colleague colleague1 = new ConcreteColleague1(mediator);
Colleague colleague2 = new ConcreteColleague2(mediator);
mediator.setColleague1(colleague1);
mediator.setColleague2(colleague2);
colleague1.send("Hello World!");
colleague2.send("Hi!");
}
}
```