Java常见设计模式及实现 |21xrx.com

Java常见设计模式及实现

2023-06-14 23:14:54 深夜i -- --

Java 设计模式工厂模式单例模式观察者模式代理模式

Java是一种面向对象的编程语言，在软件开发中，设计模式是一个非常重要的概念。设计模式是指解决特定问题的一些常用的方法或技巧。在Java中，常见的设计模式包括工厂模式、单例模式、观察者模式、代理模式等。

工厂模式：工厂模式是一种创建对象的设计模式，它会根据情况来确定实例化哪个对象，并返回该对象。在Java中，工厂模式可以通过接口实现，具体实现类则实现接口中的方法。

示例代码：


public interface Fruit {
  void eat();
}
public class Apple implements Fruit {
  @Override
  public void eat() {
    System.out.println("eat apple");
  }
}
public class Banana implements Fruit {
  @Override
  public void eat() {
    System.out.println("eat banana");
  }
}
public interface FruitFactory {
  Fruit getFruit();
}
public class AppleFactory implements FruitFactory {
  @Override
  public Fruit getFruit() {
    return new Apple();
  }
}
public class BananaFactory implements FruitFactory {
  @Override
  public Fruit getFruit() {
    return new Banana();
  }
}
public class Test {
  public static void main(String[] args) {
    FruitFactory factory = new AppleFactory();
    Fruit fruit = factory.getFruit();
    fruit.eat();
  }
}

单例模式：单例模式是一种只能创建一个实例的设计模式。在Java中，单例模式可以通过私有化构造方法和静态方法实现。

示例代码：


public class Singleton {
  private static Singleton instance = null;
  private Singleton()
  
  public static Singleton getInstance() {
    if (instance == null) {
      synchronized (Singleton.class) {
        if (instance == null) {
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}
public class Test {
  public static void main(String[] args) {
    Singleton singleton1 = Singleton.getInstance();
    Singleton singleton2 = Singleton.getInstance();
    System.out.println(singleton1 == singleton2);
  }
}

观察者模式：观察者模式是一种对象间的一对多依赖关系，当一个对象状态发生改变时，所有依赖它的对象都会自动收到通知并更新。在Java中，观察者模式可以通过接口和类实现。

示例代码：


public interface Observer {
  void update(String 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 + " received message: " + message);
  }
}
public interface Subject {
  void addObserver(Observer observer);
  void deleteObserver(Observer observer);
  void notifyObservers(String message);
}
public class ConcreteSubject implements Subject {
  private List
  observers = new ArrayList<>();
 
  @Override
  public void addObserver(Observer observer) {
    observers.add(observer);
  }
  @Override
  public void deleteObserver(Observer observer) {
    observers.remove(observer);
  }
  @Override
  public void notifyObservers(String message) {
    for (Observer observer : observers) {
      observer.update(message);
    }
  }
}
public class Test {
  public static void main(String[] args) {
    ConcreteObserver observer1 = new ConcreteObserver("Observer1");
    ConcreteObserver observer2 = new ConcreteObserver("Observer2");
    ConcreteSubject subject = new ConcreteSubject();
    subject.addObserver(observer1);
    subject.addObserver(observer2);
    subject.notifyObservers("hello world");
  }
}

代理模式：代理模式是一种在访问对象时引入一定程度的间接性的设计模式，通过代理类来控制对目标对象的访问。在Java中，代理模式可以通过接口和类实现。

示例代码：


public interface Subject {
  void request();
}
public class RealSubject implements Subject {
  @Override
  public void request() {
    System.out.println("RealSubject request");
  }
}
public class Proxy implements Subject {
  private RealSubject realSubject;
  public Proxy(RealSubject realSubject)
    this.realSubject = realSubject;
  
  @Override
  public void request() {
    beforeRequest();
    realSubject.request();
    afterRequest();
  }
  private void beforeRequest() {
    System.out.println("before request");
  }
  private void afterRequest() {
    System.out.println("after request");
  }
}
public class Test {
  public static void main(String[] args) {
    RealSubject realSubject = new RealSubject();
    Proxy proxy = new Proxy(realSubject);
    proxy.request();
  }
}

上一篇: idea打包java可执行jar包

下一篇: 小数的方法及注意事项

评论区

()

相似文章