反射

最新推荐文章于 2024-03-14 22:23:11 发布

qwy715229258163

最新推荐文章于 2024-03-14 22:23:11 发布

阅读量131

点赞数 1

分类专栏： java基础学习文章标签： java 反射 class jvm

本文链接：https://blog.csdn.net/qwy715229258163/article/details/115321382

版权

java基础学习专栏收录该内容

65 篇文章 0 订阅

订阅专栏

关于反射我们首先看一个实例：

package com.qwy.reflection1;

/**
 * @author qwy
 * @create 2021-03-30 11:26
 **/
//定义类
class Person{

}
public class TestReflection {
    public static void main(String[] args) {
        Person p= new Person();
        String name = p.getClass().getName();
        System.out.println("name = " + name);
        
    }
}

运行结果：
name = com.qwy.reflection1.Person

说明：
在正常情况下，我们要使用一个类需要先引入这个类的完整的路径之后对该类进行实例化，才能够使用这个类产生的实例对象。在java中也允许通过一个实例化对象找到一个类的完整信息，那么这就是我们所要讲解的Class类的功能。
从程序的结果可以看出，通过一个对象得到了对象所在的完整的“包.类”名称。其实getClass()方法是从Object类中继承来的，此方法的定义：public final Class getClass()。可以发现此方法返回的类型是一个Class类。实际上此类就是java反射的源头。所谓反射，从程序的运行结果来看也就不难理解，即可以通过对象的反射求出类的名称。

反射的概念

反射就是Reflection，Java的反射是指程序在运行期可以借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法等。
说到反射不得不提一下类的加载过程：
1.程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。
2.当我们使用java.exe命令对某个字节码文件进行解释运行。此时此字节码文件加载到内存中。这个过程就称为类的加载。加载到内存中的类，我们就称为运行时类（如上例中的Person类），此运行时类，就作为Class的一个实例。我们可以这样理解：每一的类本身就是Class的一个实例（一个类只有一个Class对象）。

一个运行时类（Class的实例对象）包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射

获取Class实例的四种方式

package com.qwy.reflection1;

/**
 * @author qwy
 * @create 2021-03-30 11:26
 **/
//定义类
class Person{

}

/**
 * 获取Class实例的4中方式
 */
public class TestReflection {
    public static void main(String[] args) throws ClassNotFoundException {
        //方式1：通过类的class属性方式
        Class<Person> p1 = Person.class;
        System.out.println("p1 = " + p1);
        //方式2：通过运行时类的对象,调用getClass()
        Person person= new Person();
        Class<? extends Person> p2 = person.getClass();
        System.out.println("p2 = " + p2);
        //方式3：通过Class的静态方法forName(类的全不限定名称),这种方式需要抛出异常
        Class<?> p3 = Class.forName("com.qwy.reflection1.Person");
        System.out.println("p3 = " + p3);
        //方式4：使用类加载器的方式
        Class<?> p4 = TestReflection.class.getClassLoader().loadClass("com.qwy.reflection1.Person");
        System.out.println("p4 = " + p4);

        System.out.println(p1 == p2);
        System.out.println(p1 == p3);
        System.out.println(p1 == p4);
    }
}

运行结果：
p1 = class com.qwy.reflection1.Person
p2 = class com.qwy.reflection1.Person
p3 = class com.qwy.reflection1.Person
p4 = class com.qwy.reflection1.Person
true
true
true

不难看出四种获取Class实例的方式，此时获取的运行时类是同一个。事实上，加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类都是同一个。只是获取的方式不同而已。

可以作为Class实例的类型

package com.qwy.reflection1;

import java.lang.annotation.ElementType;

/**
 * @author qwy
 * @create 2021-03-30 13:41
 **/
public class TestReflection2 {
    public static void main(String[] args) {
        //Object类型
        Class c1 = Object.class;
        System.out.println("c1 = " + c1);
        //接口类型
        Class c2 = Comparable.class;
        System.out.println("c2 = " + c2);
        //字符串数组
        Class c3 = String[].class;
        System.out.println("c3 = " + c3);
        //多维数组
        Class c4 = int[][].class;
        System.out.println("c4 = " + c4);
        //注解类型
        Class c5 = ElementType.class;
        System.out.println("c5 = " + c5);
        //重写类型
        Class c6 = Override.class;
        System.out.println("c6 = " + c6);
        //基本数据类型
        Class c7 = int.class;
        System.out.println("c7 = " + c7);
        //返回值 void 类型
        Class c8 = void.class;
        System.out.println("c8 = " + c8);
        //Class类型
        Class c9 = Class.class;
        System.out.println("c9 = " + c9);
        int[] a = new int[10];
        System.out.println("a = " + a);
        int[] b = new int[100];
        System.out.println("b = " + b);
        Class c10 = a.getClass();
        Class c11 = b.getClass(); // 只要元素类型与维度一样，就是同一个 Class 
       System.out.println(c10 == c11);

    }
}

