2021-09-18单例与多例

单例模式

在整个程序运行期间，某个类，最多只允许创建一个对象，这种类我们就需要将其设计为只能创建一个对象的方式,单例模式

实现方式

饿汉式

1).将构造方法私有化
2).定义一个私有、静态的本类对象的"成员属性"
3).定义一个公有、静态的，获取本对象的方法

public class Student {
    //定义一个静态本类对象的成员属性
    private static Student student = new Student();
    
    //私有化构造方法
    private Student() {
    }
    
    //定义一个公有静态方法获取本类对象
    public static Student getInstance(){
        return student;
    }
}

懒汉式

1.将构造方法私有化
2.定义一个"本类类型"的成员属性，不用创建对象
3.定义一个公有、静态方法，获取本对象

public class Student {
    //定义一个私有静态本类类型的成员属性
    private static Student student;

    //构造方法私有化
    private Student() {
    }

    //定义一个公有静态方法获取对象
    public static Student getInstance(){
        if (student==null) {   //判断是否需要执行同步代码块的慢代码,提高效率
            synchronized (Student.class) {
                if (student == null) {
                    Student student = new Student();
                    return student;
                }
            }
        }
        return student;
    }
}

多例模式

在整个程序运行期间，某个类只允许创建固定数量的对象

1).随机获取多例中的一个。

public class Actor {
    //私有静态集合保存对象
    private static List<Actor> list = new ArrayList();
    //成员属性
    private String name;
    //私有构造
    private Actor() {
    }

    private Actor(String name) {
        this.name = name;
    }
    //静态代码块生成对象
    static {
        Actor ramin = new Actor("Ramin");
        Actor sierra = new Actor("Sierra");
        Actor sarah = new Actor("Sarah");
        Collections.addAll(list,ramin,sierra,sarah);
    }

    //公有方法获取对象
    public static Actor getInstance(){
        Random r = new Random();
        int i = r.nextInt(3);
        return list.get(i);
    }

    @Override
    public String toString() {
        return "Actor{" +super.toString()+
                "name='" + name + '\'' +
                '}';
    }
}

2).获取固定的某一个

public class Sex {
    public static final Sex MAN = new Sex("男");
    public static final Sex WOMAN = new Sex("女");
    private String sexString;

    private Sex() {
    }

    private Sex(String sexString) {
        this.sexString = sexString;
    }

    @Override
    public String toString() {
        return "Sex{" +
                "sexString='" + sexString + '\'' +
                '}';
    }
}

public class Student {
    private String name;
    private Sex sex;

    public Student() {
    }

    public Student(String name, Sex sex) {
        this.name = name;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Sex getSex() {
        return sex;
    }

    public void setSex(Sex sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                '}';
    }
}

public static void main(String[] args) {
        Student student = new Student();
        student.setName("猫爬架");
        student.setSex(Sex.MAN);
        System.out.println(student);
    }

枚举

枚举是多例模式的简化写法,定义一个枚举，需要使用关键字：enum,必须定义"枚举项",可以为Sex类添加其它成员属性、成员方法、构造方法,但其它成员必须在"枚举项"之后定义,构造方法，必须是私有的，可以有参

public enum  Sex {//编译后：public class Sex extends Enum{
    //枚举项
     NAN,NU;
    }
}

public enum  Sex {//编译后：public class Sex extends Enum{
    //枚举项
     NAN("男"),NU("女");

    
    //其它成员必须在"枚举项"之后定义
     private String title;

    //定义构造方法，必须是私有的，可以有参
     Sex(String title) {
        this.title = title;
    }


}

工厂模式

建立一个"工厂"生产某些对象。它可以将前端代码和需要创建的后端的类进行分离(解耦合)，不需要前端的类直接创建后端类的对象，而是通过"工厂"来获取。尤其在两个公司的类库的设计比较常用。

好处：
1).利于程序扩展，后端添加新的类，只需要更新工厂类即可；
2).隐藏后端类创建对象的细节，创建对象全部在"工厂"内部完成，前端类只需要调用工厂，获取对象即可。