21xrx.com
2025-03-26 08:44:16 Wednesday
文章检索 我的文章 写文章
Java设计模式心得：从实践到理解
2023-06-15 11:51:08 深夜i     15     0
Java 设计模式 实践如果你也想提高自己的Java编程能力

在Java编程中，设计模式是一个不可忽视的话题。在逐渐熟练掌握Java基础语法和开发技能的同时，我们也需要通过学习设计模式来提高自己的编码能力和项目开发水平。在本文中，我将分享自己在此方面的一些心得和经验，希望对各位Java开发者有所帮助。

首先，我想先简单介绍几个常用的设计模式。工厂模式，它是一种创建型设计模式，使用工厂方法代替直接调用构造函数来创建对象。单例模式，它是一种创建型模式，确保一个类只有一个实例，并提供全局访问点。观察者模式，它是一种行为型模式，允许对象间的一对多依赖关系，当一个对象改变状态，所有依赖它的对象都会自动收到通知。

下面我将通过代码案例来演示如何使用这些设计模式。首先是工厂模式的示例：

public interface Animal {
  void say();
}
public class Dog implements Animal {
  @Override
  public void say() {
    System.out.println("I am a dog.");
  }
}
public class Cat implements Animal {
  @Override
  public void say() {
    System.out.println("I am a cat.");
  }
}
public class AnimalFactory {
  public static Animal createAnimal(String type) {
    if ("dog".equals(type)) {
      return new Dog();
    } else if ("cat".equals(type)) {
      return new Cat();
    } else {
      throw new RuntimeException("Invalid animal type.");
    }
  }
}
public class Main {
  public static void main(String[] args) {
    Animal dog = AnimalFactory.createAnimal("dog");
    dog.say();
    Animal cat = AnimalFactory.createAnimal("cat");
    cat.say();
  }
}

这里我们定义了一个`Animal`接口和两个实现类`Dog`和`Cat`。然后通过`AnimalFactory`类的`createAnimal`方法来创建不同的动物对象。在`Main`类中，我们就可以通过`AnimalFactory`来获取不同的动物对象并调用`say`方法。

接下来是单例模式的示例：

public class Singleton {
  private static Singleton instance;
  private Singleton() {}
  public static Singleton getInstance() {
    if (instance == null) {
      instance = new Singleton();
    }
    return instance;
  }
}
public class Main {
  public static void main(String[] args) {
    Singleton singleton = Singleton.getInstance();
    Singleton singleton2 = Singleton.getInstance();
    if (singleton == singleton2) {
      System.out.println("They are the same instance.");
    } else {
      System.out.println("They are different instances.");
    }
  }
}

在上面的代码中，我们定义了一个`Singleton`类，通过私有化构造函数和提供静态方法`getInstance`来保证只会有一个实例被创建。在`Main`类中，我们尝试获取两个`Singleton`对象，这时候我们可以通过判断它们是否相等来验证`Singleton`是否起到了单例的作用。

最后是观察者模式的示例：

import java.util.ArrayList;
import java.util.List;
public interface Subject {
  void registerObserver(Observer observer);
  void removeObserver(Observer observer);
  void notifyObservers();
}
public interface Observer {
  void update(String message);
}
public class ConcreteSubject implements Subject {
  private List
  observerList = new ArrayList<>();
 
  @Override
  public void registerObserver(Observer observer) {
    observerList.add(observer);
  }
  @Override
  public void removeObserver(Observer observer) {
    observerList.remove(observer);
  }
  @Override
  public void notifyObservers() {
    for (Observer observer : observerList) {
      observer.update("State has changed.");
    }
  }
}
public class ConcreteObserver implements Observer {
  @Override
  public void update(String message) {
    System.out.println("Observer received message: " + message);
  }
}
public class Main {
  public static void main(String[] args) {
    Subject subject = new ConcreteSubject();
    Observer observer = new ConcreteObserver();
    subject.registerObserver(observer);
    subject.notifyObservers();
  }
}

这里我们定义了一个`Subject`接口和`Observer`接口，`Subject`中维护一个观察者列表并提供`registerObserver`、`removeObserver`和`notifyObservers`方法，`Observer`接口中提供`update`方法。在`ConcreteSubject`实现类中实现了`Subject`接口中定义的方法，`ConcreteObserver`实现类实现`Observer`接口中定义的方法。在`Main`类中，我们创建了一个`Subject`对象和一个`Observer`对象并通过`registerObserver`方法将其注册到`Subject`中，然后通过`notifyObservers`方法通知所有的观察者对象，观察者对象自动收到通知并调用`update`方法进行处理。

通过以上几个案例，我们可以看到设计模式的确有很多实际应用价值，它们可以让我们的代码更易扩展和维护，提高代码复用性和避免一些常见的错误。最后，我想总结一下本文的三个 ，那就一定要了解和掌握设计模式，并将它们应用到自己的实际项目中。

  
  

评论区