JavaSe总结-27- 反射 & 设计模式 & JDK5、7、8新特性
27.02 反射_类加载器的概述和分类
27.03 反射_反射概述
27.04 反射_获取class文件对象的三种方式
27.05 反射_通过反射获取无参构造方法并使用27.06 反射_通过反射获取带参构造方法并使用
27.07 反射_通过反射获取私有构造方法并使用
27.08 反射_通过反射获取成员变量并使用
27.09 反射_通过反射获取无参无返回值成员方法并使用
27.10 反射_通过反射获取带参带返回值成员方法并使用
27.11 反射_通过反射运行配置文件内容
27.12 反射_通过反射越过泛型检查
27.13 反射_通过反射写一个通用的设置某个对象的某个属性为指定的值
27.14 反射_动态代理的概述和实现
27.15 设计模式_模版设计模式概述和使用
27.16 设计模式_装饰模式概述和使用
27.17 JDK5新特性_JDK5新特性回顾
27.18 JDK5新特性_自己实现枚举类
27.19 JDK5新特性_通过enum实现枚举类
27.20 JDK5新特性_枚举的注意事项
27.21 JDK5新特性_枚举类的常见方法
27.22 JDK7新特性_JDK7的六个新特性回顾和讲解
27.23 JDK8新特性_接口中也可以有方法
27.01 反射_类的加载概述和加载时机
类的加载:当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
加载:就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
连接
验证 是否有正确的内部结构，并和其他类协调一致
准备 负责为类的静态成员分配内存，并设置默认初始化值
解析 将类的二进制数据中的符号引用替换为直接引用
初始化:
创建类的实例
访问类的静态变量，或者为静态变量赋值
调用类的静态方法
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类
27.02 反射_类加载器的概述和分类
类加载器:负责将.class文件加载到内在中，并为之生成对应的Class对象。
类加载器的组成:
Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载
比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载。
在JDK中JRE的lib目录下ext目录
Sysetm ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径
27.03 反射_反射概述
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。
27.04 反射_获取class文件对象的三种方式
1:Object类的getClass()方法
2:数据类型的静态属性class
3:Class类中的静态方法:public static Class forName(String className)
开发中使用第三种方式
例:
1 public class Practice
2 {
3 public static void main(String[] args) throws ClassNotFoundException
4 {
5 // 方式1
6 Student p = new Student();
7 Class c1 = p.getClass();
8
9 Student p2 = new Student();
10 Class c2 = p2.getClass();
11
12 System.out.println(p == p2);// false
13 System.out.println(c1 == c2);// true
14
15 // 方式2
16 Class c3 = Student.class;
17 System.out.println(c1 == c3);// true
18
19 // 方式3
20 //public static Class forName(String className) throws ClassNotFoundException
21 //返回与带有给定字符串名的类或接口相关联的 Class 对象
22 Class c4 = Class.forName("com.test.Student");//类的全路径
23 System.out.println(c1 == c4);// true
24 }
25 }
27.05 反射_通过反射获取无参构造方法并使用
获取无参构造方法
public Constructor[] getConstructors()throws SecurityException
返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
public Constructor[] getDeclaredConstructors()throws SecurityException
返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。
例1:
1 Class c = Class.forName("com.test.Student");
2 //获取所有公共构造方法
3 Constructor[] cons = c.getConstructors();
4 for(Constructor con : cons)
5 {
6 System.out.println(con);
7 }
8 System.out.println("--------------");
9 //获取所有构造方法
10 Constructor[] conss = c.getDeclaredConstructors();
11 for(Constructor con : conss)
12 {
13 System.out.println(con);
14 }
例2:
1 public class Practice
2 {
3 public static void main(String[] args) throws Exception
4 {
5 Class c = Class.forName("com.test.Student");
6 // 获取单个构造方法
7 // public Constructor getConstructor(Class... parameterTypes)
8 // 参数表示的是:要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
9 Constructor con = c.getConstructor();// 返回的是构造方法对象
10
11 // Person p = new Person();
12 // System.out.println(p);
13 // public T newInstance(Object... initargs)
14 // 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
15 Object obj = con.newInstance();
16 System.out.println(obj);
17
18 //Student p = (Student)obj;
19 //p.show();
20 }
21 }
27.06 反射_通过反射获取带参构造方法并使用
获取带参构造方法
例:
1 public class Practice
2 {
3 public static void main(String[] args) throws Exception
4 {
5 // 获取字节码文件对象
6 Class c = Class.forName("com.test.Student");
7
8 // 获取带参构造方法对象
9 // public Constructor getConstructor(Class... parameterTypes)
10 Constructor con = c.getConstructor(String.class, int.class,String.class);
11
12 // 通过带参构造方法对象创建对象
13 // public T newInstance(Object... initargs)
14 Object obj = con.newInstance("小明", 27, "上海");
15
16 System.out.println(obj);
17 }
18 }
27.07 反射_通过反射获取私有构造方法并使用
获取私有构造方法
1 public class Practice
2 {
3 public static void main(String[] args) throws Exception
4 {
5 // 获取字节码文件对象
6 Class c = Class.forName("com.test.Student");
7
8 // 获取私有构造方法对象
9 Constructor con = c.getDeclaredConstructor(String.class);
10
11 // 用该私有构造方法创建对象
12 // IllegalAccessException:非法的访问异常。
13 // 暴力访问
14 con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查
15 Object obj = con.newInstance("旺财");
16
17 System.out.println(obj);
18 }
19 }
27.08 反射_通过反射获取成员变量并使用
获取成员变量
public Field getField(String name)throws NoSuchFieldException,SecurityException
返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
public Field[] getDeclaredFields()throws SecurityException
返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。
例:
1 public class Practice
2 {
3 public static void main(String[] args) throws Exception
4 {
5 // 获取字节码文件对象
6 Class c = Class.forName("com.test.Student");
7
8 // 通过无参构造方法创建对象
9 Constructor con = c.getConstructor();
10 Object obj = con.newInstance();
11 System.out.println(obj);
12
13 // 获取单个的成员变量
14 // 获取address并对其赋值(公共的)
15 Field addressField = c.getField("address");
16 // public void set(Object obj,Object value)
17 // 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
18 addressField.set(obj, "上海"); // 给obj对象的addressField字段设置值为"上海"
19 System.out.println(obj);
20
21 // 获取name并对其赋值(私有的)
22 // NoSuchFieldException
23 Field nameField = c.getDeclaredField("name");
24 // IllegalAccessException
25 nameField.setAccessible(true);
26 nameField.set(obj, "小强");
27 System.out.println(obj);
28
29 // 获取age并对其赋值(默认的)
30 Field ageField = c.getDeclaredField("age");
31 ageField.setAccessible(true);
32 ageField.set(obj, 27);
33 System.out.println(obj);
34 }
35 }
27.09 反射_通过反射获取无参无返回值成员方法并使用
获取无参无返回值成员方法
public Method[] getMethods()throws SecurityException
返回本类的所有公共方法同时返回从 Object 类继承的所有公共方法。
public Method[] getDeclaredMethods()throws SecurityException
返回 自己的所有方法
例:
1 public class Practice
2 {
3 public static void main(String[] args) throws Exception
4 {
5 // 获取字节码文件对象
6 Class c = Class.forName("com.test.Student");
7
8 Constructor con = c.getConstructor();
9 Object obj = con.newInstance();
10
11 // 获取单个方法并使用
12 // public void show()
13 // public Method getMethod(String name,Class... parameterTypes)
14 // 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
15 Method m1 = c.getMethod("show");
16 // obj.m1(); // 错误
17 // public Object invoke(Object obj,Object... args)
18 // 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
19 m1.invoke(obj); // 调用obj对象的m1方法
20 }
21 }
27.10 反射_通过反射获取带参带返回值成员方法并使用
获取带参带返回值成员方法
例:
1 public class Practice
2 {
3 public static void main(String[] args) throws Exception
4 {
5 // 获取字节码文件对象
6 Class c = Class.forName("com.test.Student");
7
8 Constructor con = c.getConstructor();
9 Object obj = con.newInstance();
10
11 // 获取单个方法并使用
12 // public void show()
13 // public Method getMethod(String name,Class... parameterTypes)
14 // 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
15 Method m1 = c.getMethod("show");
16 // obj.m1(); // 错误
17 // public Object invoke(Object obj,Object... args)
18 // 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
19 m1.invoke(obj); // 调用obj对象的m1方法
20
21 System.out.println("----------");
22 // public void method(String s)
23 Method m2 = c.getMethod("method", String.class);
24 m2.invoke(obj, "hello");
25 System.out.println("----------");
26
27 // public String getString(String s, int i)
28 Method m3 = c.getMethod("getString", String.class, int.class);
29 Object objString = m3.invoke(obj, "hello", 100);
30 System.out.println(objString);
31 // String s = (String)m3.invoke(obj, "hello",100);
32 // System.out.println(s);
33 System.out.println("----------");
34
35 // private void function()
36 Method m4 = c.getDeclaredMethod("function");
37 m4.setAccessible(true);
38 m4.invoke(obj);
39 }
40 }
27.11 反射_通过反射运行配置文件内容
通过配置文件运行类中的方法
反射:需要有配置文件配合使用。用class.txt代替。并且知道有两个键。className、methodName
例:
1 public class Test
2 {
3 public static void main(String[] args) throws Exception
4 {
5 // 反射前的做法
6 // Student s = new Student();
7 // s.love();
8 // Teacher t = new Teacher();
9 // t.love();
10 // Worker w = new Worker();
11 // w.love();
12
13 // 反射后的做法
14 // 加载键值对数据
15 Properties prop = new Properties();
16 FileReader fr = new FileReader("class.txt");
17 prop.load(fr);
18 fr.close();
19
20 // 获取数据
21 String className = prop.getProperty("className");
22 String methodName = prop.getProperty("methodName");
23
24 // 反射
25 Class c = Class.forName(className);
26
27 Constructor con = c.getConstructor();
28 Object obj = con.newInstance();
29
30 // 调用方法
31 Method m = c.getMethod(methodName);
32 m.invoke(obj);
33 }
34 }
上例中，如果需要运行其他的类只需要修改class.txt文件中的内容即可
27.12 反射_通过反射越过泛型检查
实现向ArrayList
1 public class ArrayListDemo
2 {
3 public static void main(String[] args) throws Exception
4 {
5 // 创建集合对象
6 ArrayList array = new ArrayList();
7
8 // array.add("hello");
9 // array.add(10);
10
11 Class c = array.getClass(); // 集合ArrayList的class文件对象
12 Method m = c.getMethod("add", Object.class);
13
14 m.invoke(array, "hello"); // 调用array的add方法，传入的值是hello
15 m.invoke(array, "world");
16 m.invoke(array, "java");
17
18 System.out.println(array);
19 }
20 }
27.13 反射_通过反射写一个通用的设置某个对象的某个属性为指定的值
1 public class Tool
2 {
3 public void setProperty(Object obj, String propertyName, Object value)throws Exception
4 {
5 // 根据对象获取字节码文件对象
6 Class c = obj.getClass();
7 // 获取该对象的propertyName成员变量
8 Field field = c.getDeclaredField(propertyName);
9 // 取消访问检查
10 field.setAccessible(true);
11 // 给对象的成员变量赋值为指定的值
12 field.set(obj, value);
13 }
14 }
15
16 //测试类
17 public class ToolDemo
18 {
19 public static void main(String[] args) throws Exception
20 {
21 Person p = new Person();
22 Tool t = new Tool();
23 t.setProperty(p, "name", "小明");
24 t.setProperty(p, "age", 27);
25 System.out.println(p);
26 System.out.println("-----------");
27
28 Dog d = new Dog();
29
30 t.setProperty(d, "sex", '男');
31 t.setProperty(d, "price", 12.34f);
32
33 System.out.println(d);
34 }
35 }
36
37 class Dog
38 {
39 char sex;
40 float price;
41
42 @Override
43 public String toString()
44 {
45 return sex + "---" + price;
46 }
47 }
48
49 class Person
50 {
51 private String name;
52 public int age;
53
54 @Override
55 public String toString()
56 {
57 return name + "---" + age;
58 }
59 }
27.14 反射_动态代理的概述和实现
动态代理:在程序运行过程中产生的这个对象，而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理
在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib
Proxy类中的方法创建动态代理类对象
public static Object newProxyInstance(ClassLoader loader,Class[] interfaces,
InvocationHandler h)throws IllegalArgumentException
返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。最终会调用InvocationHandler的方法
接口 InvocationHandler中的方法
Object invoke(Object proxy,Method method,Object[] args) throws Throwable
在代理实例上处理方法调用并返回结果。
Proxy.newProxyInstance
创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，
也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，
以$开头，proxy为中，最后一个数字表示对象的标号。
System.out.println(u.getClass().getName());
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke 方法来进行调用。
Proxy类中创建动态代理对象的方法的三个参数:
ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
InvocationHandler接口中invoke方法的三个参数:
proxy:代表动态代理对象
method:代表正在执行的方法
args:代表调用目标方法时传入的实参
27.15 设计模式_模版设计模式概述和使用
模版设计模式概述:模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现
优点:使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
缺点:如果算法骨架有修改的话，则需要修改抽象类
例:
1 //模板
2 public abstract class GetTime
3 {
4 // 计算出一段代码的运行时间
5 public long getTime()
6 {
7 long start = System.currentTimeMillis();
8 code();
9
10 long end = System.currentTimeMillis();
11
12 return end - start;
13 }
14 public abstract void code();
15 }
16
17 //实现类
18 public class ForDemo extends GetTime
19 {
20 @Override
21 public void code()
22 {
23 for (int x = 0; x < 100000; x++)
24 {
25 System.out.println(x);
26 }
27 }
28 }
29 //测试类
30 public class Practice
31 {
32 public static void main(String[] args)
33 {
34 GetTime gt = new ForDemo();
35 System.out.println(gt.getTime() + "毫秒");
36 }
37 }
27.16 设计模式_装饰模式概述和使用
装饰设计模式概述:装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案
优点:使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，并且可以随意的组合这些功能
缺点:正因为可以随意组合，所以就可能出现一些不合理的逻辑
例:
1 public class Practice
2 {
3 public static void main(String[] args)
4 {
5 Person p = new Person();
6 // p.chifan();
7
8 NewPerson p1 = new NewPerson(p);
9 p1.chifan();
10
11 NewPerson2 p2 = new NewPerson2();
12 p2.chifan();
13 }
14 }
15
16 class Person
17 {
18 void chifan()
19 {
20 System.out.println("吃饭");
21 }
22 }
23
24 //这个类的出现是为了增强Person而出现的。
25 class NewPerson//装饰设计模式
26 {
27 private Person p ;
28 NewPerson(Person p)
29 {
30 this.p = p;
31 }
32
33 public void chifan()
34 {
35 System.out.println("开胃酒");
36 p.chifan();
37 System.out.println("甜点");
38 }
39
40 }
41
42
43 class NewPerson2 extends Person//继承
44 {
45 public void chifan()
46 {
47 System.out.println("开胃酒");
48 super.chifan();
49 System.out.println("甜点");
50 }
51 }
27.17 JDK5新特性_JDK5新特性回顾
自动装箱和拆箱、泛型、增强for循环、静态导入、可变参数
27.18 JDK5新特性_自己实现枚举类
枚举概述:是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。
举例:一周只有7天，一年只有12个月等。
单例设计模式:单例类是一个类只有一个实例
那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。
例:
1 //版本1
2 public class Direction
3 {
4 // 创建几个实例
5 public static final Direction FRONT = new Direction();
6 public static final Direction BEHIND = new Direction();
7 public static final Direction LEFT = new Direction();
8 public static final Direction RIGHT = new Direction();
9
10 // 构造私有，不能无限的创建
11 private Direction()
12 {}
13 }
14 ----------------------------------------------------------------------
15 //版本2
16 public class Direction2
17 {
18 // 创建几个实例
19 public static final Direction2 FRONT = new Direction2("前");
20 public static final Direction2 BEHIND = new Direction2("后");
21 public static final Direction2 LEFT = new Direction2("左");
22 public static final Direction2 RIGHT = new Direction2("右");
23
24 // 构造私有，别人就不能无限的创建了
25 // private Direction2() {
26 // }
27
28 // 加入成员变量,并去掉无参构造
29 private String name;
30
31 private Direction2(String name)
32 {
33 this.name = name;
34 }
35
36 public String getName()
37 {
38 return name;
39 }
40 }
41 ----------------------------------------------------------------------
42 //版本3
43 public abstract class Direction3
44 {
45 // 创建几个实例
46 public static final Direction3 FRONT = new Direction3("前")
47 {
48 @Override
49 public void show()
50 {
51 System.out.println("前");
52 }
53
54 };
55 public static final Direction3 BEHIND = new Direction3("后")
56 {
57 @Override
58 public void show()
59 {
60 System.out.println("后");
61 }
62
63 };
64 public static final Direction3 LEFT = new Direction3("左")
65 {
66 @Override
67 public void show()
68 {
69 System.out.println("左");
70 }
71
72 };
73 public static final Direction3 RIGHT = new Direction3("右")
74 {
75 @Override
76 public void show()
77 {
78 System.out.println("右");
79 }
80
81 };
82
83 // 构造私有，别人就不能无限的创建了
84 // private Direction2() {
85 // }
86
87 // 加入成员变量,并去掉无参构造
88 private String name;
89
90 private Direction3(String name)
91 {
92 this.name = name;
93 }
94
95 public String getName()
96 {
97 return name;
98 }
99
100 // 加入抽象方法
101 public abstract void show();
102 }
103 ----------------------------------------------------------------------
104 //测试
105 public class DirectionDemo
106 {
107 public static void main(String[] args)
108 {
109 Direction d = Direction.FRONT;
110 System.out.println(d); // cn.itcast_01.Direction@175078b
111 System.out.println("------------------------------------");
112 Direction2 d2 = Direction2.FRONT;
113 System.out.println(d2);// cn.itcast_01.Direction2@11563ff
114 System.out.println(d2.getName());
115 d2 = Direction2.RIGHT;
116 System.out.println(d2);
117 System.out.println(d2.getName());
118 System.out.println("------------------------------------");
119 Direction3 d3 = Direction3.FRONT;
120 System.out.println(d3);
121 System.out.println(d3.getName());
122 d3.show();
123
124 d3 = Direction3.LEFT;
125 System.out.println(d3);
126 System.out.println(d3.getName());
127 d3.show();
128 }
129 }
27.19 JDK5新特性_通过enum实现枚举类
格式:
只有枚举项的枚举类
public enum 枚举类名
{
枚举项1，枚举项2，枚举项3…;
}
例:
1 //版本1
2 public enum Direction
3 {
4 FRONT, BEHIND, LEFT, RIGHT;
5 }
6 ----------------------------------------------------------------------
7 //版本2
8 public enum Direction2
9 {
10 FRONT("前"), BEHIND("后"), LEFT("左"), RIGHT("右");
11
12 private String name;
13
14 private Direction2(String name)
15 {
16 this.name = name;
17 }
18
19 public String getName()
20 {
21 return name;
22 }
23 }
24
25 ----------------------------------------------------------------------
26 //版本3
27 public enum Direction3
28 {
29 FRONT("前")
30 {
31 @Override
32 public void show()
33 {
34 System.out.println("前");
35 }
36 },
37 BEHIND("后")
38 {
39 @Override
40 public void show()
41 {
42 System.out.println("后");
43 }
44 },
45 LEFT("左")
46 {
47 @Override
48 public void show()
49 {
50 System.out.println("左");
51 }
52 },
53 RIGHT("右")
54 {
55 @Override
56 public void show()
57 {
58 System.out.println("右");
59 }
60 };
61
62 private String name;
63
64 private Direction3(String name)
65 {
66 this.name = name;
67 }
68
69 public String getName()
70 {
71 return name;
72 }
73
74 public abstract void show();
75 }
76
77 ----------------------------------------------------------------------
78 //测试
79 public class DirectionDemo
80 {
81 public static void main(String[] args)
82 {
83 Direction d = Direction.FRONT;
84 System.out.println(d); // FRONT
85 // public String toString()返回枚举常量的名称，它包含在声明中。
86 System.out.println("-------------");
87 Direction2 d2 = Direction2.FRONT;
88 System.out.println(d2);
89 System.out.println(d2.getName());
90 System.out.println("-------------");
91 Direction3 d3 = Direction3.FRONT;
92 System.out.println(d3);
93 System.out.println(d3.getName());
94 d3.show();
95 System.out.println("--------------");
96
97 Direction3 dd = Direction3.FRONT;
98 dd = Direction3.LEFT;
99
100 switch (dd)
101 {
102 case FRONT:
103 System.out.println("你选择了前");
104 break;
105 case BEHIND:
106 System.out.println("你选择了后");
107 break;
108 case LEFT:
109 System.out.println("你选择了左");
110 break;
111 case RIGHT:
112 System.out.println("你选择了右");
113 break;
114 }
115 }
116 }
运行结果:
FRONT
-------------
FRONT
前
-------------
FRONT
前
前
--------------
你选择了左
27.20 JDK5新特性_枚举的注意事项
注意事项:
1.定义枚举类要用关键字enum
2.所有枚举类都是Enum的子类
3.枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省 略。建议不要省略
4.枚举类可以有构造器，但必须是private的，它默认的也是private的。枚举项的用法比较特殊:枚举(“”);
5.枚举类也可以有抽象方法，但是枚举项必须重写该方法
6.枚举在switch语句中的使用
27.21 JDK5新特性_枚举类的常见方法
1.public final int compareTo(E o)比较此枚举与指定对象的顺序。
2.public final String name()返回此枚举常量的名称，在其枚举声明中对其进行声明。
3.public final int ordinal()返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
4.public String toString()返回枚举常量的名称，它包含在声明中。
5.public static
返回带指定名称的指定枚举类型的枚举常量。
例:
1 public class Practice
2 {
3 public static void main(String[] args)
4 {
5 // int compareTo(E o)
6 Direction2 d21 = Direction2.FRONT;//0
7 Direction2 d22 = Direction2.BEHIND;//1
8 Direction2 d23 = Direction2.LEFT;//2
9 Direction2 d24 = Direction2.RIGHT;//3
10 System.out.println(d21.compareTo(d21));//0
11 System.out.println(d21.compareTo(d24));//-3
12 System.out.println(d24.compareTo(d21));//3
13 System.out.println("---------------");
14 // String name()
15 System.out.println(d21.name());//FRONT
16 System.out.println("--------------");
17 // int ordinal()
18 System.out.println(d21.ordinal());//0
19 System.out.println(d22.ordinal());//1
20 System.out.println("--------------");
21 // String toString()
22 System.out.println(d21.toString());//FRONT
23 System.out.println(d22.toString());//BEHIND
24 System.out.println("--------------");
25 // T valueOf(Class type,String name)
26 Direction2 d = Enum.valueOf(Direction2.class, "FRONT");
27 System.out.println(d.getName());//前
28 System.out.println("----------------");
29 // values()
30 // 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便
31 Direction2[] dirs = Direction2.values();
32 for (Direction2 d2 : dirs)
33 {
34 System.out.println(d2);
35 System.out.println(d2.getName());
36 }
37 }
38 }
27.22 JDK7新特性_JDK7的六个新特性回顾和讲解
二进制字面量
JDK7开始，可以用二进制来表示整数（byte,short,int和long）。
使用二进制字面量的好处是，可以使代码更容易被理解。语法非常简单，只要在二进制数值前面加 0b或者0B
例:int x = 0b110110
数字字面量可以出现下划线
为了增强对数值的阅读性，如我们经常把数据用逗号分隔一样。JDK7提供了_对数据分隔。
例:int x = 100_1000;
注意事项:
不能出现在进制标识和数值之间
不能出现在数值开头和结尾
不能出现在小数点旁边
switch 语句可以用字符串
泛型简化
异常的多个catch合并
try-with-resources 语句
try(必须是java.lang.AutoCloseable的子类对象){…}
好处:
资源自动释放，不需要close()了
把需要关闭资源的部分都定义在这里就行了
主要是流体系的对象是这个接口的子类(JDK7的API)
27.23 JDK8新特性_接口中也可以有方法
例:
1 interface Inter
2 {
3 //抽象方法
4 public abstract void show();
5
6 //default方法
7 public default void defaultPrint()
8 {
9 System.out.println("defaultPrint run");
10 }
11
12 //static方法
13 public static void staticPrint()
14 {
15 System.out.println("staticPrint run");
16 }
17 }
18
19 //实现类
20 class InterImpl implements Inter
21 {
22 public void show()
23 {
24 System.out.println("重写接口中的方法");
25 }
26 }
27
28 //测试类
29 public class Demo
30 {
31 public static void main(String[] args)
32 {
33 //Inter.defaultPrint(); //非静态方法不能直接使用
34 Inter.staticPrint();
35
36 Inter i = new InterImpl();
37 i.defaultPrint();
38 i.show();
39 }
40 }