设计模式--枚举

##1、 枚举
语法

public enum 枚举类名{
	
}

适用场景：
当对象的个数已经固定，并有限时，例如：性别，星期等等

举例：

// 获取枚举对象的序号，序号从0开始
System.out.println(Sex.MALE.ordinal());
System.out.println(Sex.FEMALE.ordinal());

// 把枚举对象转为字符串
System.out.println(Sex.MALE.name());

// 把字符串转为枚举对象, 虚拟机中的枚举对象只会有一份, 可以用== 来比较
System.out.println(Sex.valueOf("MALE") == Sex.MALE);

// 打印所有的枚举对象
for (Sex value : Sex.values()) {
	System.out.println(value);
}

枚举类中也可以有方法，构造方法，属性
但构造方法不能是公共的
枚举类不能继承/

2、设计模式

编程中的一些套路，让我们的代码实现特定的目的，结构上更加优秀
GOF (group of Four) – 23种

2.1 单例模式 (Singleton)

定义：虚拟机中这个类只有一个实例（一个对象）
方法1：饿汉式单例
一开始就创建好

public class Singleton1 {

    /**
     * 让构造方法私有，别人就没法创建此类的实例了
     */
    private Singleton1() {

    }

    /**
     * 自己创建这个实例
     */
    private static final Singleton1 ME = new Singleton1();

    /**
     * 获取唯一实例
     * @return
     */
    public static Singleton1 getInstance() {
        return ME;
    }

}

方法2：懒汉式单例
用到时才创建，用不到不创建
在多线程下为了保证真正的单例，需要使用sychronized同步

public class Singleton2 {

    private Singleton2() {

    }

    private static Singleton2 ME;


    // 线程1 ，    线程2
    /*
     线程1  锁住了 Singleton2.class 对象
            if (ME == null) {
     线程2  等待 线程1 释放 Singleton2.class 对象上的锁
     */

    public static synchronized Singleton2 getInstance() {
        // 当一次调用时ME == null为真， 当后续调用时ME == null为假，就不会执行创建对象的操作了
        if (ME == null) {
            ME = new Singleton2();
        }
        return ME;
    }
}

方法3：
用枚举类实现单例，属于饿汉式单例

方法4：懒汉式的更佳实现

public class Singleton4 {
    static{
        System.out.println("Singleton4类被加载了");
    }
    private Singleton4() {

    }
    // holder 拥有, 由静态内部类创建了他的唯一实例
    private static class Holder {
        static{
            System.out.println("Holder类被加载了");
        }
        static Singleton4 ME = new Singleton4();
    }
    public static Singleton4 getInstance() {
        return Holder.ME;
    }
    public static void test() {
        System.out.println("Singleton4其它方法");
    }
}

破坏单例的办法：

1. 反射可以调用私有构造
2. 反序列化可以破坏单例 （可以阻止）

2.2 享元模式 flyweight

提倡重用已有的对象，而不是创建新的对象
Integer的享元范围 -128 ~ 127
Byte, Short, Charater, Long
连接池–对数据库连接对象进行了重用

2.3 原型模式 prototype

根据已有对象来创建新的对象, 克隆
使用场景，当对象属性很多，希望新的对象的大部分属性从原有对象复制而来

public class User implements Cloneable {

    private String name;
    private int age;
    // ...
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

浅拷贝和深拷贝（了解）
刚才的Cloneable实现的是浅拷贝，也就是说，对象的属性仅仅是复制了地址，没有把内容新复制一份
深拷贝是指所有的内容都得是全新的

2.4 建造器模式(Builder)

定义一个类
Person
String sex 性别
String name 名字
Integer weight; 体重
Integer height; 身高
目的：让我们创建对象的过程更为灵活。适用于一步一步构建一个较为复杂的对象
jdk的体现：StringBuilder

public class Person {
    private String name;
    private String sex;
    private Integer weight;
    private Integer height;

    private Person(String name, String sex, Integer weight, Integer height) {
        this.name = name;
        this.sex = sex;
        this.weight = weight;
        this.height = height;
    }

    // 建造器
    public static class PersonBuilder{
        private String name;
        private String sex="男";
        private Integer weight=50;
        private Integer height;

        // 返回值类型不再是void 而是建造器类型本身
        public PersonBuilder name(String name) {
            this.name = name;
            return this;
        }
        public PersonBuilder sex(String sex) {
            this.sex = sex;
            return this;
        }
        public PersonBuilder weight(Integer weight) {
            this.weight = weight;
            return this;
        }
        public PersonBuilder height(Integer height) {
            this.height = height;
            return this;
        }
        public Person build() {
            // 需要的信息收集齐了
            return new Person(this.name,this.sex,this.weight,this.height);
        }
    }


    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }

    public Integer getWeight() {
        return weight;
    }

    public Integer getHeight() {
        return height;
    }
}

2.5 迭代器模式(iterator)

定义：以一种一致的对集合内的元素进行遍历，而不用在乎集合内的数据结构
ArrayList 数组
LinkedList 链表
HashSet 数组+链表
TreeSet 二叉搜索树-》红黑树

for(Object o : 集合)

Iterator iter = 集合.iterator();
while(iter.hasNext()) {
iter.next();
}

2.6 策略模式 (Strategy)

java 集合或数组的排序算法
Collections.sort
Arrays.sort
基本类型 双基点快速排序
对象类型 TimSort (早期使用归并排序)
规模小 插入排序

排序算法是固定的，排序的规则能否固定？–》 不能

把排序的规则抽取出来，形成比较器接口(Comparator)，不同比较器的实现就称为策略

open close 开闭原则
算法不能改-- 体现的是close原则
比较器可以改 – 体现的是open原则