枚举，包类型

一.枚举

在JDK1.5 之前，我们定义常量都是： public static final.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 

public class Season {
    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("冬天","白雪皑皑");

    private String name;
    private String des;
    private Season(){};

    private Season(String name, String des) {
        this.name = name;
        this.des = des;
    }

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

版本迭代以后

1.构造器默认私有

2.枚举中属性必须位于枚举元素下面

3.所有的自定义枚举默认继承自Enum类

4.枚举类不能再继承其他的类

5.枚举类可以实现一个接口

6.枚举对象可以根据自身的需求，灵活判断是否需要自定义接口内的方法

public enum Season {
    SPRING("春天","穿暖花开"),
    SUMMER("夏天","烈日炎炎"),
    AUTUMN("秋天","天高云阔"),
    WINTER("冬天","白雪皑皑");

    private String name;
    private String des;
    Season(){};

    Season(String name, String des) {
        this.name = name;
        this.des = des;
    }
    
}

也可以直接建立一个Enum类型

public enum Gender {
    MAN,WOMAN
}

main

public class EnumTest {
    public static void main(String[] args) {
        Gender gender=Gender.MAN;
        switch (gender){
            case MAN:
                System.out.println("just man");
                break;
            case WOMAN:
                System.out.println("just woman");
                break;
            default:
                throw new IllegalStateException("Unexpected value: " + gender);
        }
    }
}

即可

实现接口的代码：

package com.atguigu.day10;

public enum Gender implements Run{
    MAN{
        @Override
        public void run(){
            System.out.println("昂首挺胸");
        }
    },WOMAN{
        @Override
        public void run(){
            System.out.println("婀娜多姿");
        }
    }
}

interface Run{
    void run();
}

main

package com.atguigu.day10;

public class EnumTest {
    public static void main(String[] args) {
        Gender gender=Gender.MAN;
        gender.run();
    }
}

输出

昂首挺胸

 二.包类型

1.Java是面向对象的，万事万物皆对象

如何判断一个变量是不是对象，让此变量 .出现一些列的方法，则是对象

常见的包类型有：

byte    short   int   long   float  double   char boolean

Byte   Short   Integer Long Float  Double Character Boolean

Integer就是int的包装类

package com.atguigu.day10;

public class Test2 {
    public static void main(String[] args) {

        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //将一个十进制的数转换为2进制
        String s1= Integer.toBinaryString(2);
        System.out.println(s1);
        //将一个十进制的数转换为8进制
        String s2 =Integer.toOctalString(9);
        System.out.println(s2);
        
/*        基本数据类型与包装类之间的转换
         
         1.基本数据转换为包装类型
          老方法：
            方式一：通过构造器
                Integer 标识符 = new Integer(基本数据类型);
            方式二：
                Integer 标识符 = Integer.valueOf(基本数据类型);
                
           新方法：
                Inteter 标识符=基本数据类型
           
                */

            int a=10;
            Integer i1=new Integer(a);
            Integer i2 = Integer.valueOf(a);
            
            Integer i3=23;
            
            /*
            2.包装类型转换为基本数据类型
            方法一：调用包装类的intValue();
            
            方法二：自动拆箱
                   直接将引用数据类型变为基本数据类型
                   基本数据类型 标识符 = 包装对象
            
            */
            
            Integer i4=new Integer(20);
            
            int i44=i4.intValue();
            int i5=i4;
            


    }
}

 字符串与基本数据类型/包装类型的转换

package com.atguigu.day10;

public class Test3 {
/*    1.字符串-----》基本数据类型/包装类
    方法1：
         Integer.parseInt("字符串纯数字");
         如果不是纯数字，会报异常
    方法2：
         Integer ix = new Integer("字符串纯数字");

     其他包装类依次类推:
        Double.parseDouble("字符串小数");
        Boolean.parseBoolean("true");
        Long.parseLong("123.3");
        注意：
        char中没有此方法

        2.基本类型数据转换为字符串
           方法1：""+基本数据类型
           方法2：String.valueOf();


         */

    public static void main(String[] args) {
        //以Double为例
        String ages= "25.5";
        Double v =Double.parseDouble(ages);
        System.out.println(v);

        Double v2= new Double("34.2");
        System.out.println(v2);
        
        //转为字符串
        String s1=""+100;
        String s2 = String.valueOf(100);
        System.out.println(s1);
        System.out.println(s2);

    }
}

 2.包装类型数据只能接受对应的包装类型，其他类型不能再采用类型自动提升

比如

Byte b =20;
Integer i=b;

这样就会报错

3.包装类的缓存问题：

包装类                          缓存对象

Byte                               -128-127

Short                              -128-127

Integer                           -128-127

Long                              -128-127

Float                              没有

Double                           没有

Character                      0-127

Boolean                         true/false

代码：

package com.atguigu.day10;

public class BaoTest {
    public static void main(String[] args) {
        Integer i=1;
        Integer j=1;
        System.out.println("i==j:"+(i==j));//true

        Integer i1=128;
        Integer j1=128;
        System.out.println("i1==j1:"+(i1==j1));//false

        Integer i2=new Integer(1);//新NEW的在堆中
        Integer j2=1;//这个用的是缓冲区的常量对象，在方法区
        System.out.println("i2==j2:"+(i2==j2));//false

        Integer i3=new Integer(1);//新NEW的在堆中
        Integer j3=new Integer(1);//另一个新NEW的堆中
        System.out.println("i3==j3:"+(i3==j3));//false

        Double d1 = new Double(1.0);
        Double d2 = new Double(1.0);
        System.out.println("d1==d2:"+(d1==d2));
        //没有缓存对象，每个都是新new的,false

    }
}

常见面试题

package com.atguigu.day10;

public class BaoTest {
    public static void main(String[] args) {
        Integer i=1;
        Integer j=1;
        System.out.println("i==j:"+(i==j));//true

        Integer i1=128;
        Integer j1=128;
        System.out.println("i1==j1:"+(i1==j1));//false

        Integer i2=new Integer(1);//新NEW的在堆中
        Integer j2=1;//这个用的是缓冲区的常量对象，在方法区
        System.out.println("i2==j2:"+(i2==j2));//false

        Integer i3=new Integer(1);//新NEW的在堆中
        Integer j3=new Integer(1);//另一个新NEW的堆中
        System.out.println("i3==j3:"+(i3==j3));//false

        Double d1 = new Double(1.0);
        Double d2 = new Double(1.0);
        System.out.println("d1==d2:"+(d1==d2));
        //没有缓存对象，每个都是新new的,false

        Double d3 =1.0;
        double d4 =1.0;
        //true,和基本数据类型比较会自动拆箱，比较数值
        System.out.println(d3==d4);

        Integer i4=1000;
        double d5=1000;
        //true,会先将i4自动拆箱为int，然后根据基本数据类型“自动类型转换”规则，转为double比较
        System.out.println(i4==d5);

        Integer i5=1000;
        int i6 =1000;
        //true,会将i5自动拆箱为int
        System.out.println(i5==i6);


        Integer i7=30;
        System.out.println("before change:"+i7);
        changeValue(i7);
        System.out.println("after change:"+i7);
/*  输出 before change:30
        changing:60
        after change:30*/
    }

    private static void changeValue(Integer i7) {
        i7=60;
        System.out.println("changing:"+i7);
    }
}