本期知识点：
反射
枚举
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 {
@Override
public 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;
@Override
public 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;
@Override
public 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;
@Override
public 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 Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
（参数：加载器+接口+InvocationHandler子类对象）
返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
iii.Proxy类中创建动态代理对象的方法的三个参数：
ClassLoader对象：定义了由哪个ClassLoader对象来对生成的代理对象进行加载
Interface对象的数组：表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
InvocationHandler对象：表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
iv.使用：
创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。
c.InvocationHandler的方法
i.概述：
java.lang.reflect
接口 InvocationHandler
InvocationHandler 是代理实例的调用处理程序实现的接口。
ii.方法：
Object invoke(Object proxy, Method method, 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 {
@Override
public void add() {
System.out.println("添加功能");
}
@Override
public void delete() {
System.out.println("删除功能");
}
@Override
public void update() {
System.out.println("更改功能");
}
@Override
public 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;
}
@Override
public 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("前"){;
@Override
public void fun() {
System.out.println("前");
}
};
public static final Direction3 HOU= new Direction3("后"){
@Override
public void fun() {
System.out.println("后");
}
};
public static final Direction3 ZUO = new Direction3("左"){
@Override
public void fun() {
// TODO Auto-generated method stub
System.out.println("左");
}
};
public static final Direction3 YOU = new Direction3("右"){
@Override
public void fun() {
// TODO Auto-generated method stub
System.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) {
// 版本1
Direction e = Direction.QIAN;
System.out.println(e);//public String toString()返回枚举常量的名称，它包含在声明中
System.out.println("---------");
// 版本2
Direction2 e2 =Direction2.HOU;
System.out.println(e2);
System.out.println(e2.getName());
System.out.println("---------");
// 版本3
Direction3 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("前"){
@Override
public void fun() {
System.out.println("前");
}
},HOU("后"){
@Override
public void fun() {
// TODO Auto-generated method stub
System.out.println("后");
}
},ZUO("左"){
@Override
public void fun() {
// TODO Auto-generated method stub
System.out.println("左");
}
},YOU("右"){
@Override
public void fun() {
// TODO Auto-generated method stub
System.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;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "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));//-3
System.out.println(d24.compareTo(d21));//3
System.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());//0
System.out.println(d22.ordinal());//1
System.out.println(d23.ordinal());//2
System.out.println(d24.ordinal());//3
System.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)
