JavaSE基础day25 反射2、1.8新特新
一. 反射应用
(一) 反射获取成员变量并使用
1.Class类获取成员变量对象:
Field[] getFields()
返回所有公共成员变量对象的数组
Field[] getDeclaredFields()
返回所有成员变量对象的数组
Field getField(String name)
返回单个公共成员变量对象,参数name表示成员变量的名字
Field getDeclaredField(String name)
返回单个成员变量对象,参数name表示成员变量的名字
2.Field类型: 表示一个成员变量类型,每个对象都是一个具体的成员变量
作用: 获取成员变量的各种信息(修饰符、注解、名称),做各种数据类型的转换.
3.Field类用于给成员变量赋值的方法:
set(Object obj, Object value): 用于给obj对象的,指定成员变量,赋value值
4.Field类获取成员变量值的方法:
get(Object obj): 用于获取obj对象的指定成员变量值
public class Person { private String name; private String id; int age; public String sex; public String address; public String getName() { return name; } public void setName(String name) { this.name = name; } void print(){ System.out.println("我是普通print功能,默认修饰"); } private boolean equal(double d1, double d2){ return d1 == d2; } public Person(){} public Person(String name){ System.out.println(name); } Person(String name, int age){ System.out.println(name + "--" + age); } private Person(int age){ System.out.println(age); } }
import java.lang.reflect.Constructor; import java.lang.reflect.Field; public class TestReflect { public static void main(String[] args) throws Exception { // 1. 获取到Person类型的字节码文件对象 Class c = Person.class; // 2. 获取Person中所有的公共修饰的成员变量 Field[] fArr = c.getFields(); for(Field f : fArr){ System.out.println(f); } System.out.println("----------------------"); // 3. Field[] getDeclaredFields()返回所有成员变量对象的数组 Field[] fArr2 = c.getDeclaredFields(); for(Field f : fArr2){ System.out.println(f); } System.out.println("_______________________________"); // 4.Field getField(String name)返回单个公共成员变量对象,参数name表示成员变量的名字 Field f1 = c.getField("sex"); System.out.println(f1); // 6. 通过Field类型中的set方法给指定的成员变量进行赋值 // set(对象,变量值) Constructor con = c.getConstructor(); Person p = (Person)con.newInstance(); f1.set(p,"男"); // get(Object obj): 获取到参数obj对应的指定成员变量的值 // System.out.println(p.sex);// 男 String sex = (String)f1.get(p); System.out.println(sex);// 男 // 5. Field getDeclaredField(String name)返回单个成员变量对象,参数name表示成员变量的名字 Field f2 = c.getDeclaredField("age"); Field f3 = c.getDeclaredField("name"); System.out.println(f2); System.out.println(f3); /* f3.set(p,"张三"); System.out.println(p.getName());*/ } }
(二) 反射获取类中的成员方法并执行
1.Class类获取成员方法对象:
Method[] getMethods()
返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()
返回所有成员方法对象的数组，不包括继承的
Method getMethod(String methodName, Class<?>...parameterTypes)
返回单个公共成员方法对象
Method getDeclaredMethod(String methodName, Class<?>...parameterTypes)
返回单个成员方法对象
2.Method类型:
(1) 表示成员方法的类型,该类型的每个对象,都是一个具体的成员方法
(2) 成员方法对象具有的功能: 获取成员方法信息,运行方法.
3.Method类用于执行方法的功能:
invoke(Object obj, Object...values):调用obj对象的成员方法,参数是values是运行方法的实际参数,返回值Object类型是方法运行的返回值结果.
public class Person { private String name; private String id; int age; public String sex; public String address; public String getName() { return name; } public void setName(String name) { this.name = name; } void print(){ System.out.println("我是普通print功能,默认修饰"); } private boolean equal(double d1, double d2){ return d1 == d2; } public Person(){} public Person(String name){ System.out.println(name); } Person(String name, int age){ System.out.println(name + "--" + age); } private Person(int age){ System.out.println(age); } }
import java.lang.reflect.Method; public class ReflectMethod { public static void main(String[] args) throws Exception{ // 1. 获取到Person类型的字节码文件对象 Class c = Class.forName("com.ujiuye.reflect.Person"); // 2. 获取Person中所有的公共修饰的方法(包括继承到的) Method[] allPubMethod = c.getMethods(); for(Method m : allPubMethod){ System.out.println(m); } System.out.println("-----------------"); // 3.Method[] getDeclaredMethods()返回所有成员方法对象的数组，不包括继承的 Method[] allMethod = c.getDeclaredMethods(); for(Method m : allMethod){ System.out.println(m); } System.out.println("--------------------------------"); // 4. Method getMethod(String methodName, Class<?>...parameterTypes)返回单个公共成员方法对象 // 第一个参数表示方法名称; 第二个参数是这个方法对应的参数列表 (因为方法可以有重载形式,因此获取某一个方法时必须说明 // 方法名称和参数列表) Method m1 = c.getMethod("setName",String.class); System.out.println(m1); // invoke(Object obj, Object...values): 第一个参数是一个对象, 第二个参数表示当前方法调用时传递的实际参数 // 注意: 如果一个类型中有公共修饰的, 空参数构造方法, Class类型中有newInstance() 快速创建出指定类型对象,调用的就是 // 这个类型的空参数构造方法 Person p1 = (Person)c.newInstance(); m1.invoke(p1,"小六六"); Method m3 = c.getMethod("getName"); System.out.println(m3); String name = (String)m3.invoke(p1); System.out.println(name); // 5. Method getDeclaredMethod(String methodName, Class<?>...parameterTypes)返回单个成员方法对象 Method m2 = c.getDeclaredMethod("equal",double.class,double.class); System.out.println(m2); boolean boo = (Boolean)m2.invoke(p1,3.14,3.14); System.out.println(boo); } }
(三) 暴力反射
1.通过Class类中:
getDeclaredXXX方法: 可以获取类中所有声明的成员(属性、方法、构造),私有的成员也可以获取到.但是私有成员进行访问使用时,会因为权限问题导致失败,因此就需要暴力反射解决访问私有的问题
2.修改该对象的访问权限:
AccessibleObject类是Field,Method和Constructor对象的基类. 它提供了将反射对象标记为在使用它时抑制默认Java语言访问控制检查的功能.
setAccessible(boolean flag): true的值表示反射对象应该在使用时抑制Java语言访问检查,false的值表示反映的对象应该强制执行Java语言访问检查.
3.一旦设定当前对象可以访问,私有的成员也可以被访问,被修改.
public class Person { private String name; private String id; int age; public String sex; public String address; public String getName() { return name; } public void setName(String name) { this.name = name; } void print(){ System.out.println("我是普通print功能,默认修饰"); } private boolean equal(double d1, double d2){ return d1 == d2; } public Person(){} public Person(String name){ System.out.println(name); } Person(String name, int age){ System.out.println(name + "--" + age); } private Person(int age){ System.out.println(age); } }
import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; public class 暴力反射 { public static void main(String[] args) throws Exception { // 1. 获取到Person类型字节码文件对象 Class c = Person.class; // 2. 获取Person中的私有构造 Constructor privateCon = c.getDeclaredConstructor(int.class); // 将构造方法进行暴力反射 privateCon.setAccessible(true); Person p = (Person) privateCon.newInstance(18); System.out.println(p); // 3. 获取到Person中的私有成员变量 Field f = c.getDeclaredField("name"); // 将成员变量name进行暴力反射 f.setAccessible(true); f.set(p, "王五"); // 4. 获取到Person中私有方法 Method m = c.getDeclaredMethod("equal",double.class, double.class); // 将方法进行暴力反射 m.setAccessible(true); boolean boo = (Boolean)m.invoke(p,6.6,6.6); System.out.println(boo); } }
(四) 泛型擦除案例
定义出一个ArrayList<String> 集合,泛型中只能存储String类型数据, 利用反射机制,向该集合中成功添加Integer类型数据
import java.lang.reflect.Method; import java.util.ArrayList; public class 泛型擦除 { public static void main(String[] args) throws Exception{ // 定义出一个ArrayList<String> 集合,泛型中只能存储String类型数据, // 利用反射机制,向该集合中成功添加Integer类型数据 ArrayList<String> list = new ArrayList<>(); list.add("abc"); // 1. 获取到ArrayList类型字节码文件对象 Class c = Class.forName("java.util.ArrayList"); // 2. 获取到ArrayList集合中的add方法 Method m = c.getDeclaredMethod("add",Object.class); // 3. 运行m方法 m.invoke(list,12); m.invoke(list,6.89); System.out.println(list); } }
二. JDK新特性
(一) 接口的新特性
1. 概述:
jdk8之前接口是规则的集合体，方法只有抽象方法。
jdk8版本开始不光有抽象方法同时增加了实体方法。
2. 增加内容:
jdk8：default默认方法, static静态方法
jdk9: private私有方法
1.1 默认方法
1. 被关键字 default 修饰的方法就是默认方法,是在jdk8版本才出现的方法,独属于接口所有。
2. 出现的原因：在jdk8版本的时候，需要对一个接口下面的所有的实现类的功能做一个增强，就需要在接口当中去添加方法，如果接口中添加的是抽象方法，下面的实现类就需要强制去重写这些抽象方法，jdk希望在接口当中添加方法，直接就让下面的实现类去使用，不用再次的进行重写，所以添加了使用default做修饰的默认方法，默认方法是可以不被重写的，因为他有方法体。
3. 语法格式:
修饰符 default 返回值类型 方法名 (参数列表){方法体}
4. 使用规则:
(1) 加上default的,实现类可以不重写，直接调用
(2) 特殊情况1：实现类实现了两个接口，如果有相同的默认方法声明，则强制要求在实现类中，重写这个方法，以指定确定的实现内容
(3) 特殊情况2：在特殊情况1中，如果在实现类重写这个方法的过程中，希望指定其中某一个接口的默认实现，则可以调用”父接口名.super.默认方法名称(实际参数)”
(4) 特殊情况3：实现类实现了继承了一个父类，并且实现了一个接口，并且在父类中和接口中，有相同的方法声明，则“类优先”。即使继承的是一个抽象类，也是使用父类的实现（即强制重写）。
5. 产生的影响
(1) 接口中如果也可以定义非抽象方法，那么接口和抽象类的差别就越来越小
(2) java中一个类只能继承一个抽象类，但是可以同时实现多个接口,所以有了默认方法，就会让大量的抽象类变成接口，即弱化了抽象类
public interface MyInterface { // 1. JDK8之前: 接口中的方法只有抽象方法, 默认修饰符 public abstract void show(); // 2. 在JDK8版本: 可以在接口中添加默认方法default, 还有静态方法static /* 接口中添加默认方法目的: 为了后期便于接口的维护,默认方法可以直接被实现类继承使用,不强制重写 */ public default int getSum(int x, int y){ return x + y; } }
public class MyInterfaceImpl extends Fu implements MyInterface,InterfaceOther{ @Override public void show() { System.out.println("重写了父接口中的抽象方法"); } @Override public void fun() { } // 1. 如果一个类同时实现多个接口, 并且父接口中定义出相同的默认方法声明,导致实现类继承的默认方法冲突 // ,于是要求实现类必须重写重复的默认方法 /*@Override public int getSum(int x, int y){ System.out.println("我是重写的默认方法"); // 2. 如果实现类想要调用父接口中的默认方法 父接口名.super.默认方法(实际参数); return InterfaceOther.super.getSum(x,y); // return x * y; }*/ }
public class Fu { public int getSum(int x, int y){ return (x + y) * 10; } }
public interface InterfaceOther { void fun(); public default int getSum(int x, int y){ return 2 * x * y; } }
public class TestInterface { public static void main(String[] args) { // 1. 实现类可以直接继承使用从父接口中继承到的默认方法 MyInterfaceImpl mil = new MyInterfaceImpl(); mil.show(); System.out.println(mil.getSum(4,5)); } }
1.2 静态方法
1、接口的静态方法可以定义方法体内容
2、static不能和abstract共存
3、外界只能通过接口名称.静态方法来访问接口静态方法
4、实现类中不会继承接口中的静态方法，原因：如果一个类同时实现了两个接口，具有相同的静态方法名，继承之后不知道应该以哪个为准, 而静态方法又不能重写，因此矛盾无法解决
public interface MyInterface { // 3. JDK8版本中: 可以添加静态方法static // 1) 静态方法只属于接口本身, 可以用接口名.直接调用 // 2) 接口中的静态方法不给实现类继承使用 public static void print(int n){ for(int i = 1; i <= n; i++){ System.out.println(i); } } }
public class TestInterface { public static void main(String[] args) { // 2. 接口中的静态方法不能给实现类继承使用 MyInterface.print(5); //MyInterfaceImpl.print(6); } }
1.3 私有方法
1. 概述: 私有方法是jdk9版本增加的一个实体方法，主要是用来进一步封装代码，提升相关代码安全性的手段。私有化之后方法不能被实现类直接调用使用或重写修改，只能提供给接口的静态方法和默认方法使用。
2. 使用:
(1) 普通私有方法：只能提供给默认方法调用使用
(2) 静态私有方法：默认方法和静态方法都可以调用
静态方法只能使用静态的私有方法，不能使用普通的私有方法
public interface MyInterface { public default void fun(){ // fun中有很多逻辑代码,实现类就可以直接将这些代码继承,使用 // 于是为了安全度考虑, 可以将fun中的部分代码逻辑封装在一个私有方法中 test(); testShow(); } public static void show(){ testShow(); } // 1. 普通私有方法只能在当前接口中的默认方法中调用 private void test(){ System.out.println("你好"); } // 2. 静态私有方法即可以在默认方法中调用, 也可以在静态方法中进行调用 private static void testShow(){ System.out.println("我是为了静态方法代码安全性考虑设计"); } }
浙公网安备 33010602011771号