27.12_JDK5新特性

1,自动拆装箱
2,泛型
3,可变参数列表
4,静态导入
5,增强for循环
6,互斥锁
7,枚举f
8,引入StringBuilder类

27.13_JDK5新特性(自己实现枚举类)

• a:回想单例设计模式：单例类是一个类只有一个实例
• 那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。

public class EnumClass {  //自定义枚举类方式一
    public static final EnumClass MON = new EnumClass();
    public static final EnumClass TUE = new EnumClass();
    private EnumClass() {}  //私有构造，不让其他类创建本类对象
}


public class EnumClass2 {  //自定义枚举类方式二
    public static final EnumClass2 MON = new EnumClass2("星期一");
    public static final EnumClass2 TUE = new EnumClass2("星期二");
    private String name;
    private EnumClass2() {}  //私有构造，不让其他类创建本类对象
    private EnumClass2(String name) {   this.name = name ;}  //私有构造，不让其他类创建本类对象
    public String getName() { return name; }
}

public abstract class EnumClass3 {  //自定义枚举类方式三
    public static final EnumClass3 MON = new EnumClass3("星期一"){
        public void show() { System.out.println(this.getName()); }
    };
    public static final EnumClass3 TUE = new EnumClass3("星期二"){
        public void show() { System.out.println(this.getName()); }
    };
    private String name;
    private EnumClass3() {}  //私有构造，不让其他类创建本类对象
    private EnumClass3(String name) {   this.name = name ;}  //私有构造，不让其他类创建本类对象
    public String getName() { return name; }
    public String getName() { return name; }
    public abstract void show();
}

27.14_JDK5新特性(通过enum实现枚举类)

public enum Week {  //枚举格式一
    AA,BB,CC;
}

enum Week2 {  //枚举格式二
    AA("星期一"),BB("星期二"),CC("星期三");
    private String name;
    private Week2(String name) {  this.name = name;  }
    public String getName() { return name; }
}

enum Week3 {  //枚举格式三
    AA("星期一"){
        public void show() { System.out.println("我是星期一"); }
    },
    BB("星期二"){
        public void show() { System.out.println("我是星期一"); }
    },CC("星期三"){
        public void show() { System.out.println("我是星期一"); }
    };
    private String name;
    private Week3(String name) { this.name = name; }
    public String getName() {  return name;  }
    public abstract void show();
}
----------------分割线----------------
System.out.println(Week.AA);
System.out.println(Week2.AA.getName());
Week3.AA.show();

27.15_JDK5新特性(枚举的注意事项)

• 定义枚举类要用关键字enum
• 所有枚举类都是Enum的子类
• 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
• 枚举类可以有构造器，但必须是private的，它默认的也是private的。
• 枚举类也可以有抽象方法，但是枚举项必须重写该方法
• 枚举在switch语句中的使用

switch (Week.AA) {  //default 可以省，也可以加
case AA:
    System.out.println("匹配星期一");
    break;
case BB:
    System.out.println("匹配星期二");
    break;
case CC:
    System.out.println("匹配星期三");
    break;
}

27.16_JDK5新特性(枚举类的常见方法)

Week2 w = Week2.BB;

System.out.println(w.ordinal());  //返回枚举的索引（编号）
System.out.println(w.compareTo(Week2.CC));  //比较，比较的是索引(编号)
System.out.println(w.name());  //获取枚举实例的名称，结果： BB
System.out.println(w.toString()); //没有重写就是 w.name() 的结果

Week2 aa = Week2.valueOf(Week2.class, "AA");
System.out.println(aa);  //其实就是通过字节码对象 获取了 枚举项

for (Week2 temp : Week2.values()) {  //遍历枚举
    System.out.println(temp.getName());
}

27.17_JDK7新特性(JDK7的六个新特性回顾和讲解)

• A:二进制字面量
• B:数字字面量可以出现下划线
• C:switch语句可以用字符串
• D:泛型简化,菱形泛型
• E:异常的多个catch合并,每个异常用或|
• F:try-with-resources 语句, 1.7版本的异常处理代码

System.out.println( 0b110 );  //6的二进制:  0b110 , 以0b开头表示二进制
System.out.println( 100_000 ); //10万

// 因为 InputStream 实现了 AutoCloseable接口，所以会自动关闭
// 而 tyr(){} 会自动关闭 ()里面的对象，反之，()里面的对象必须实现了 AutoCloseable接口
try(
  FileInputStream in = new FileInputStream("xxoo.txt");
  FileOutputStream out = new FileOutputStream("xxoo.txt");
){
  int data ;
  while( (data = in.read()) != -1) {
    out.write(data);
  }
}

在try()中创建的流对象必须实现了AutoCloseable这个接口,
如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉 

27.18_JDK8新特性(JDK8的新特性)

• 1.接口中可以定义有方法体的方法,如果是非静态,必须用default修饰

interface Inter {
    public default void print() { //必须必须使用 default 修饰
        System.out.println("我在接口里，但是我有方法体！");
    }
    
    public static void method() {
        System.out.println("我是接口里的静态方法，接口名.来调用");
    }
}

• 2.内部类调用局部变量时，可以省略 final 修饰符了。但实际上JVM编译之后还是给加上了的，只是可以省略了。

问题：局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
答：因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用。

• ** 2.Lambda 表达式**
  详细Lambda表达式(闭包)的讲解: 点我查看

// JDK1.8之前的 比较器写法
Comparator<String> c = new Comparator<String>() {
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
};

// 使用 Lambda表达式
Comparator<String> c2 = (String o1, String o2) -> {
    return o1.compareTo(o2);
};

// Lambda表达式的应用：可以写的很短，可以去掉{}、return、类型,让JVM自动推导
List<String> list = Arrays.asList("aaa","ddd","bb","cc");
Collections.sort(list, (a,b) -> a.compareTo(b) );  //虽然可以简写到这种程度，但是我感觉，这样不利于阅读，还是写全一点好理解
Collections.sort(list, (String a, String b) -> {return a.compareTo(b);} );  // 写全的形式

new Thread(() -> {System.out.println("xx");}).start();  //多线程应用

END。
我是小侯爷。
在魔都艰苦奋斗，白天是上班族，晚上是知识服务工作者。
如果读完觉得有收获的话，记得关注和点赞哦。
非要打赏的话，我也是不会拒绝的。