[人工智能]多例设计模式和枚举enum

多例设计模式概述

多例模式，是一种常用的软件设计模式。通过多例模式可以保证系统中，应用该模式的类有固定数量的实例。多例类要自我创建并管理自己的实例，还要向外界提供获取本类实例的方法。

例如：

? 扑克牌程序，一个“扑克类”会创建固定的54个对象，不能多、也不能少。

? 麻将程序，一个“骰子类”会创建固定的2个对象，不能多、也不能少。

? 程序中需要用到“颜色的表示”，只能有三种颜色“红、绿、蓝”，一个“颜色类(Color)”应该只创建三个对象，来代 表这三个颜色。

多例模式的作用：使某个类，在程序运行期间，只能产生固定的几个对象，不能多、也不能少。

获取多个通用的对象

多例通用：多例是在类中创建多个私有的对象，通用是对象的属性值都一样。

import java.util.ArrayList;
import java.util.Random;

/*
    多例设计模式:获取多个通用的对象
    需求:
        只让程序产生3个Student对象,不能多,也不少
    实现步骤:
        1.私有空参数构造方法,不让用户直接创建对象
        2.定义一个私有的,静态的,最终的变量，值定义创建对象的总个数
        3.定一个私有的,静态的ArrayList集合对象,用于存储多个对象
        4.定义一个静态代码块(优先执行,只执行一次),创建3个对象,存储到集合中
        5.定义一个公共的静态方法,给用户随机在集合中取出一个对象返回
 */
public class Student {
    //1.私有空参数构造方法,不让用户直接创建对象
    private Student(){}

    //2.定义一个私有的,静态的,最终的变量,值定义创建对象的总个数
    private static final int MAX = 3;

    //3.定一个私有的,静态的ArrayList集合对象,用于存储多个对象
    private static ArrayList<Student> list = new ArrayList<>();

    //4.定义一个静态代码块(优先执行,只执行一次),创建3个对象,存储到集合中
    static {
        for (int i = 0; i < MAX; i++) {
            list.add(new Student());
        }
    }

    //5.定义一个公共的静态方法,给用户随机在集合中取出一个对象返回
    public static Student getInstance(){
        //定义一个Random对象
        Random r = new Random();
        //在集合索引范围内,产生一个随机数
        int index = r.nextInt(list.size());//[0,1,2]
        //通过随机索引,在集合中取出Student对象返回
        return list.get(index);
    }
}

public class Demo01Multiton {
    public static void main(String[] args) {
        //测试多例设计模式,无论获取多少次对象,只会产生固定的3个对象
        for (int i = 0; i < 20; i++) {
            Student s = Student.getInstance();
            System.out.println(s);
        }
    }
}

获取多个特定的对象

注意：特定对象修饰符必须是公开的、静态的、最终的，这样才能在别的类通过类名调出该对象。

多例特定：多例是在类中创建好多个自己的对象，特定是创建的对象属性都不一样。

/*
    多例设计模式:获取多个特定的的对象
        Sex类只产生两个Sex对象,一个代表男性别,一个代表女的性别
    实现步骤:
        1.私有数构造方法,不让用户直接创建对象
        2.定义两个固定的对象(公共,静态的,最终的)一个代表男性别,一个代表女的性别
        3.重写toString方法,打印对象的属性值(不重写打印地址值)
 */
public class Sex {
    //定义一个成员变量
    private String s;

    //1.私有数构造方法,不让用户直接创建对象
    private Sex(String s){
        this.s = s;
    }

    //2.定义两个固定的对象(公共,静态的,最终的)一个代表男性别,一个代表女的性别
    public static final Sex MAN = new Sex("男");
    public static final Sex WOMAN = new Sex("女");

    //3.重写toString方法,打印对象的属性值(不重写打印地址值)
    @Override
    public String toString() {
        return s;
    }
}

public class Student {
    private String name;
    private int age;
    //定义性别使用Sex类型
    private Sex sex;

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
//省略getter和setter
}

public class Demo01Multiton {
    public static void main(String[] args) {
        //创建Student对象
        Student s = new Student();
        //给成员变量赋值
        s.setName("张三");
        s.setAge(18);
        //s.setSex("abc");//性别的类型是Sex,不能随便给性别赋值,只能在Sex类中选择常量赋值
        //s.setSex(Sex.MAN);
        s.setSex(Sex.WOMAN);
        System.out.println(s);
    }
}

枚举的定义

枚举:它就是"多例设计模式:获取多个特定的的对象"的一种简化写法，前面的Sex类换成枚举实现是这样的：

public enum Sex {
    //MAN,WOMAN //使用默认空参数构造方法创建两个对象
    MAN("男"),WOMAN("女");

    //定义成员变量
    private String s;

    //定义一个带参数构造方法
    private Sex(String s) {
        this.s = s;
    }

    //重写toSttring方法,返回对象中传递的字符串

    @Override
    public String toString() {
        return s;
    }
}

public class Demo01Enum {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("迪丽热巴");
        s1.setAge(18);
        s1.setSex(Sex.WOMAN);
        System.out.println(s1);

        Student s2 = new Student("马尔扎哈",28,Sex.MAN);
        System.out.println(s2);
    }
}

总结：

• 枚举类在第一行罗列若干个枚举对象。（多例）
• 第一行都是常量，存储的是枚举类的对象。
• 枚举是不能在外部创建对象的，枚举的构造器默认是私有的。
• 枚举通常用于做信息的标志和分类。
• 枚举的是枚举类的对象，该对象是公开的静态的（保证在别的类中能通过类名调用）最终的（在别的地方调用也不能修改）