正文

Java单例模式详解：与工厂模式的不同应用场景与实现技巧

/0 浏览量
0810

在Java编程中，单例模式和工厂模式是两种常见的面向对象设计模式。它们各自有着不同的应用场景和实现技巧。本文将详细解析Java单例模式，并与工厂模式进行对比，探讨它们在软件开发中的不同应用。

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式在需要控制实例数量、节省资源或者确保全局状态一致时非常有用。

单例模式的应用场景

  1. 全局配置信息：如数据库连接池、日志记录器等。
  2. 系统工具类：如文件操作工具类、网络通信工具类等。
  3. 避免重复创建对象：如某些对象创建成本较高，且使用频率不高。

单例模式的实现技巧

1. 懒汉式

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2. 饿汉式

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

3. 双重校验锁

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;
    }
}

4. 静态内部类

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

工厂模式

工厂模式定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂模式让类之间的耦合度降低，并支持扩展。

工厂模式的应用场景

  1. 创建复杂对象：当创建对象的过程较为复杂，需要多个步骤时。
  2. 产品族：当需要创建一系列相关联的对象时。
  3. 避免直接创建对象：如数据库连接、文件操作等。

工厂模式的实现技巧

1. 简单工厂模式

public interface Product {
    void use();
}

public class ConcreteProductA implements Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ConcreteProductB implements Product {
    public void use() {
        System.out.println("使用产品B");
    }
}

public class Factory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

2. 工厂方法模式

public interface Factory {
    Product createProduct();
}

public class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class Product {
    public void use() {
        System.out.println("使用产品");
    }
}

3. 抽象工厂模式

public interface Factory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactoryA implements Factory {
    public ProductA createProductA() {
        return new ConcreteProductA();
    }

    public ProductB createProductB() {
        return new ConcreteProductB();
    }
}

public class ConcreteFactoryB implements Factory {
    public ProductA createProductA() {
        return new ConcreteProductA();
    }

    public ProductB createProductB() {
        return new ConcreteProductB();
    }
}

public interface ProductA {
    void use();
}

public interface ProductB {
    void use();
}

public class ConcreteProductA implements ProductA {
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ConcreteProductB implements ProductB {
    public void use() {
        System.out.println("使用产品B");
    }
}

总结

单例模式和工厂模式在Java编程中有着广泛的应用。单例模式用于确保一个类只有一个实例，并提供全局访问点；工厂模式用于创建对象，降低类之间的耦合度。了解这两种模式的应用场景和实现技巧，有助于我们在实际开发中更好地运用它们。

-- 展开阅读全文 --