reflect

1.新建一个Person实体类

package reflect;

/**
 * 使用当前类测试反射机制
 */
public class Person {
    private String name = "张三";
    private int age = 22;

    public Person() {
    }

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

    public void sayHello(){
        System.out.println(name+":大家好!");
    }
    public void sayHi(){
        System.out.println(name+":嗨!,我今年"+age);
    }

    public void say(String name){
        System.out.println(this.name+":你好!"+name);
    }

    public void say(String name,int age){
        System.out.println(this.name+":你好!"+",你今年"+age+"了吗?");
    }

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

2. 获取一个类的类对象和类中所有方法

package reflect;

import java.lang.reflect.Method;
import java.util.Scanner;

/**
 * 反射
 * 反射是java中的一套动态机制,允许我们的程序在运行期间在确定对象的实例化,属性
 * 的操作以及方法的调用.
 * 反射可以提高代码的灵活性,但是也会带来较慢的运行速度和更多的资源开销.所以不能
 * 过渡依赖反射.
 *
 */
public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        /*
            反射的第一步是获取要操作的类的类对象,即:class的实例
            JVM中每个被加载的类都有且只有一个Class的实例与之对应,通过这个类对象
            可以了解它表示的这个被加载的类的一切信息(类名,有哪些属性,方法,构造器等)
            并可以进行响应的操作.

            获取一个类的类对象主要方式为:
            1:类名.class . 例如:
            Class cls = String.class;//获取String的类对象
            Class cls = int.class//获取int的类对象,基本类型也有类对象

            2:Class.forName(String className).例如:
            Class cls = Class.forName("java.lang.String");
            基本类型不能用这样的方式被加载

            3:类加载器ClassLoader
         */
        //获取字符串的类对象
//        Class cls = String.class;
//        Class cls = Class.forName("java.lang.String");
        /*
            java.util.HashMap
            java.util.ArrayList
            java.io.FileOutPutStream
            java.io.RandomAccessFile
            reflect.Person
         */
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个类名:");
        String className = scan.nextLine();
        Class cls = Class.forName(className);
        String name = cls.getName();
        System.out.println("字符串的类对象名:"+name);

        //获取Class所表示类的所有方法(不包含私有方法)
        Method[] methods = cls.getMethods();
        System.out.println("字符串的所有方法总计:"+methods.length+"个");
        for(Method method : methods){
            System.out.println(method.getName());
        }
    }
}

3.使用反射机制实例化对象

package reflect;

import java.util.ArrayList;
import java.util.Scanner;

/**
 * 使用反射机制实例化对象
 */
public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        ArrayList list = new ArrayList();
        System.out.println(list);

        //1加载要实例化的类对象
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个类名:");
        String className = scan.nextLine();
        Class cls = Class.forName(className);

        //2实例化
        Object obj = cls.newInstance();
        System.out.println(obj);

    }
}

4.利用反射机制获得一个类的构造器并实例化对象

package reflect;

import java.lang.reflect.Constructor;

/**
 * 使用不同的构造器实例化参数
 */
public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        System.out.println(p1);

        Person p2 = new Person("苍老师",55);
        System.out.println(p2);

        //使用反射
        Class cls = Class.forName("reflect.Person");

        //通过类对象获取对应的构造器
        Constructor c = cls.getConstructor();//获取无参的构造器
        Object obj = c.newInstance();//创建一个实例
        System.out.println(obj);

        //获取有参构造器
        Constructor c1 = cls.getConstructor(String.class,int.class);
        Object obj1 = c1.newInstance("苍老师",55);
        System.out.println(obj1);
    }
}

5.使用反射机制获取一个类对象并调用一个类中的方法

package reflect;

import java.lang.reflect.Method;

/**
 * 使用反射机制调用构造方法
 */
public class ReflectDemo4 {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        p.sayHello();

        //使用反射
        Class cls = Class.forName("reflect.Person");
        Object o = cls.getConstructor().newInstance();//实例化person
        //调用sayHello方法
        Method m = cls.getMethod("sayHello");
        m.invoke(o);// o.sayHello

        p.say("李四");//调用有参方法
        //第二个参数开始就是方法的参数类型,顺序,个数,类型必须与方法定义一致
        Method m2 = cls.getMethod("say", String.class);
        m2.invoke(o,"李四");


        p.say("李四",22);

        Method m3 = cls.getMethod("say", String.class, int.class);
        m3.invoke(o,"李四",22);


    }
}