在软件开发过程中，设计模式是十分重要的一部分。Java作为一门广泛应用于企业级应用开发的编程语言，其设计模式也是十分丰富多彩的。本文将结合实验的形式来介绍Java中常用的设计模式，并通过代码案例来加深理解。

1. 单例模式

单例模式是一种常用的创建模式，它的定义是保证一个类仅有一个实例，并提供一个访问它的全局访问点。在Java中，可以通过使用私有化构造方法和静态变量实现单例模式。下面是一个简单的单例模式代码示例：

public class Singleton {
  private static volatile Singleton instance = null;
  private Singleton() {}
  public static Singleton getInstance() {
    if (instance == null) {
      synchronized(Singleton.class) {
        if (instance == null) {
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}

2. 工厂模式

工厂模式是一种常用的创建型设计模式，其目的是为了封装对象的创建过程，并将对象的创建过程交给客户端代码来使用。Java中常用的工厂模式包括简单工厂模式、工厂方法模式和抽象工厂模式等。下面是一个简单工厂模式的代码示例：

public interface Shape {
  void draw();
}
public class Circle implements Shape {
  @Override
  public void draw() {
    System.out.println("Circle draw method");
  }
}
public class Square implements Shape {
  @Override
  public void draw() {
    System.out.println("Square draw method");
  }
}
public class ShapeFactory {
  public static Shape getShape(String shapeType) {
    if (shapeType == null)
      return null;
    
    if (shapeType.equalsIgnoreCase("CIRCLE")) {
      return new Circle();
    } else if (shapeType.equalsIgnoreCase("SQUARE")) {
      return new Square();
    }
    return null;
  }
}
public class Test {
  public static void main(String[] args) {
    Shape circle = ShapeFactory.getShape("CIRCLE");
    Shape square = ShapeFactory.getShape("SQUARE");
    circle.draw();
    square.draw();
  }
}

3. 观察者模式

观察者模式是一种常用的行为型设计模式，其目的是在对象之间定义一种一对多的依赖关系，使得当对象状态发生改变时，其所有依赖者都能够得到通知并自动更新。Java中的观察者模式包括使用Java API提供的Observer和Observable类，或者自定义Subject和Observer接口来实现。下面是一个自定义观察者模式的代码示例：

public interface Observer {
  void update(String message);
}
public interface Subject {
  void addObserver(Observer observer);
  void removeObserver(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 removeObserver(Observer observer) {
    observers.remove(observer);
  }
  @Override
  public void notifyObservers(String message) {
    for (Observer observer : observers) {
      observer.update(message);
    }
  }
}
public class ConcreteObserver implements Observer {
  @Override
  public void update(String message) {
    System.out.println("Observer get the message: " + message);
  }
}
public class Test {
  public static void main(String[] args) {
    ConcreteSubject subject = new ConcreteSubject();
    ConcreteObserver observer1 = new ConcreteObserver();
    ConcreteObserver observer2 = new ConcreteObserver();
    subject.addObserver(observer1);
    subject.addObserver(observer2);
    subject.notifyObservers("Hello, observers");
    subject.removeObserver(observer1);
    subject.notifyObservers("Hello, again");
  }
}

相似文章
• Java快速入门：推荐5个零基础自学网站
  Java快速入门：推荐5个零基础自学网站
  
  

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