【JavaSE笔记】反射_枚举_JDK新特性

本期知识点：
反射
枚举
JDK新特性

一.反射

1.类的加载及类加载器

a.类的加载：

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

加载：

就是指将class文件读入内存，并为之创建一个Class对象。

任何类被使用时系统都会建立一个Class对象。

连接：

验证 是否有正确的内部结构，并和其他类协调一致

准备 负责为类的静态成员分配内存，并设置默认初始化值

解析 将类的二进制数据中的符号引用替换为直接引用

初始化：

就是以前讲过的初始化步骤

b.类的加载时机

• 创建类的实例
• 访问类的静态变量，或者为静态变量赋值
• 调用类的静态方法
• 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
• 初始化某个类的子类
• 直接使用java.exe命令来运行某个主类

c.类加载器

负责将.class文件加载到内在中，并为之生成对应的Class对象。

虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。

d.类加载器的组成

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包和类路径

class Student {}public class ClassDemo {public static void main(String[] args) throws Exception {//方式一 Object类中的getClass方法Student s1 = new Student();Student s2 = new Student();Class c1 = s1.getClass();Class c2 = s2.getClass();System.out.println(s1==s2);System.out.println(c1==c2);//方式二 通过静态属性方法Class c3 = Student.class;Class c4 = Student.class;System.out.println(c3==c4);//方式三 通过Class类里面的一个静态方法 forName();//参数传该类的全类名  (带包的类)Class fn1 = Class.forName("Class.Student");System.out.println(fn1==c4);}}

2.反射

a.概述:

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用它的任意一个方法和属性；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的字节码文件对象。

而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

b.获取class文件对象的三种方式

i.Object类的getClass()方法

ii.静态属性class

iii.Class类中静态方法forName()

c反射的使用

i.通过反射获取构造方法并使用

1):获取所有构造方法

public Constructor<?>[] getConstructors()

获取所有的构造方法对象数组 不包含私有的

public Constructor<?>[] getDeclaredConstructors()

获取所有的构造方法对象,包括私有的

2):获取单个构造方法

public Constructor<T> getConstructor(Class<?>... parameterTypes)

获取指定的共有的构造方法

public Constructor<T> getDeclaredConstructor(Class<?>...parameterTypes)

获取指定的共有的或私有的构造方法

ii.通过反射获取成员变量并使用

1)获取所有成员变量

public Field[] getFields()

获取所有的字段 不包含私有字段

public Field[] getDeclaredFields()

获取所有字段 包含私有字段

2)获取单个成员变量

public Field getField(String name)

获取单个的公有字段

public Field getDeclaredField(String name)

获取单个的公有字段或私有字段

iii.通过反射获取成员方法并使用

1):获取所有成员方法

public Method[] getMethods()

获取所有的共有的方法对象 包括父类的公共方法

public Method[] getDeclaredMethods()

获取所有的方法对象 包括私有的

2):获取单个成员方法

public Method getMethod(String name,Class<?>...parameterTypes)

获取指定的方法对象

public Method getDeclaredMethod(String name,Class<?>...parameterTypes)

获取私有的方法对象

i.

