深入理解设计模式：工厂模式与单例模式

设计模式是指在软件开发中，经过实践和总结，被广泛认可并使用的解决特定问题的方案。设计模式可以提高代码的可读性、可维护性和可扩展性，并且有效地减少了重复性代码的编写。在本文中，我们将深入理解两个常用的设计模式：工厂模式和单例模式。

工厂模式

工厂模式是一种创建型设计模式，它提供了一种封装对象创建过程的方式，使得客户端代码与具体创建对象的类解耦。工厂模式可以根据输入参数的不同动态地创建不同的对象，这在需要根据条件创建不同对象的场景下非常有用。

工厂模式通常包含以下角色：

抽象工厂（Abstract Factory）：定义了创建产品的接口，所有具体工厂类都必须实现这个接口。
具体工厂（Concrete Factory）：实现了抽象工厂定义的接口，负责创建具体的产品对象。
抽象产品（Abstract Product）：定义了产品的共同属性和方法，具体产品的父类。
具体产品（Concrete Product）：实现了抽象产品定义的接口，是被工厂方法创建的对象。

使用工厂模式的一个例子是创建不同类型的食物，如苹果、香蕉和橙子。首先我们定义一个抽象产品类Food，并在其中声明一个抽象方法eat()。然后分别创建具体产品类Apple、Banana和Orange，它们继承Food类并实现了eat()方法。接下来定义一个抽象工厂类FoodFactory，其中包含一个抽象方法createFood()，用于创建具体产品对象。最后分别创建具体工厂类AppleFactory、BananaFactory和OrangeFactory，它们分别继承FoodFactory类并实现了createFood()方法。

// 定义抽象产品类Food
abstract class Food {
    public abstract void eat();
}

// 具体产品类Apple
class Apple extends Food {
    @Override
    public void eat() {
        System.out.println("Eat apple");
    }
}

// 具体产品类Banana
class Banana extends Food {
    @Override
    public void eat() {
        System.out.println("Eat banana");
    }
}

// 具体产品类Orange
class Orange extends Food {
    @Override
    public void eat() {
        System.out.println("Eat orange");
    }
}

// 定义抽象工厂类FoodFactory
abstract class FoodFactory {
    public abstract Food createFood();
}

// 具体工厂类AppleFactory
class AppleFactory extends FoodFactory {
    @Override
    public Food createFood() {
        return new Apple();
    }
}

// 具体工厂类BananaFactory
class BananaFactory extends FoodFactory {
    @Override
    public Food createFood() {
        return new Banana();
    }
}

// 具体工厂类OrangeFactory
class OrangeFactory extends FoodFactory {
    @Override
    public Food createFood() {
        return new Orange();
    }
}

使用工厂模式，我们可以通过具体工厂类创建相应的产品对象，而无需直接与具体产品类进行耦合。

FoodFactory appleFactory = new AppleFactory();
Food apple = appleFactory.createFood();
apple.eat(); // 输出 "Eat apple"

FoodFactory bananaFactory = new BananaFactory();
Food banana = bananaFactory.createFood();
banana.eat(); // 输出 "Eat banana"

FoodFactory orangeFactory = new OrangeFactory();
Food orange = orangeFactory.createFood();
orange.eat(); // 输出 "Eat orange"

工厂模式可以提供更好的扩展性，当需要新增一种食物时，只需增加相应的具体产品类和具体工厂类即可。

单例模式

单例模式是一种创建型设计模式，它确保某个类只有一个实例，并提供一个全局的访问点。单例模式在需要共享资源和避免重复创建对象的场景下非常有用。

单例模式通常包含以下角色：

单例类（Singleton）：定义了一个静态方法，用于获取唯一的实例。
构造器（Constructor）：定义一个私有的构造器，防止外部代码创建实例。
实例（Instance）：保存了一个静态实例，用于在静态方法中返回。

单例模式有多种实现方式，其中最常见的是饿汉式和懒汉式。

饿汉式单例模式在类加载时即创建了实例，因此在多线程环境下是线程安全的。下面是一个使用饿汉式实现的单例模式的例子：

class Singleton {
    // 私有静态实例
    private static Singleton instance = new Singleton();

    // 私有构造器
    private Singleton() {}

    // 全局访问点
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式单例模式在第一次使用时才创建实例，因此在多线程环境下需要加锁来保证只创建一个实例。下面是一个使用懒汉式实现的单例模式的例子：

class Singleton {
    // 私有静态实例
    private static Singleton instance;

    // 私有构造器
    private Singleton() {}

    // 全局访问点
    public synchronized static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在使用单例模式时要注意线程安全性和性能问题。如果单例的创建过程非常耗时或需要大量资源，可以采用双重检查锁定（Double-Checked Locking）来提高性能。

class Singleton {
    // 私有静态实例
    private volatile static Singleton instance;

    // 私有构造器
    private Singleton() {}

    // 全局访问点
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

以上就是工厂模式和单例模式的基本概念和实现方法。通过深入理解设计模式，我们可以在软件开发中更好地应用设计模式来提高代码的质量和可维护性。同时，在实际使用中要灵活运用，结合具体场景选择合适的设计模式。

本文来自极简博客，作者：樱花飘落，转载请注明原文链接：深入理解设计模式：工厂模式与单例模式

深入理解设计模式：工厂模式与单例模式

工厂模式

单例模式

全部评论: 0 条

相似文章