目录
1.什么是反射?
反射：是框架设计的灵魂。它就是把类中成员封装到其他类对象的形式。在通过该类对象可以获取成员的信息。
框架： 它就是一个半成品，客户可以引入该框架，在框架的基础上填写自己的业务代码。提高开发效率。 比如: springmvc mybatis框架 。
2.获取Class反射类的方式
获取CLass反射类共有三种方式：
- Class.forName("类的全路径")
- 类.class
- 对象名.getClass();
package com.aaa.demo08;
public class Test08 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//第一种方法：Class.forName("类的全路径")
Class<?> aClass1 = Class.forName("com.aaa.demo08.Student");
//第二种方法：类.class
Class<Student> aClass2 = Student.class;
//第三种方法：对象名.getClass()
Student student = new Student();
Class<? extends Student> aClass3 = student.getClass();
Class<? extends Student> aClass4 = student.getClass();
//判断这三个对象的引用地址是否相同
System.out.println(aClass1);
System.out.println(aClass1==aClass2);
System.out.println(aClass1==aClass3);
System.out.println(aClass2==aClass3);
//System.out.println(aClass4==aClass3);
}
}
package com.aaa.demo08;
public class Student {
private String name;
private Integer age;
private String address;
public void show(){
System.out.println("hello");
}
public Student() {
}
public Student(String name, Integer age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}3.通过反射类获取对应的类对象
反射类调用newInstance（）；
public class Test02 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
Class<Student> studentClass = Student.class;
Student student = studentClass.newInstance();
Student student1 = studentClass.newInstance();
System.out.println(student);
System.out.println(student1);
System.out.println(student==student1);
Class<Student> aClass = (Class<Student>) Class.forName("com.aaa.demo01.Student");
Student student2 = aClass.newInstance();
Student student3 = new Student();
Class<? extends Student> aClass1 = student3.getClass();
Student student4 = aClass1.newInstance();
System.out.println(student3);
System.out.println(student4);
}
}4.获取反射类中的属性类对象
4.1获取反射类中的属性类对象
- getDelaredFields()：获取该类中全部属性对象
- getDelaredField(String name)：获取该类中指定名称的属性对象
- getFields()：获取该类和父类中全部public修饰的属性对象
- getField(String name)：获取该类和父类中指定名称的被public修饰的属性对象
package com.aaa.demo02;
import java.lang.reflect.Field;
public class Test002 {
public static void main(String[] args) throws NoSuchFieldException {
//获取反射类
Class<Student> studentClass = Student.class;
//1.获取该类中全部属性对象
Field[] declaredFields = studentClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//2.获取该类中指定名称的属性对象
Field age = studentClass.getDeclaredField("age");
System.out.println(age);
//3.获取该类以及父类中被public修饰的属性对象
Field[] fields = studentClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
//4.获取该类以及父类中指定名称且被public修饰的属性对象
Field hobby = studentClass.getField("hobby");
System.out.println(hobby);
}
}
class People{
public String hobby;
private String address;
}
class Student extends People{
private String name;
private Integer age;
public Integer idCard;
public Student() {
}
public Student(String name, Integer age, Integer idCard) {
this.name = name;
this.age = age;
this.idCard = idCard;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Integer getIdCard() {
return idCard;
}
public void setIdCard(Integer idCard) {
this.idCard = idCard;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", idCard=" + idCard +
'}';
}
}
4.2Field类中常见的方法
setAccessible(true); //设置私有访问权限
getAnnotation(注解.class):获取属性上的注解对象
package com.aaa.demo03;
import java.lang.annotation.*;
import java.lang.reflect.Field;
public class Test03 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException {
Class<Teacher> aClass = Teacher.class;
Teacher teacher = aClass.newInstance();
System.out.println(teacher);
Field name = aClass.getDeclaredField("name");
Field address = aClass.getDeclaredField("address");
Field[] declaredFields = aClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
name.set(teacher,"zkl");
System.out.println(teacher);
//允许访问私有属性
address.setAccessible(true);
address.set(teacher,"郑州");
System.out.println(teacher);
//获取该属性上的指定名称的注解
My annotation = address.getAnnotation(My.class);
System.out.println(annotation.value());
}
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface My{
String value();
}
class Teacher{
public String name;
@My(value = "地址")
private String address;
public Teacher() {
}
public Teacher(String name, String address) {
this.name = name;
this.address = address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}
5. 获取方法类对象
5.1获取方法类对象
getMethods(): //获取本类以及父类中public修饰的方法对象
getMethod(name,Class...):获取本类以及父类中指定名称public修饰的方法对象
getDeclaredMethods():获取本类中所有的Method方法对象
getDeclaredMethod(name,Class 参数的类型):获取本类中指定名称的方法对象
package com.aaa.demo04;
import java.lang.reflect.Method;
public class Test04 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, NoSuchFieldException {
Class<Show> showClass = Show.class;
Show show = showClass.newInstance();
//1.getMethods():获取本类以及父类中public修饰的方法对象
Method[] methods = showClass.getMethods();
for (Method method : methods) {
System.out.println(method);
}
//2.getMethod(name,Class...):获取本类以及父类中指定名称public修饰的方法对象
Method hello2 = showClass.getMethod("hello2", String.class);
System.out.println(hello2);
//3.getDeclaredMethods():获取本类中所有的Method方法对象
Method[] declaredMethods = showClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
//4.getDeclaredMethod(name,Class 参数的类型):获取本类中指定名称的方法对象
Method hello3 = showClass.getDeclaredMethod("hello3");
System.out.println(hello3);
}
}
class Show{
public String hello1(){
System.out.println("Hello world 01");
return "======1";
}
public String hello2(String name){
System.out.println("Hello world 01");
return "======1";
}
private String hello3(){
System.out.println("Hello world 01");
return "======1";
}
}
5.2Method类中常见的方法
invoke(Object o,Object... values): 执行该方法体。
getAnnotation():获取方法上的注解对象
package com.aaa.demo04;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test05 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
Class<Fun> funClass = Fun.class;
Fun fun = funClass.newInstance();
//hello2
Method hello2 = funClass.getMethod("hello2", String.class, Integer.class);
//执行该方法体
Object zkl = hello2.invoke(fun, "zkl", 25);
System.out.println(zkl);
//获取该属性的注解对象
My02 annotation = hello2.getAnnotation(My02.class);
System.out.println(annotation.value());
//hello3
Method hello3 = funClass.getDeclaredMethod("hello3");
hello3.setAccessible(true);
Object invoke = hello3.invoke(fun);
System.out.println(invoke);
}
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface My02{
String value();
}
class Fun{
public String hello1() {
System.out.println("Hello world 01");
return "======1";
}
@My02("今天是周五")
public String hello2(String name, Integer age) {
System.out.println("name:" + name + " age:" + age);
return "======1";
}
private String hello3() {
System.out.println("Hello world 01");
return "======1";
}
}6.获取Constructor对象
6.1获取Constructor对象
getConstructors(): //获取该类所有public构造方法。
getConstructor(Class...params):获取类中指定参数列表的public构造方法。
getDeclaredConstructors():获取该类所有的构造方法。
getDeclaredConstructor(Class...params):获取类中指定参数列表的构造方法。
package com.aaa.demo05;
import java.lang.reflect.Constructor;
public class Test005 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
Class<Son> sonClass = Son.class;
Son son = sonClass.newInstance();
Constructor<?>[] declaredConstructors = sonClass.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor);
}
Constructor<?>[] constructors = sonClass.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
}
}
class Father{
public Father() {
System.out.println("父类中的无参构造函数");
}
public Father(String name) {
System.out.println("父类中的无参构造函数");
}
}
class Son extends Father{
public Son(){
System.out.println("子类中的无参构造函数");
}
public Son(Integer age){
System.out.println("子类中的有参构造函数");
}
private Son(String name){
System.out.println("子类中的有参私有构造函数");
}
}
6.2Constructor类中常用的方法
package com.aaa.demo05;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Test005 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
Class<Son> sonClass = Son.class;
Constructor<Son> declaredConstructor = sonClass.getDeclaredConstructor(Integer.class);
Son son = declaredConstructor.newInstance(56);
Constructor<Son> declaredConstructor1 = sonClass.getDeclaredConstructor(String.class);
declaredConstructor1.setAccessible(true);
Son zkl = declaredConstructor1.newInstance("zkl");
}
}
class Father{
public Father() {
System.out.println("父类中的无参构造函数");
}
public Father(String name) {
System.out.println("父类中的无参构造函数");
}
}
class Son extends Father{
public Son(){
System.out.println("子类中的无参构造函数");
}
public Son(Integer age){
System.out.println("子类中的有参构造函数"+age);
}
private Son(String name){
System.out.println("子类中的有参私有构造函数"+name);
}
}
1556
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