运行结果：
c1 = class java.lang.Object
c2 = interface java.lang.Comparable
c3 = class [Ljava.lang.String;
c4 = class [[I
c5 = class java.lang.annotation.ElementType
c6 = interface java.lang.Override
c7 = int
c8 = void
c9 = class java.lang.Class
a = [I@4554617c
b = [I@74a14482
true

从运行结果看，java中几乎所有的类型都可以作为Class的实例（包括基本数据类型）。

反射机制的主要功能

1.在运行期判断某个对象所属的类
2. 在运行期创建某个类的对象
3. 在运行期判断一个类所有的成员变量和方法
4. 在运行期获取泛型信息
5. 在运行期调用一个对象的成员变量和方法
6. 在运行期处理注解
7. 可以用作动态代理
8. …

反射机制主要的API

1.java.lang.Class:代表一个运行时类的对象
2.java.lang.reflect.Method:表示类中的方法
3.java.lang.reflect.Field:表示类的成员变量
4.java.lang.reflect.Constructor:表示类的构造方法
5.java.lang.reflect.Proxy：动态代理类（以下简称为代理类）是一个实现在创建类时在运行时指定的接口列表的类
6…

通过反射创建运行时类的对象

package com.qwy.reflection2;

/**
 * @author qwy
 * @create 2021-03-30 14:55
 **/
class Person{
    private String name;
    private int age;

    public Person() {
        System.out.println("Person.Person---无参构造");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class TestNewInstance {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        Class<Person> clazz = Person.class;
        //根据运行时类，获取对应的类的实例
        Person person = clazz.newInstance();
        person.setName("张三");
        person.setAge(12);

        System.out.println("person = " + person);

    }
}

运行结果：
Person.Person—无参构造
person = Person{name=‘张三’, age=12}

从运行结构发现，clazz.newInstance() 底层调用的无参构造方法。这就要求我们在创建类时，提供一个无参构造器，以便在使用反射时，创建该类的对象。需要注意一点是，构造器的访问权限应该能使外部类调用到。

关于Class类的理解

通过上例我们发现一个运行时类的实例可以使用Class来接收。根据反射的定义，某个类的属性、方法和构造器、某个类到底实现了哪些接口。JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

Class类本身也是一个类
Class对象只能由系统创建对象
一个被加载的类，在JVM中只能有一个Class实例。
一个Class对象对应着一个加载到JVM中的一个*.class文件
每一个类的实例都会保留自己是由哪一个Class实例所创建的
我们可以通过Class获取到一个类中所有的结构
Class是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的 Class对象
在Object类中定义了 public final Class getClass()

Class类中常用的方法

public static Class<?> forName(String className) throws ClassNotFoundException//传入完整的“包.类”名称实例化Class对象
public Constructor[] getConstructors() throws SecurityExcepton//得到一个类的全部构造方法
public Field[] getDeclaredFields() throws SecurityException//得到本类中单独定义的全部属性
public File[] getFields() throws SecurityException//取得本类所有公共属性
public Method[] getMethods() throws SecurityException//取得类中的全部方法
public Method getMethod(String name,Class… parameterTpys) throws NoSuchMethodException,SecurityException//返回一个Method对象，并设置一个方法中所有参数类型
public Class[] getInterfaces()//得到一个类中所有实现的全部接口
public String getName()//得到一个类中完整的“包.类“名称
public Package getPackage()//得到一个类的包
public Class getSuperclass()//得到一个类的父类
public Object newInstance() throws InstantiationException,IllegalAccessException//根据Class定义的类实例化对象
public Class<?> getComponentType()//返回表示数组类型的Class
public boolean isArray()//判断次Class是否是一个数组
ClassLoader getClassLoader() //返回该类的类加载器。
…
通过Class.forName()获取运行时类实例

package com.qwy.reflection3;

/**
 * @author qwy
 * @create 2021-03-30 15:31
 **/
class Person{
    private String name;
    private int age;

    public Person() {
        System.out.println("Person.Person---无参构造");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class TestForName {
    public static void main(String[] args) {
        try {
            //获取运行时类的实例
            Class<?> clazz = Class.forName("com.qwy.reflection3.Person");
            System.out.println("clazz = " + clazz);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
clazz = class com.qwy.reflection3.Person

获取运行类的所有构造方法

package com.qwy.reflection3;

import java.lang.reflect.Constructor;

/**
 * @author qwy
 * @create 2021-03-30 15:31
 **/
class Person{
    private String name;
    private int age;

    public Person() {
        System.out.println("Person.Person---无参构造");
    }
    private Person(String name){
        this.name=name;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class TestConstructor {
    public static void main(String[] args) {
        try {
            //获取运行时类的实例
            Class<?> clazz = Class.forName("com.qwy.reflection3.Person");
            System.out.println("获取公共的构造方法：");
            Constructor<?>[] constructors = clazz.getConstructors();
            for (Constructor c:constructors) {
                System.out.println("c = " + c);
            }
            System.out.println("获取所有的构造方法（包含私有的构造方法）：");
            Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
            for (Constructor c:declaredConstructors) {
                System.out.println("c = " + c);
            }
            System.out.println("获取指定类型的构造方法（不能获取私有的构造方法）：");
            //获取指定类型的构造方法(此方法只能获取公共的构造方法)
            Constructor<?> constructor = clazz.getConstructor(String.class,int.class);
            System.out.println("constructor = " + constructor);
            System.out.println("获取指定类型的构造方法（包括获取私有的构造方法）：");
            //获取指定的构造方法（可以获取是私有的构造方法）
            Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(String.class);
            System.out.println("declaredConstructor = " + declaredConstructor);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
获取公共的构造方法：
c = public com.qwy.reflection3.Person(java.lang.String,int)
c = public com.qwy.reflection3.Person()
获取所有的构造方法（包含私有的构造方法）：
c = public com.qwy.reflection3.Person(java.lang.String,int)
c = private com.qwy.reflection3.Person(java.lang.String)
c = public com.qwy.reflection3.Person()
获取指定类型的构造方法（不能获取私有的构造方法）：
constructor = public com.qwy.reflection3.Person(java.lang.String,int)
获取指定类型的构造方法（包括获取私有的构造方法）：
declaredConstructor = private com.qwy.reflection3.Person(java.lang.String)

通过获取的构造方法实例化对象

package com.qwy.reflectionr4;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author qwy
 * @create 2021-03-30 15:31
 **/
class Person{
    private String name;
    private int age;

    public Person() {
        System.out.println("Person.Person---无参构造");
    }
    //私有的构造方法
    private Person(String name){
        this.name=name;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class TestConstructor {
    public static void main(String[] args) {
      
            //获取运行时类的实例
        try {
            Class<?> clazz = Class.forName("com.qwy.reflectionr4.Person");
            System.out.println("使用非私有的构造方法：");
            //调用非私有的构造方法
            Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
            Person p1 = (Person) constructor.newInstance("小明", 12);
            System.out.println("p1 = " + p1);
            System.out.println("使用私有的构造方法：");
            //调用私有的构造方法
            Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(String.class);
            //设置私有的构造方法可以访问，否则会报java.lang.IllegalAccessException异常
            declaredConstructor.setAccessible(true);
            Person p2 = (Person) declaredConstructor.newInstance("张三");
            System.out.println("p2 = " + p2);
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}

运行结果：
使用非私有的构造方法：
p1 = Person{name=‘小明’, age=12}
使用私有的构造方法：
p2 = Person{name=‘张三’, age=0}

注意：使用私有的构造方法时，需要设置构造方法可以访问，否则报java.lang.IllegalAccessException异常。
获取属性

package com.qwy.reflectionr5;

import java.lang.reflect.Field;

/**
 * @author qwy
 * @create 2021-03-30 16:11
 **/
class Person{
    private String name;
    private int age;
    public String sex;

    public Person() {
        System.out.println("Person.Person---无参构造");
    }
    //私有的构造方法
    private Person(String name){
        this.name=name;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}
class Student extends  Person{
    private int score;
    public String subject;
}
public class TestField {
    public static void main(String[] args) {
        try {
        Class<Student> clazz = Student.class;
        System.out.println("获取本类所有的公共属性：");
        Field[] fields = clazz.getFields();
        for (int  i = 0;  i <fields.length ;  i++) {
            System.out.println("fields = " + fields[i]);
        }
        System.out.println("获取本类所有的属性：");
        Field[] declaredFields = clazz.getDeclaredFields();
        for (int i = 0; i <declaredFields.length ; i++) {
            System.out.println("declaredFields = " + declaredFields[i]);
        }
        System.out.println("获取父类所有的公共属性：");
        Field[] fields1 = clazz.getSuperclass().getFields();
        for (int  i = 0;  i <fields1.length ;  i++) {
            System.out.println("fields1 = " + fields1[i]);
        }
        System.out.println("获取父类所有的属性：");
        Field[] declaredFields1 = clazz.getSuperclass().getDeclaredFields();
        for (int i = 0; i <declaredFields1.length ; i++) {
            System.out.println("declaredFields1 = " + declaredFields1[i]);
        }
        System.out.println("获取指定本类公共的属性(只能获取公共的)：");
            Field subject = clazz.getField("subject");
            System.out.println("subject = " + subject);
            System.out.println("获取指定本类私有的属性（可以获取私有的）：");
            Field score = clazz.getDeclaredField("score");
            System.out.println("score = " + score);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：
获取本类所有的公共属性：
fields = public java.lang.String com.qwy.reflectionr5.Student.subject
fields = public java.lang.String com.qwy.reflectionr5.Person.sex
获取本类所有的属性：
declaredFields = private int com.qwy.reflectionr5.Student.score
declaredFields = public java.lang.String com.qwy.reflectionr5.Student.subject
获取父类所有的公共属性：
fields1 = public java.lang.String com.qwy.reflectionr5.Person.sex
获取父类所有的属性：
declaredFields1 = private java.lang.String com.qwy.reflectionr5.Person.name
declaredFields1 = private int com.qwy.reflectionr5.Person.age
declaredFields1 = public java.lang.String com.qwy.reflectionr5.Person.sex
获取指定本类公共的属性(只能获取公共的)：
subject = public java.lang.String com.qwy.reflectionr5.Student.subject
获取指定本类私有的属性（可以获取私有的）：
score = private int com.qwy.reflectionr5.Student.score
操作属性

package com.qwy.reflectionr6;

import java.lang.reflect.Field;

/**
 * @author qwy
 * @create 2021-03-30 16:39
 **/
class Person{
    private String name;
    private int age;
    public String sex;

    public Person() {
        System.out.println("Person.Person---无参构造");
    }
    //私有的构造方法
    private Person(String name){
        this.name=name;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

public class TestField {
    public static void main(String[] args) {

        try {
            Class<Person> clazz = Person.class;
            //获取操作的对象
            Person p = clazz.newInstance();
            System.out.println("设置非私有属性的值：");
            Field sex = clazz.getField("sex");
            //设置对象属性的值
            sex.set(p,"男");
            //获取对象属性的值
            System.out.println("sex.get(p) = " + sex.get(p));
            System.out.println("设置私有属性的值：");
            Field name = clazz.getDeclaredField("name");
            //注意：设置属性可访问，否则java.lang.IllegalAccessException
            name.setAccessible(true);
            name.set(p,"李四");
            System.out.println("name.get(p) = " + name.get(p));

            System.out.println("p = "+p);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

运行结果：
Person.Person—无参构造
设置非私有属性的值：
sex.get§ = 男
设置私有属性的值：
name.get§ = 李四
p = Person{name=‘李四’, age=0, sex=‘男’}

此实例中通过反射获取Field实例，然后通过Field的set()和get()方法分别给指定的属性设置和取值操作。
注意：在操作私有属性时，一定要设置属性可访问：setAccessible(true);否则会报java.lang.IllegalAccessException异常。
获取方法操作

package com.qwy.reflectionr7;

import java.lang.reflect.Method;

/**
 * @author qwy
 * @create 2021-03-30 16:57
 **/
class Person{
    private String name;
    private int age;
    public String sex;

    public Person() {
        System.out.println("Person.Person---无参构造");
    }
    //私有的构造方法
    private Person(String name){
        this.name=name;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
    public void say(){
        System.out.println("Person.say===人可以说话");
    }
    private String eat(String food){
        System.out.println("人吃的食物："+food);
        return  food;
    }
}
public class TestMethod {
    public static void main(String[] args) {
        try {
        Class<Person> clazz = Person.class;
        System.out.println("获取所有公开的方法（包括继承从父类过来的或接口实现的）：");
        Method[] methods = clazz.getMethods();
        for (Method m:methods) {
            System.out.println("m = " + m);
        }
        System.out.println("获取本类的方法(不包含继承的和实现的，但是包含私有的)：");
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method dm:declaredMethods) {
            System.out.println("dm = " + dm);
        }
            System.out.println("获取指定方法名的非私有的方法：");
            Method say = clazz.getMethod("say");
            System.out.println("say = " + say);
            System.out.println("获取指定方法名的私有的方法：");
            Method eat = clazz.getDeclaredMethod("eat", String.class);
            System.out.println("eat = " + eat);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
获取所有公开的方法（包括继承从父类过来的或接口实现的）：
m = public java.lang.String com.qwy.reflectionr7.Person.toString()
m = public java.lang.String com.qwy.reflectionr7.Person.getName()
m = public void com.qwy.reflectionr7.Person.setName(java.lang.String)
m = public java.lang.String com.qwy.reflectionr7.Person.getSex()
m = public void com.qwy.reflectionr7.Person.say()
m = public int com.qwy.reflectionr7.Person.getAge()
m = public void com.qwy.reflectionr7.Person.setAge(int)
m = public void com.qwy.reflectionr7.Person.setSex(java.lang.String)
m = public final void java.lang.Object.wait() throws java.lang.InterruptedException
m = public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
m = public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
m = public boolean java.lang.Object.equals(java.lang.Object)
m = public native int java.lang.Object.hashCode()
m = public final native java.lang.Class java.lang.Object.getClass()
m = public final native void java.lang.Object.notify()
m = public final native void java.lang.Object.notifyAll()
获取本类的方法(不包含继承的和实现的，但是包含私有的)：
dm = public java.lang.String com.qwy.reflectionr7.Person.toString()
dm = public java.lang.String com.qwy.reflectionr7.Person.getName()
dm = public void com.qwy.reflectionr7.Person.setName(java.lang.String)
dm = public java.lang.String com.qwy.reflectionr7.Person.getSex()
dm = public void com.qwy.reflectionr7.Person.say()
dm = public int com.qwy.reflectionr7.Person.getAge()
dm = public void com.qwy.reflectionr7.Person.setAge(int)
dm = private java.lang.String com.qwy.reflectionr7.Person.eat(java.lang.String)
dm = public void com.qwy.reflectionr7.Person.setSex(java.lang.String)
获取指定方法名的非私有的方法：
say = public void com.qwy.reflectionr7.Person.say()
获取指定方法名的私有的方法：
eat = private java.lang.String com.qwy.reflectionr7.Person.eat(java.lang.String)

从运行结果看：
1.clazz.getMethods()可以获取接口或父类被实现或继承的非私有的方法
2.clazz.getDeclaredMethods()只能获取本类的方法（包含私有的）
3.clazz.getDeclaredMethod(“eat”, String.class);需要制定方法名和参数类型（常用）。交clazz.getMethod(“say”)（不常用）

获取方法后的操作

package com.qwy.reflectionr8;

import java.lang.reflect.Method;

/**
 * @author qwy
 * @create 2021-03-30 17:14
 **/
class Person{
    private String name;
    private int age;
    public String sex;

    public Person() {
        System.out.println("Person.Person---无参构造");
    }
    //私有的构造方法
    private Person(String name){
        this.name=name;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
    public void say(){
        System.out.println("Person.say===人可以说话");
    }
    private String eat(String food){
        System.out.println("人吃的食物："+food);
        return  food;
    }
}
public class TestMethod {
    public static void main(String[] args) {
       try{
           Class<Person> clazz = Person.class;
           Person p=clazz.newInstance();
           Method m = clazz.getDeclaredMethod("eat", String.class);
           m.setAccessible(true);
           //执行eat()方法，并传参，返回结果为eat（）方法的返回值
           String  result = (String) m.invoke(p, "烧鸡");
           System.out.println("result = " + result);

       }catch (Exception e){
           e.printStackTrace();
       }
    }
}

运行结果：
Person.Person—无参构造
人吃的食物：烧鸡
result = 烧鸡

此实例中只调用了私有的方法进行演示，注意：设置eat()方法可被访问。

关于其他关于反射的东东后期慢慢补充

qwy715229258163

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
反射

关于反射我们首先看一个实例：package com.qwy.reflection1;/** * @author qwy * @create 2021-03-30 11:26 **///定义类class Person{}public class TestReflection { public static void main(String[] args) { Person p= new Person(); String name = p.getCl
复制链接

扫一扫

专栏目录