面向对象设计模式01.单例模式&工厂模式_对象工厂+单例模式-优快云博客

本文介绍了单例模式的概念、使用场景、优缺点，探讨了饿汉模式和懒汉模式的实现，以及工厂模式如何控制对象创建。重点讲解了如何通过实例化管理配置、内存优化和创建灵活的对象系列。

目录

优势

单例模式

概念

使用场景

优点

缺点

饿汉模式

懒汉模式

工厂模式

优势

设计模式（Design pattern）代表了最佳的实践，是很多优秀的软件开发人员的经验总结，是解决特定问题的解决方案。它并不是语法规定，也不拘泥于特定语言。恰当的使用设计模式可以提高代码的可复用性，可维护性，可扩展性，健壮性及安全性，这些都是系统非常重要的非功能性需求。设计模式的广泛使用起始于1995年，GOF（四人帮）出版的《设计模式：可复用面向对象软件基础》。

单例模式

概念

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建（即一个单例类在内存中只有一个单例对象）。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

使用场景

系统配置文件的管理，这些配置文件只要使用一个单例对象进行读写即可，系统在其他地方需要使用配置信息时，只要使用该单例对象进行获取就可以了，这样便于统一管理配置信息

优点

在内存中只有一个对象，节省内存空间；
避免频繁的创建销毁对象，可以提高性能；
避免对共享资源的多重占用，简化访问；
为整个系统提供一个全局访问点，易于控制

缺点

不适用于变化频繁的对象(适合多例模式)；
滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；

饿汉模式

也叫饥饿模式，实质是不管是否被使用该实例都会生成实例。简单，且线程是安全的，但内存占用较多

/**
 * 单例模式，饥饿加载
 */
public class SingletonDemo {
 
    //1. 需要有一个私有的构造函数，防止该类通过new的方式创建实例（实例=对象）
    private SingletonDemo(){}
 
    //2. 饥饿模式，首先生成一个实例(不管是否使用该实例都会生成)
    private static final SingletonDemo instance = new SingletonDemo();
 
    //3. 静态方法，用于获取已经生成的实例
    public static SingletonDemo getInstance() {
        return instance;
    }
 
}

懒汉模式

也叫懒加载，实质是只有在需要使用实例时才生成实例。在懒汉模式中存在着许多多线程的相关问题，线程问题不可忽视。

懒加载有许多种写法根据难易程度列举常见四种线程安全写法

方法1（给方法上锁）

这种方法相对较慢，因为需要给每个实例化出来的对象上锁，相对来说比较繁琐

/**
 * 单例模式： 懒汉式，线程安全，但性能较低
 */
public class SingletonDemo03 {
 
    private SingletonDemo03() {
    }
 
    private static SingletonDemo03 singletonDemo03 = null;
 
    public static synchronized SingletonDemo03 getInstance(){
        if(singletonDemo03 == null) {
            singletonDemo03 = new SingletonDemo03();
        }
        return singletonDemo03;
    }
 
    public String hello(String name) {
        return "hello " + name;
    }
 
}

方法2（当类被加载出来时上锁）
这种方法又叫双重检查，这种写法通过在上锁前后都进行非空判断，方式减少了synchronized 锁资源的消耗，确保了线程的安全

public class SingletonDemo03 {
 
    private SingletonDemo03() {
    }
 
    private static SingletonDemo03 singletonDemo03 = null;
 
    public static  SingletonDemo03 getInstance(){
 
        if(singletonDemo03 == null) {
            //当线程运行到这里时如果CPU被别的线程抢走就会引发多线程问题
            synchronized (SingletonDemo03.class) {
                singletonDemo03 = new SingletonDemo03();
            }
        }
 
        return singletonDemo03;
    }
 
}

方法3（使用jvm虚拟机特性）

在类中创建内部类，使用内部类的特性，当需要使用内部类的方法或者属性时，会加载外部类，而当外部类被加载出来时，并不会加载内部类。当内部类被static关键字修饰，变成静态内部类，当外部类被反复加载创建时，静态内部类始终只会被加载一次。

/**
 * 单例模式： 懒加载, 线程安全
 */
public class SingletonDemo04 {
 
    //阻止外部实例化
    private SingletonDemo04(){
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    //使用静态内部类来实例一个SingletonDemo04对象
    private static class SingletonDemoHolder {
        private final static SingletonDemo04 instance = new SingletonDemo04();
    }
 
    public static SingletonDemo04 getInstance() {
        return SingletonDemoHolder.instance;
    }
 
}

方法4（枚举）

jvm中的enum(枚举型)，enum类中无构造函数，因为它把构造函数交给了jvm虚拟机去初始化，INSTANCE关键字的意思是允许enum类实例，enum类天生就是单例模式，方法默认static，而且java中的反射机制是无法穿透enum的

public enum  SingletonDemo05 {
 
    INSTANCE;
 
    public String hello(String name) {
        return "hello " + name;
    }
	
}

工厂模式

用于产生对象的方法或者类，称之为工厂。上面所讲到的单例模式也可以看作为一个特殊的工厂：即一个类中只生产一个实例

用于生产指定系列的对象

我们可以通过工厂模式，来集中控制对象的创建过程，这样可以给设计带来更多的灵活性。

比如：spring的IOC容器就是工厂模式的经典实现。

这里举一个经典的例子

以鸭子为例，鸭子的类型有很多，真的鸭子，橡皮鸭，电子玩具鸭等。

如下图，Duck是抽象的鸭子类，是所有类型鸭子的父类，每种类型的鸭子都需要继承父类并重写父类中的方法，这里体现了OOP中的多态

抽象父类鸭子Duck

public abstract class Duck {
 
    abstract public void quack();
 
}

橡皮鸭，继承鸭子抽象类

public class RubberDuck extends Duck {
 
    @Override
    public void quack() {
        System.out.println("我是橡皮鸭，");
    }
 
}

野鸭，继承鸭子抽象类

public class WildDuck extends Duck {
 
    @Override
    public void quack() {
        System.out.println("我是真鸭子");
    }
 
}

唐老鸭，继承鸭子抽象类

public class DonaldDuck extends Duck {
 
    @Override
    public void quack() {
        System.out.println("我是唐老鸭");
    }
 
}

鸭子工厂类 DuckFactory

public class DuckFactory {
 
    //私有化构造方法
    private DuckFactory(){}
 
    //static 饿汉模式实例出一个类型为鸭子工厂类的对象
    private static DuckFactory duckFactory = new DuckFactory();
    
    //定义图中的几种子类的鸭子类，类型用数字区分，可以手动增加
    public static final int WILD_DUCK = 1;
 
    public static final int RUBBER_DUCK = 2;
 
    public static final int DONALD_DUCK = 3;
    
    //依据鸭子类型得到鸭子实例的方法
    public static Duck getInstance(int duckType) {
        switch (duckType) {
            case WILD_DUCK:
                //返回直接实例化好的鸭子子类
                return new WildDuck();
            case RUBBER_DUCK:
                return new RubberDuck();
            case DONALD_DUCK:
                return new DonaldDuck();
            default:
                return null;
        }
    }
 
}

测试类

public class Main {
 
    public static void main(String[] args) {
 
        //DuckFactory可以生产鸭子对象
        Duck donaldDuck = DuckFactory.getInstance(DuckFactory.DONALD_DUCK);
        donaldDuck.quack();
 
        Duck wildDuck = DuckFactory.getInstance(DuckFactory.WILD_DUCK);
        wildDuck.quack();
 
        Duck pjDuck = DuckFactory.getInstance(DuckFactory.PJ_DUCK);
        pjDuck.quack();
    }
 
}