public class Studnet {public Studnet() {System.out.println("这是无参构造");}public Studnet(String name) {System.out.println("这是有参构造"+" "+name);}private Studnet(String name , int age) {System.out.println("有参私有构造"+" "+name+" "+age);}}import java.lang.reflect.Constructor;public class Demo {@SuppressWarnings("unchecked")public static void main(String[] args) throws Exception {/*  * A:获取所有构造方法 public Constructor<?>[] getConstructors() 获取所有的构造方法对象数组 不包含私有的 public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法对象,包括私有的B:获取单个构造方法 public Constructor<T> getConstructor(Class<?>... parameterTypes)获取指定的共有的构造方法public Constructor<T>  getDeclaredConstructor(Class<?>...//获取指定的共有的或私有的构造方法parameterTypes)*///获取所有的构造方法,Class fn = Class.forName("反射2.Studnet");Constructor[] a = fn.getConstructors();for (Constructor con : a) {System.out.println(con);}System.out.println("-----------");//获取所有的构造方法,包括私有Constructor[] dc = fn.getDeclaredConstructors();for (Constructor con : dc) {System.out.println(con);}System.out.println("-----------");Constructor c1 = fn.getConstructor();Object obj1 = c1.newInstance();System.out.println(obj1);System.out.println("-----------");Constructor c2 = fn.getConstructor(String.class);Object obj2 = c2.newInstance("Yang");System.out.println(obj2);System.out.println("-----------");Constructor c3 = fn.getDeclaredConstructor(String.class, int.class);c3.setAccessible(true); //取消语法检查Object obj3 = c3.newInstance("Ash",21);System.out.println(obj3);}}

ii.

public class Fu {@Overridepublic String toString() {return "Fu [age=" + age + ", sex=" + sex + "]";}public int age;private char sex;}public class Zi extends Fu{public String name;private int money;@Overridepublic String toString() {return "Zi [name=" + name + ", money=" + money + "]";}}import java.lang.reflect.Field;public class Demo {@SuppressWarnings("unchecked")public static void main(String[] args) throws Exception {// 1)获取所有成员变量// public Field[] getFields() 获取所有的字段 不包含私有字段// public Field[] getDeclaredFields() 获取所有字段 包含私有字段// 2)获取单个成员变量// public Field getField(String name)//获取单个的公有字段// public Field getDeclaredField(String name)//获取单个的公有字段或私有字段Class fn = Class.forName("反射3.Zi");Class fn2 = Class.forName("反射3.Fu");Field[] a = fn.getFields();for (Field f1 : a) {System.out.println(f1.getName());}System.out.println("----------");Field[] b = fn.getDeclaredFields();for (Field f2 : b) {System.out.println(f2.getName());}System.out.println("----------");Field f3 = fn.getField("name");Object obj = fn.getConstructor().newInstance();f3.set(obj, "Ash");System.out.println(obj);System.out.println("----------");Field f4 = fn2.getField("age");Object obj2 = fn2.getConstructor().newInstance();f4.set(obj2, 23);System.out.println(obj2);System.out.println("----------");System.out.println("----------");System.out.println("----------");}}

iii.

public class Student {public void fun(){System.out.println("this is fun()");}public void fun(String name){System.out.println(name);}public int gun (int a){return a*a;}private void hun(int a){System.out.println(a);}}import java.lang.reflect.Method;public class Demo {@SuppressWarnings("unchecked")public static void main(String[] args) throws Exception {// 1):获取所有成员方法// public Method[] getMethods() //获取所有的共有的方法对象 包括父类的公共方法// public Method[] getDeclaredMethods()//获取所有的方法对象 包括私有的// 2):获取单个成员方法// public Method getMethod(String name,Class<?>...// parameterTypes)//获取指定的方法对象// public Method getDeclaredMethod(String name,Class<?>...//获取私有的方法对象// parameterTypes)Class fn = Class.forName("反射4_成员方法.Student");Method[] a = fn.getMethods();for (Method m : a) {System.out.println(m);}System.out.println("-----------");Method[] b = fn.getDeclaredMethods();for (Method mm : b) {System.out.println(mm);}System.out.println("-----------");Method m1 = fn.getMethod("fun",String.class );Object obj = fn.newInstance();m1.invoke(obj, "Ying");System.out.println("-----------");Method m2 = fn.getDeclaredMethod("hun", int.class);m2.setAccessible(true);m2.invoke(obj, 100);System.out.println("-----------");Method m3 = fn.getMethod("gun", int.class);System.out.println(m3.invoke(obj, 2));System.out.println("-----------");}}

3.反射案例

a.通过反射运行配置文件的内容

public class Student {public void fun(){System.out.println("this is fun()");}}public class Teaher {public void fun(){System.out.println("this is fun()");}public void hun(){System.out.println("this is hun()");}}import java.io.FileInputStream;import java.io.IOException;import java.lang.reflect.Method;import java.util.Properties;public class Demo {@SuppressWarnings("unchecked")public static void main(String[] args) throws Exception, IOException {//class_name=反射5_test.Student//method_name=fun//读取配置文件Properties p = new Properties();p.load(new FileInputStream("config.txt"));//获取某个类字节码文件对象Class fn = Class.forName(p.getProperty("class_name"));//获取方法Method dm = fn.getDeclaredMethod(p.getProperty("method_name"));//执行方法dm.invoke(fn.newInstance());}}

b.通过反射越过泛型检查

public class Student {private String name;private int age;@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + "]";}}import java.lang.reflect.Method;import java.util.ArrayList;public class Test {public static void main(String[] args) throws Exception {ArrayList<String> a = new ArrayList<>();a.add("Ying");//利用反射Class c  = a.getClass();//获取add方法对象Method dm = c.getDeclaredMethod("add", Object.class);//执行方法dm.invoke(a, 22);System.out.println(a);}}

c.通过反射给任意的一个对象的任意的属性赋值为指定的值

public class Student {private String name;private int age;@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + "]";}}import java.lang.reflect.Field;public class MyTooL {public MyTooL() {super();}// 提供设置的一个静态方法//public void setProperty(Object obj, String propertyName, Object value){}//obj 给哪个对象设置//propertyName 字段名称// value 字段值public static void setProperty(Object obj, String propertyName, Object value) throws Exception{Class class1 = obj.getClass();Field df = class1.getDeclaredField(propertyName);df.setAccessible(true);//取消语法检查df.set(obj, value);}}//(通过反射写一个通用的设置某个对象的某个属性为指定的值)(理解)//写一个工具类 可以给某个对象的某个属性设置值public class Demo {public static void main(String[] args) throws Exception {Student s = new Student();MyTooL.setProperty(s, "name", "Ash");MyTooL.setProperty(s, "age", 20);System.out.println(s);}}

4.动态代理

a.概述：

代理：

本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。

动态代理：

在程序运行过程中产生的这个对象

而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

b.Proxy类中的方法创建动态代理类对象

i.概述：

java.lang.reflect

类 Proxy

Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。

ii.方法：

public static ObjectnewProxyInstance(ClassLoaderloader,Class<?>[]interfaces, InvocationHandler h) throws IllegalArgumentException

（参数：加载器+接口+InvocationHandler子类对象）

返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

iii.Proxy类中创建动态代理对象的方法的三个参数：

ClassLoader对象：定义了由哪个ClassLoader对象来对生成的代理对象进行加载

Interface对象的数组：表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

InvocationHandler对象：表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

iv.使用：

创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。

System.out.println(u.getClass().getName());

c.InvocationHandler的方法

i.概述：

java.lang.reflect

接口 InvocationHandler

InvocationHandler 是代理实例的调用处理程序实现的接口。

ii.方法：

Objectinvoke(Objectproxy, Methodmethod, Object[]args) throws Throwable

在代理实例上处理方法调用并返回结果。

在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

iii.InvocationHandler接口中invoke方法的三个参数：

proxy:代表动态代理对象

method:代表正在执行的方法

args:代表调用目标方法时传入的实参

iv.使用：

每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke 方法来进行调用。

public interface UserOperation {public abstract void add();public abstract void delete();public abstract void update();public abstract void find();}public class UserTool implements UserOperation {@Overridepublic void add() {System.out.println("添加功能");}@Overridepublic void delete() {System.out.println("删除功能");}@Overridepublic void update() {System.out.println("更改功能");}@Overridepublic void find() {System.out.println("查找功能");}}import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class MyInvocationHandler implements InvocationHandler {private Object obj;public MyInvocationHandler(Object obj){this.obj=obj;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {System.out.println("权限校验");Object i = method.invoke(obj, args);System.out.println("日志记录表");return i;//返回来代理对象}}import java.lang.reflect.Proxy;public class Demo {public static void main(String[] args) {//不用代理直接调用方法UserOperation u= new UserTool();u.add();u.delete();u.update();u.find();System.out.println("----------");//创建代理对象//准备对u对象 做一个代理对象//public static Object newProxyInstance(ClassLoader loader,//Class<?>[] interfaces, InvocationHandler h) MyInvocationHandler mi = new MyInvocationHandler(u);UserOperation newProxy = (UserOperation) Proxy.newProxyInstance(u.getClass().getClassLoader(), u.getClass().getInterfaces(), mi);newProxy.add();newProxy.delete();newProxy.update();newProxy.find();}}

二.枚举

1.概述：

是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。

举例：一周只有7天，一年只有12个月等。

那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类

2.枚举类的引出，通过自己定义一个枚举类来演示案例 

测试类

public class DirectionDemo {public static void main(String[] args) {System.out.println("版本1.0");Direction d = Direction.QIAN;System.out.println(d);//地址值 ，说明创建对象了System.out.println("-------------");System.out.println("版本2.0");Direction2 d2 = Direction2.YOU;System.out.println(d2);System.out.println(d2.getName());System.out.println("-------------");System.out.println("版本3.0");Direction3 d3 = Direction3.HOU;System.out.println(d3);System.out.println(d3.getName());d3.fun();//编译看左边，运行看左边System.out.println("版本1.0");d3 = Direction3.ZUO;System.out.println(d3);System.out.println(d3.getName());d3.fun();}}

版本1.0

public class Direction {//创建实例public static final Direction QIAN = new Direction();public static final Direction HOU= new Direction();public static final Direction ZUO = new Direction();public static final Direction YOU = new Direction();//私有构造，别人不能创建 private Direction(){}}

版本2.0

public class Direction2 {//创建实例public static final Direction2 QIAN = new Direction2("前");public static final Direction2 HOU= new Direction2("后");public static final Direction2 ZUO = new Direction2("左");public static final Direction2 YOU = new Direction2("右");//加入成员变量private String name;private Direction2(String name){this.name=name;}public String getName(){return name;}}

版本3.0

public abstract class Direction3 {//创建子类实现抽象类的抽象方法public static final Direction3 QIAN = new Direction3("前"){;@Overridepublic void fun() {System.out.println("前");}};public static final Direction3 HOU= new Direction3("后"){@Overridepublic void fun() {System.out.println("后");}};public static final Direction3 ZUO = new Direction3("左"){@Overridepublic void fun() {// TODO Auto-generated method stubSystem.out.println("左");}};public static final Direction3 YOU = new Direction3("右"){@Overridepublic void fun() {// TODO Auto-generated method stubSystem.out.println("右");}};//加入成员变量private String name;private Direction3(String name){this.name=name;}public String getName(){return name;}//加入抽象方法public abstract void fun();}

3.枚举类

a.格式

格式是：只有枚举项的枚举类

public enum 枚举类名 {

枚举项1，枚举项2，枚举项3…;

}

b.案例演示：

测试类

public class Demo {public static void main(String[] args) {//版本1Direction e = Direction.QIAN;System.out.println(e);//public String toString()返回枚举常量的名称，它包含在声明中System.out.println("---------");//版本2Direction2 e2 =Direction2.HOU;System.out.println(e2);System.out.println(e2.getName());System.out.println("---------");//版本3Direction3 e3 = Direction3.ZUO;System.out.println(e3);System.out.println(e3.getName());e3.fun();Direction3 d = Direction3.QIAN;switch(d){case QIAN:System.out.println("你选了前");break;case HOU:System.out.println("你选了后");break;case ZUO:System.out.println("你选了左");break;case YOU:System.out.println("你选了右");break;}}}

版本1

public enum Direction{QIAN,HOU,ZUO,YOU;}

版本2

public enum Direction2 {QIAN("前"),HOU("后"),ZUO("左"),YOU("右");private String name;private Direction2(String name){this.name=name;}public String getName(){return name;}}

版本3

public enum Direction3 {QIAN("前"){@Overridepublic void fun() {System.out.println("前");}},HOU("后"){@Overridepublic void fun() {// TODO Auto-generated method stubSystem.out.println("后");}},ZUO("左"){@Overridepublic void fun() {// TODO Auto-generated method stubSystem.out.println("左");}},YOU("右"){@Overridepublic void fun() {// TODO Auto-generated method stubSystem.out.println("右");}};private String name;private Direction3(String name){this.name=name;}public String getName(){return name;}public abstract void fun();}

4.注意事项

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

