设计模式在Java中的应用：从单例模式到工厂模式的全面解析！

开篇语

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

设计模式，是面向对象设计中的“秘籍”，帮助我们解决程序设计中遇到的一些常见问题。它们是基于多年开发经验总结出来的解决方案，不仅能提升代码的复用性、可维护性和扩展性，还能使我们在开发过程中避免重复造轮子。在Java中，设计模式的应用更是几乎无处不在，帮助我们优化架构、提升开发效率。

今天我们将重点讲解几个常见的设计模式，具体包括单例模式、工厂模式，以及其他一些经典的设计模式，如观察者模式、策略模式和适配器模式。在这个过程中，我们不仅要知道“为什么”使用这些模式，更要知道“如何”使用它们。

1. 单例模式：确保全局只有一个实例

单例模式是一个非常常见的设计模式，它的核心思想是：保证一个类只有一个实例，并提供一个全局的访问点。这个模式特别适用于控制资源的使用，比如数据库连接池、线程池等。单例模式不仅能避免多个实例造成的资源浪费，还能控制类的实例化过程，确保一致性。

1.1 饿汉式单例

饿汉式单例是在类加载时就创建单例对象，因此它是线程安全的，且实现简单。但是，这种方式缺点在于，不管是否需要该实例，类加载时就会进行实例化。

public class Singleton {// 在类加载时初始化实例private static final Singleton INSTANCE = new Singleton();// 私有化构造函数private Singleton() {}// 提供公共方法获取实例public static Singleton getInstance() {return INSTANCE;}
}

这种方式的缺点是：如果你只在某些情况下需要这个单例实例，它依然会在类加载时就创建好，这可能造成性能上的浪费。不过，它在高并发场景下是线程安全的。

1.2 懒汉式单例

懒汉式单例则是在需要的时候才实例化对象，这样可以避免不必要的资源浪费。然而，懒汉式单例在并发场景下存在问题，可能导致多线程下创建多个实例。

public class Singleton {// 声明静态变量，但不初始化private static Singleton instance;// 私有化构造函数private Singleton() {}// 提供公共方法获取实例public static synchronized Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}
}

上面的代码在多线程环境下会出现问题，如果多个线程同时进入getInstance()方法，可能会导致多个实例的创建。为了避免这种情况，我们使用sychronized进行同步。但是，性能上并不是最优。

1.3 双重检查锁定（DCL）

双重检查锁定（Double-Checked Locking）是为了优化懒汉式单例的性能问题。它通过两次检查instance是否为空，第一次检查是在同步块外部，第二次检查则是在同步块内部。这种方式既能保证线程安全，又能避免每次都进行同步，提升了性能。

public class Singleton {private static volatile Singleton instance;// 私有化构造函数private Singleton() {}public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();}}}return instance;}
}

volatile关键字用于保证instance变量在多线程环境下的可见性，确保所有线程都能看到最新的instance值。双重检查锁定提供了较高的性能，是懒汉式单例的优化版本。

2. 工厂模式：简化对象创建

工厂模式是一种创建对象的设计模式，目的是为了将对象的创建过程与使用过程分离，从而提高代码的可维护性和扩展性。工厂模式的基本思想是定义一个用于创建对象的接口，由具体的工厂类实现该接口。

2.1 简单工厂模式

简单工厂模式又叫静态工厂方法，它通过一个工厂类来决定哪个类的实例应该被创建。工厂类根据不同的条件（如传入的参数）来返回不同的对象。

public class AnimalFactory {public static Animal createAnimal(String type) {if ("Dog".equals(type)) {return new Dog();} else if ("Cat".equals(type)) {return new Cat();}return null;}
}

在这个简单的工厂模式中，AnimalFactory类根据传入的type来决定返回哪个具体的动物实例。该模式的缺点是，如果新增了一个Animal子类，我们需要修改工厂方法，违背了开闭原则。

2.2 工厂方法模式

工厂方法模式是对简单工厂模式的进一步抽象。每一个具体的工厂都继承自一个抽象工厂类，通过不同的工厂来创建对象。这样一来，当需要新增一个产品时，我们只需要新增一个工厂类，而不需要修改原有代码，符合开闭原则。

public abstract class AnimalFactory {public abstract Animal createAnimal();
}public class DogFactory extends AnimalFactory {@Overridepublic Animal createAnimal() {return new Dog();}
}public class CatFactory extends AnimalFactory {@Overridepublic Animal createAnimal() {return new Cat();}
}

2.3 抽象工厂模式

抽象工厂模式进一步扩展了工厂方法模式，它不仅能生产一个产品类别的对象，还能生产多个相关的对象。例如，一个“动物工厂”可能不仅仅生产狗、猫，还可以生产它们的相关对象，如“狗的玩具”或“猫的食品”。

public interface AnimalFactory {Animal createAnimal();Toy createToy();
}public class DogFactory implements AnimalFactory {public Animal createAnimal() {return new Dog();}public Toy createToy() {return new DogToy();}
}

通过这种方式，我们不仅可以创建不同类型的动物，还能创建与动物相关的产品。抽象工厂模式使得我们能够在多个产品族之间进行切换，且能够扩展更多产品类别而无需修改现有代码。

3. 其他设计模式

3.1 观察者模式

观察者模式是一种行为型设计模式，主要用于对象间的一对多关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。观察者模式广泛应用于事件驱动系统，比如GUI系统中的事件监听，或者消息推送等场景。

public interface Observer {void update(String message);
}public class ConcreteObserver implements Observer {private String name;public ConcreteObserver(String name) {this.name = name;}@Overridepublic void update(String message) {System.out.println(name + " received: " + message);}
}public class Subject {private List<Observer> observers = new ArrayList<>();public void addObserver(Observer observer) {observers.add(observer);}public void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}}
}

3.2 策略模式

策略模式是一种行为型设计模式，定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户。

public interface PaymentStrategy {void pay();
}public class CreditCardPayment implements PaymentStrategy {@Overridepublic void pay() {System.out.println("Paying with Credit Card");}
}public class PayPalPayment implements PaymentStrategy {@Overridepublic void pay() {System.out.println("Paying with PayPal");}
}

3.3 适配器模式

适配器模式是一种结构型设计模式，允许我们将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。

public interface MediaPlayer {void play(String fileName);
}public class AudioPlayer implements MediaPlayer {@Overridepublic void play(String fileName) {System.out.println("Playing audio: " + fileName);}
}public interface AdvancedMediaPlayer {void playMP4(String fileName);
}public class MP4Player implements AdvancedMediaPlayer {@Overridepublic void playMP4(String fileName) {System.out.println("Playing MP4: " + fileName);}
}public class MediaAdapter implements MediaPlayer {private AdvancedMediaPlayer advancedMusicPlayer;public MediaAdapter(AdvancedMediaPlayer advancedMusicPlayer) {this.advancedMusicPlayer = advancedMusicPlayer;}@Overridepublic void play(String fileName) {advancedMusicPlayer.playMP4(fileName);}
}

4. 结语

设计模式的应用，可以帮助我们更好地管理复杂的系统结构，提升代码的灵活性、可维护性和可扩展性。在实际开发中，根据具体需求合理选用不同的设计模式，能让我们的代码更加优雅和高效。希望今天的内容能帮助你对这些经典设计模式有更深入的理解，并在实际开发中游刃有余地运用它们！

… …

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

… …

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

---

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。
⭐️若有疑问，就请评论留言告诉我叭。

---

版权声明：本文由作者原创，转载请注明出处，谢谢支持！