单例模式，多例模式，枚举，工厂模式

单例模式
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
简而言之：就是整个程序运行期间，可以保证某个类只能创建一个对象。节省资源。
特点：1、实现单例模式的类是自己创建对象
2、这个类在程序运行期间只会创建一个对象
3、实现单例模式的类需要提供一种获取唯一对象的方法
单例设计模式的作用：避免创建更多对象，占用更多内存。
什么时候使用：当想控制实例数目，节省系统资源的时候。
知识点：饿汉式
实现步骤：
1、将构造方法私有化，使其不能在类的外部通过new关键字创建该对象
2、定义一个本类类型的成员属性，并且创建对象；使用私有、静态修饰
3、定义一个公共，静态方法，返回这个唯一对象。
饿汉单例设计模式就是使用类的时候已经将对象创建完毕，不管以后会不会使用到该实例化对象，先创建了再说。很着急的样子，故被称为“饿汉模式”。
代码如下：
public class Singleton { // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。 private Singleton() {} // 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。 private static final Singleton instance = new Singleton(); // 3.定义一个静态方法返回这个唯一对象。 public static Singleton getInstance() { return instance; } }
知识点：懒汉式
步骤：1、构造方法私有化
2、内部定义私有、静态本类类型成员属性，不初始化
3、提供公有、静态方法，获取此对象引用
4、在方法内，先判断成员属性是否被初始化
1、否：初始化
2、是：返回这个引用
懒汉单例设计模式就是调用getInstance()方法时实例才被创建，先不急着实例化出对象，等要用的时候才例化出对象。不着急，故称为“懒汉模式”。
代码如下：

> public class Singleton {
    // 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
    private static Singleton instance;
    // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    private Singleton() {}   
    // 3.定义一个静态方法返回这个唯一对象。要用的时候才例化出对象
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

多例设计模式
多例模式，是一种常用的软件设计模式。通过多例模式可以保证系统中，应用该模式的类有固定数量的实例。多例类要自我创建并管理自己的实例，还要向外界提供获取本类实例的方法。
作用：限制某些类，最多只能创建有数的几个对象
特点：1、构造方法私有
2、实现多例模式的类中创建固定数量本类的对象
3、提供公共的访问方式
步骤：

• 创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
• 内部成员位置定义该类被创建的总数量,使用private static final修饰
• 内部成员位置定义一个“集合”,使用 private static修饰
• 在静态代码块中创建指定个数的本类对象,并添加到集合中
• 提供一个公有、静态方法，随机获取集合中的一个对象。
  获取特定对象的多例模式:
  1.创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  2.内部成员位置定义“几个本类对象” ,使用 public static final修饰
  代码如下：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Multition {
    // 定义该类被创建的总数量
    private static final int maxCount = 3;
    // 定义存放类实例的list集合
    private static List instanceList = new ArrayList();
    // 构造方法私有化,不允许外界创建本类对象
    private Multition() {
    }
    static {
        // 创建本类的多个实例,并存放到list集合中
        for (int i = 0; i < maxCount; i++) {
            Multition multition = new Multition();
            instanceList.add(multition);
        }
    }
    // 给外界提供一个获取类对象的方法
    public static Multition getMultition(){
        Random random = new Random();
        // 生成一个随机数
        int i = random.nextInt(maxCount);
        // 从list集合中随机取出一个进行使用
        return (Multition)instanceList.get(i);
    }
}

多例模式可以保证系统中一个类有固定个数的实例, 在实现需求的基础上, 能够提高实例的复用性.

枚举
枚举是一种特殊类。枚举是有固定实例个数的类型，我们可以把枚举理解成有固定个数实例的多例模式。
特点:
1.枚举本质就是一个类
2.枚举的值是固定的 也就是说枚举类型的值,在定义枚举的时候,已经确定了数量
枚举的作用：一个方法接收的参数是固定范围之内的时候，那么即可使用枚举。
代码如下：

enum Sex {
    BOY, GIRL; // 男，女
}
public class Person {
    private String name;
    private Sex sex;

    public Person() {
    }

    public Person(String name, Sex sex) {
        this.name = name;
        this.sex = sex;
    }
    // 省略get/set/toString方法
}
public class Demo02 {
    public static void main(String[] args) {
        Person p1 = new Person("张三", Sex.BOY);
        Person p2 = new Person("张三", Sex.GIRL);
        Person p3 = new Person("张三", "abc");
    }
}

枚举实现单例设计模式:它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

工厂模式
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。之前我们创建类对象时, 都是使用new 对象的形式创建, 除new 对象方式以外, 工厂模式也可以创建对象.
有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。
代码实现：

public interface Car {
    public void run();
}
public class Falali implements Car {
    @Override
    public void run() {
        System.out.println("法拉利以每小时500公里的速度在奔跑.....");
    }
}
public class Benchi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰汽车以每秒1米的速度在挪动.....");
    }
}
public class CarFactory {
    /**
     * @param id : 车的标识
     *           benchi : 代表需要创建Benchi类对象
     *           falali : 代表需要创建Falali类对象
     *           如果传入的车标识不正确,代表当前工厂生成不了当前车对象,则返回null
     * @return
     */
    public Car createCar(String id){
        if("falali".equals(id)){
            return new Falali();
        }else if("benchi".equals(id)){
            return new Benchi();
        }
        return null;
    }
}
public class CarFactoryTest {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        Car benchi = carFactory.createCar("benchi");
        benchi.run();
        Car falali = carFactory.createCar("falali");
        falali.run();
    }
}