  public class Demo_Switch {public static void main(String[] args) {Direction3 d = Direction3.QIAN;switch(d){case QIAN:System.out.println("你选了前");break;case HOU:System.out.println("你选了后");break;case ZUO:System.out.println("你选了左");break;case YOU:System.out.println("你选了右");break;}}}

  
  

5.枚举类中的几个常见方法

public final int compareTo(E o)

比较此枚举与指定对象的顺序。

public final Stringname()

返回此枚举常量的名称，在其枚举声明中对其进行声明。

public final intordinal()

返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

public String toString()返回枚举常量的名称，它包含在声明中。可以重写此方法，虽然一般来说没有必要。当存在更加“程序员友好的”字符串形式时，应该使用枚举类型重写此方法。

public static <T extends Enum<T>> TvalueOf(Class<T> enumType,String name)

返回带指定名称的指定枚举类型的枚举常量。名称必须与在此类型中声明枚举常量所用的标识符完全匹配。

values()

此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

public enum Direction2 {QIAN("前"),HOU("后"),ZUO("左"),YOU("右");private String name;private Direction2(String name){this.name=name;}public String getName(){return name;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn "I LOVE YOU";}}public class EnumFunction {public static void main(String[] args) {//int compareTo(E o)//public final int compareTo(E o)比较此枚举与指定对象的顺序。Direction2 d21 = Direction2.QIAN;Direction2 d22 = Direction2.HOU;Direction2 d23 = Direction2.ZUO;Direction2 d24 = Direction2.YOU;System.out.println(d21.compareTo(d24));//-3System.out.println(d24.compareTo(d21));//3System.out.println("------------");//String name()//public final String name()返回此枚举常量的名称，在其枚举声明中对其进行声明。System.out.println(d21.name());System.out.println(d22.name());System.out.println(d23.name());System.out.println(d24.name());System.out.println("------------");//int ordinal()//public final int ordinal()返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。System.out.println(d21.ordinal());//0System.out.println(d22.ordinal());//1System.out.println(d23.ordinal());//2System.out.println(d24.ordinal());//3System.out.println("------------");//String toString()//public String toString()返回枚举常量的名称，它包含在声明中。//可以重写此方法，虽然一般来说没有必要。当存在更加“程序员友好的”字符串形式时，应该使用枚举类型重写此方法。 System.out.println(d21.toString());System.out.println(d22.toString());System.out.println(d23.toString());System.out.println(d24.toString());System.out.println("------------");//<T> T valueOf(Class<T> type,String name)//public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name)//返回带指定名称的指定枚举类型的枚举常量。名称必须与在此类型中声明枚举常量所用的标识符完全匹配。Direction2 d = Direction2.valueOf(Direction2.class, "QIAN");System.out.println(d.getName());System.out.println("------------");//values() Direction2[] a = Direction2.values();for (Direction2 d1 : a) {System.out.println(d1.getName());}}}

三.JDK7新特性

1.二进制字面量

JDK7开始，终于可以用二进制来表示整数（byte,short,int和long）。

使用二进制字面量的好处是，可以使代码更容易被理解。只要在二进制数值前面加0b或者0B

int x = 0b110110

2.数字字面量可以出现下划线

为了增强对数值的阅读性，如我们经常把数据用逗号分隔一样。JDK7提供了_对数据分隔。

举例：

int x = 100_1000;

注意事项：

• 不能出现在进制标识和数值之间
• 不能出现在数值开头和结尾
• 不能出现在小数点旁边

3.switch 语句可以用字符串

4.泛型简化

5.异常的多个catch合并

6.try-with-resources 语句

try(必须是java.lang.AutoCloseable的子类对象){…}

好处：

• 资源自动释放，不需要close()了
• 把需要关闭资源的部分都定义在这里就ok了
• 主要是流体系的对象是这个接口的子类(看JDK7的API)