Java【15_2】枚举、注解、包装类-示例

按步骤编写代码：
* 定义接口Universe，提供抽象方法doAnything。
* 定义普通类Star，提供成员发光shine方法，打印“star:星星一闪一闪亮晶晶"
* 定义普通类Sun，
  继承Star类，重写shine方法，打印"sun:光照八分钟，到达地球"
  实现Universe接口，实现doAnything，打印"sun:太阳吸引着9大行星旋转"
* 测试类中，创建Star对象，调用shine方法
* 测试类中，多态的方式创建Sun对象，调用doAnything方法，向下转型，调用shine方法。

示例代码：
public class Home2 {
    public static void main(String[] args) {
        Star star=new Star();
        star.shine();

        Universe universe=new Sun();//多态
        universe.doAnything();

        Sun sun=(Sun)universe;
        sun.shine();
    }
}

interface Universe{
    void doAnything();
}

class Star{
    public void shine(){
        System.out.println("星星一闪一闪亮晶晶");
    }
}

class Sun extends Star implements Universe{
    @Override
    public void shine() {
        System.out.println("光照八分钟，到达地球");
    }

    @Override
    public void doAnything() {
        System.out.println("太阳吸引着9大行星旋转");
    }
}

示例：实现单例模式（一二三属于饿汉式，四属于懒汉式）
public class Demo1 {
    public static void main(String[] args) {
        //Single single=new Single();
        Single single1 = Single.getSingle();
        Single single2 = Single.getSingle();
        /* Single single1 = Single.SINGLE;
        Single single2 = Single.SINGLE;*/

        System.out.println(single1==single2);
    }
}

public class Single {
    /* 方式一：
    private static final Single SINGLE=new Single();
    private Single(){}

    public static Single getSingle(){//该方法需要通过类名调用！
        return SINGLE;
    }*/
    /*方式二：
    public static final Single SINGLE=new Single();
    private Single(){}*/

    /*方式三：
    public static final Single SINGLE;
    static {
        SINGLE=new Single();
    }
    private Single(){}*/

    //方式四：该方式存在一定的线程安全问题！(讲完线程，会解决该方式的线程安全)
    private static Single SINGLE;
    private Single(){}

    public static Single getSingle(){//该方法需要通过类名调用！
        if(SINGLE==null)
            SINGLE=new Single();
        return SINGLE;
    }
}

D:\javademo\day15_am>javac Demo1.java
D:\javademo\day15_am>java Demo1
true

饿汉式：不管你要不要，类加载的时候，对象已经准备好
懒汉式：只有你要的时候，我才给你准备对象

示例：JDK1.5之前，通过自己的逻辑实现枚举
public class Demo2 {
    public static void main(String[] args) {
        Person person=new Person();
        person.setId(10);
        person.setName("张三");
        person.setGender(Gender.GIRL);

        System.out.println(person.getName()+"的性别是："+person.getGender().getValue());

        /*Gender.BOY=Gender.GIRL;
        System.out.println(Gender.BOY);
        System.out.println(Gender.GIRL);*/
    }
}
public class Person {
    private int id;
    private String name;
    //private char gender;//性别采用字符  'a'  '1'  '尚'
    private Gender gender;//对象关联

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Gender getGender() {
        return gender;
    }

    public void setGender(Gender gender) {
        this.gender = gender;
    }
}

/*
    性别的类
        只对外提供两个对象！
 */
public class Gender {

    private String value;//说明  value对外不能提供set方法

    public static final Gender BOY=new Gender("男孩");
    public static final Gender GIRL=new Gender("女孩");
    private Gender(String value){
        this.value=value;
    }

    public String getValue() {
        return value;
    }

    /*方式一：
    private static final Gender BOY=new Gender();
    private static final Gender GIRL=new Gender();
    private Gender(){}
    public static Gender getBoy(){
        return BOY;
    }
    public static Gender getGirl(){
        return GIRL;
    }*/

    /*public static final Gender BOY;
    public static final Gender GIRL;
    static{
        BOY=new Gender();
        GIRL=new Gender();
    }
    private Gender(){}*/
}

D:\javademo\day15_am>javac Demo2.java
D:\javademo\day15_am>java Demo2
张三的性别是：女孩

示例：定义季节的枚举类，然后并设置属性value(对季节的描述)！在测试类测试
public class Test1 {
    public static void main(String[] args) {
        Season spring=Season.WINTER;
        System.out.println(spring.getValue());
    }
}

class Season{
    private Season(String value){this.value=value;}
    private String value;//季节的描述
    public static final Season SPRING=new Season("春意盎然");
    public static final Season SUMMER=new Season("烈日炎炎");
    public static final Season AUTUMN=new Season("秋高气爽");
    public static final Season WINTER=new Season("真冷");

    public String getValue() {
        return value;
    }
}

D:\javademo\day15_am>javac Test1.java
D:\javademo\day15_am>java Test1
真冷

示例：JDK1.5之后，通过该关键字创建的类就是枚举类！
public class Demo3 {
    public static void main(String[] args) {
        Gender2 boy=Gender2.BOY;
        //类名可以调用到，说明是静态的
        //挎包可以用，说明是公有的
        //Gender2.BOY=Gender2.GIRL;
        //不允许修改值，说明是常量！
    }
}
public enum Gender2 {
    //没有属性，就没必要去显示的创建构造器
    BOY,GIRL;
    //相当于创建了两个对象，一个名称是BOY,一个名称是GIRL
    //默认就是采用的无参构造器创建的对象！
    //对象与对象之间采用逗号隔开，最后使用分号结束
    //对象默认就是公有的静态的常量
    /*public static final Gender2 BOY=new Gender2();
    public static final Gender2 GIRL=new Gender2();*/
    /*private Gender2(){
        System.out.println("无参构造");
    }*/
}

