Java设计模式是Java语言中广泛应用的一种编程思想，它可以帮助开发人员更好地组织和管理代码，提高代码的可复用性和可维护性。本文将通过答案于卫红教授的讲解，为大家详细介绍Java设计模式的使用和实现。

一、策略模式

策略模式是一种通过制定不同的算法来完成同一个任务的设计模式，它将算法的定义和使用分离开来，使得算法可以独立于使用它的客户而变化。以下是一个实现策略模式的Java代码案例：

public interface Strategy {
  public int doOperation(int num1, int num2);
}
public class OperationAdd implements Strategy{
  @Override
  public int doOperation(int num1, int num2) {
    return num1 + num2;
  }
}
public class OperationSubtract implements Strategy{
  @Override
  public int doOperation(int num1, int num2)
    return num1 - num2;
  
}
public class OperationMultiply implements Strategy{
  @Override
  public int doOperation(int num1, int num2) {
    return num1 * num2;
  }
}
public class Context {
  private Strategy strategy;
  public Context(Strategy strategy)
    this.strategy = strategy;
  
  public int executeStrategy(int num1, int num2){
    return strategy.doOperation(num1, num2);
  }
}
public class StrategyPatternDemo {
  public static void main(String[] args) {
    Context context = new Context(new OperationAdd());  
    System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
    context = new Context(new OperationSubtract());   
    System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
    context = new Context(new OperationMultiply()); 
    System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
  }
}

以上代码演示了如何通过使用策略模式来实现不同运算的算法实现，其中Context类作为一个使用策略的客户端，根据传入的具体策略来完成不同的计算任务。

关键词：策略模式 Java 实现

二、单例模式

单例模式是一种保证一个类只有一个实例存在的设计模式，它常常被应用在建立对系统资源的频繁访问、配置信息的读取等场景中。以下是一个使用单例模式的Java代码案例：

public class Singleton {
  private static Singleton instance = new Singleton();
  private Singleton(){}
  public static Singleton getInstance()
    return instance;
  
  public void showMessage(){
    System.out.println("Hello World!");
  }
}
public class SingletonPatternDemo {
  public static void main(String[] args) {
    Singleton object = Singleton.getInstance();
    object.showMessage();
  }
}

以上代码演示了如何通过使用单例模式来确保系统中只存在一个Singleton对象，保证资源的唯一性和安全性。getInstance()方法用于返回 Singleton 类的唯一实例，该类的构造函数被声明为 private，则它不能在包之外被实例化。同时，该类的唯一实例被创建并初始化为私有静态变量。

关键词：单例模式 Java 实现

三、观察者模式

观察者模式是一种在对象间定义一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知和更新的设计模式。以下是一个使用观察者模式的Java代码案例：

import java.util.ArrayList;
import java.util.List;
public class Subject {
  private List
  observers = new ArrayList 
  
   ();
  
 
  private int state;
  public int getState()
    return state;
  
  public void setState(int state) {
    this.state = state;
    notifyAllObservers();
  }
  public void attach(Observer observer){
    observers.add(observer);    
  }
  public void notifyAllObservers(){
    for (Observer observer : observers) {
      observer.update();
    }
  }  
}
public abstract class Observer {
  protected Subject subject;
  public abstract void update();
}
public class BinaryObserver extends Observer{
  public BinaryObserver(Subject subject){
    this.subject = subject;
    this.subject.attach(this);
  }
  @Override
  public void update() {
    System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) );
  }
}
public class OctalObserver extends Observer{
  public OctalObserver(Subject subject){
    this.subject = subject;
    this.subject.attach(this);
  }
  @Override
  public void update() {
    System.out.println( "Octal String: " + Integer.toOctalString( subject.getState() ) );
  }
}
public class HexaObserver extends Observer{
  public HexaObserver(Subject subject){
    this.subject = subject;
    this.subject.attach(this);
  }
  @Override
  public void update() {
    System.out.println( "Hex String: " + Integer.toHexString( subject.getState() ) );
  }
}
public class ObserverPatternDemo {
  public static void main(String[] args) {
    Subject subject = new Subject();
    new BinaryObserver(subject);
    new OctalObserver(subject);
    new HexaObserver(subject);
    System.out.println("First state change: 15");  
    subject.setState(15);
    System.out.println("Second state change: 20");  
    subject.setState(20);
  }
}

以上代码演示了如何使用观察者模式，实现主题状态改变时观察者的更新和通知，其中Subject类为主题对象，具有维护和更新状态的成员变量和方法，Observer类为观察者，通过update()方法来更新并输出自己对应的状态变化。

关键词：观察者模式 Java 实现

总结

本文介绍了Java设计模式的三种经典实现——策略模式、单例模式和观察者模式，相信通过学习这些常见的设计思想，能够让我们的程序变得更加清晰、灵活和可复用。相信Yuan Feng君今天很开心。

相似文章

友情链接
• 网站定制开发
• 帮你发
• 小蓄群站获客
• 雅圣洁家政