示例：枚举类有参构造器
public class Demo3 {
    public static void main(String[] args) {
        Season2 season2=Season2.WINTER;
        System.out.println(season2);
    }
}

public enum Season2 {
    SPRING("春意盎然"),
    SUMMER("烈日炎炎"),
    AUTUMN("硕果累累"),
    WINTER("白雪皑皑");
    //创建对象的时候，为属性设置属性值
    private Season2(String value){
        this.value=value;
    }
    private String value;

    public String getValue() {
        return value;
    }

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

D:\javademo\day15_am>javac Demo3.java
D:\javademo\day15_am>java Demo3
白雪皑皑
 

示例：枚举类的父类Enum，使用父类中的方法
public class Demo4 {
    public static void main(String[] args) {
        Season2 season2=Season2.SUMMER;
        System.out.println(season2.name());//获得对象的名称
        System.out.println(season2.toString());//Enum重写后的
        System.out.println(season2.ordinal());//返回当前对象的位置(角标)

        Season2[] values = Season2.values();//返回该枚举类所有的常量对象
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }

        System.out.println("--------------");
        String str="WINTER";
        Season2 season21 = Season2.valueOf(str);
        System.out.println(season21.getValue());
    }
}

D:\javademo\day15_am>javac Demo4.java
D:\javademo\day15_am>java Demo4
SUMMER
烈日炎炎
1
春意盎然
烈日炎炎
硕果累累
白雪皑皑
--------------
白雪皑皑
 

示例：JDK1.5之后，enum实现接口
public class Demo4 {
    public static void main(String[] args) {
        Season2.SPRING.fly();
        Season2.WINTER.fly();
        Season2.SUMMER.fly();
    }
}
public interface Fly {
    void fly();
}
public enum Season2 implements Fly{
    SPRING("春意盎然"){
        public void fly(){
            System.out.println("风筝飞");
        }
    },
    SUMMER("烈日炎炎"){
        public void fly(){
            System.out.println("裙子飞");
        }
    },
    AUTUMN("硕果累累"){
        public void fly(){
            System.out.println("秋天自己飞");
        }
    },
    WINTER("白雪皑皑");
    //创建对象的时候，为属性设置属性值
    private Season2(String value){
        this.value=value;
    }
    private String value;

    public String getValue() {
        return value;
    }

    @Override
    public void fly() {
        System.out.println("可以飞");
    }

    /*@Override
    public String toString() {
        return  value ;
    }*/
}

D:\javademo\day15_pm>javac Demo4.java
D:\javademo\day15_pm>java Demo4
风筝飞
可以飞
裙子飞

示例：装箱、拆箱
    @Test
    public void test1(){
        byte b1=10;
        //手动装箱  b2的值就是b1的值
        Byte b2=new Byte(b1);
        //手动装箱   b3的值就是34
        Byte b3=new Byte("34");
        //自动装箱   使用起来方便很多(查看源码)
        Byte b4=b1;
        byte b5=b2.byteValue();
        byte b6=b2; //自动拆箱
    }

示例：包装类的常用方法
public class Demo8 {
    public static void main(String[] args) {
        String str="45";
        int i = new Integer(str);
        System.out.println(i);

        int i1 = Integer.parseInt(str);
        System.out.println(i1);

        byte b = Byte.parseByte(str);

        short i2 = Short.parseShort(str);

        long l = Long.parseLong(str);

        float v1 = Float.parseFloat(str);

        double v = Double.parseDouble(str);

        boolean b1 = Boolean.parseBoolean(str);
    }
}

示例：自动装箱的原理
//Integer i=10;//自动装箱  会默认调用Integer中的valueOf方法
/*  自动装箱的核心(源码)
public static Integer valueOf(int i) {
    //判断i的值，是否在一个范围  -128 ~ 127  从数组中取值(地址)给你
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        //如果在，返回一个数组中的值
        return IntegerCache.cache[i + (-IntegerCache.low)];
    //如果不在和自己new的没区别
    return new Integer(i);
}
范围是多少？
数组是啥？
①： Integer类加载-->静态成员内部类IntegerCache(也会加载)
    int low=-128
    int high=127
    Integer cache[]=new Integer[(high - low) + 1];//127 + 128 + 1
        创建了一个长度为256的数组！
        循环创建-128~127的Integer对象，存储在数组中!（默认值）
*/

public class Demo9 {
    public static void main(String[] args) {
        Integer i1=10;//1. Integer这个类会加载  2. 在创建i1这个局部变量
        Integer i2=10;
        System.out.println(i1==i2);//true  对比地址

        Integer i3=new Integer(10);
        System.out.println(i1==i3);//false  对比地址

        Integer i4=200;
        Integer i5=200;
        System.out.println(i4==i5);//false

        Integer i6=300;
        int i8=i6;
        int i7=300;
        System.out.println(i8==i7);//true  因为有基本数据类型(i6会转为int在对比)
    }
}

D:\javademo\day15_pm>java Demo9
true
false
false
true