Java中的反射（2）

使用当前类测试反射机制

package reflect;

public class Person{
    private String name = "张三";
    private int age = 20;
    
    public Person(){} //无参构造
    public Person(String name,int age){ //有参构造
        super();
        this.name = name;
        this.age = age;
    }
    public void sayHello(){
        System.out.println(str+":"+str); //输出：大家好！:大家好！
    }
    public void say(String str,int age){
        System.out.println("大家好，我是"+str+"，今年"+age+"岁"); //大家好，我是张三，今年30岁
    }
    
    //重写toString();为了方便看对象的属性值而不是地址值
    @Override
    public String toString(){
        return "Person[name=" + name + ",age=" + age + "]";
    }
    private void dosome(){
        System.out.println("Person:我是私有方法！！！")
    }
}

package reflect;

import java.lang.reflect.Method;

public class ReflectDemo{
    public static void main(String[] args){
        Person p = new Person();
        p.sayHello("大家好！");
        p.say("张三",30);
        
        Class cls = Class,forName("reflect.Person");
        Object o = cls.newInstance();
        
        //sayHello(String)
        Method m = cls.getMethod("sayHello",String.class);
        m.invoke(o,"哈喽~~");
        
        Method m1 = cls.getMethod("say",String.class);
        m1.invoke(o,"李四"，22);
    }
}

Java反射机制

反射式一种动态机制，允许我们实例化对象、调用方法、操作属性从编码期间确定转移到程序运行期间确定。因此反射提高了程序的灵活性，但是随之带来的是更多的系统开销和较慢的运行效率。因此反射机制不能过度使用

package reflect;

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

public class ReflectDemo1{
    public static void main(String[] args){
        /*
        反射第一步，获取要利用反射操作的类的类对象
        Class类的实例
        JVM中每个被加载的类都有且只有一个Class实例与之对应，通过类对象(Class的实例)我们可以得知其  表示的类的一切信息：
        例如：类名，有哪些属性，哪些方法，哪些构造器等等，并利用这些在程序运行期间操作他们。
        
        获取一个类的类对象有三种方式：
        1、类名.class
           例如：
           Class cls = String.class;
           Class cls = int.class;
        2、Class.forName(String className)
           例如：
           Class cls = Class.forName("java.lang.String");
           这里的forName方法中传入的是类的完全限定名
           包名.类名
        3、类的加载器ClassLoader进行加载并获取
        */
         //优点：简单直接   缺点：硬编码获取，不灵活
           Class cls = String.class;
           Class cls1 = int.class
        //Class.forName()
        try{
            //Class cls = Class.forName("java.io.OutputStream"); //写死了，不灵活
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入一个类名：");
            String className = scan.nextLine();
            Class cls = Class.forName(className);
            
            //获取String中的所有公开方法
            Method[] methods = cls.getDeclaredMethods();
            for(Method method : methods){
                System.out.println(method.getName);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

利用反射实例化操作

package reflect;

public class RedlectDemo2{
    public static void main(String[] args){
        //new关键字
        Person p = new Person();
        System.out.println(p); //输出：Person [name=张三, age=22]
        
        //利用反射实例化
        //1、加载类的类对象
        Class cls = Class.forName("refiect.Person");
        //2、利用Class方法newInstance实例化
        Object o = cls.newInstance(); //必须有无参构造
        System.out.println(o); //输出：Person [name=张三, age=22]
    }
}

通过指定的构造器实例化对象

package reflect;

import java.lang.reflect.Constructor;

public class ReflectDemo3{
    public static void main(String[] args) throws Exception{
        Person p = new Person();
        System.out.println(p);
        
        Person p1 = new Person("李四",22);
        System.out.println(p1);
        
        Class<?> cls = Class.forName("reflect.Person");
        //获取构造器
        Constructor<?> c = cls.getConstructor();
        //利用该构造器实例化对象
        Object o = c.newInstance();
        System.out.println(o);
        
        //利用Person(String,int)
        Constructor<?> c2 = cls.getConstructor(String.class,int.class);
        //实例化
        Object o 2 = c2.newInstance("小明",50);
        System.out.println(o2);
    }
}

使用反射机制调用方法

package reflect;

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

public class ReflectDemo4{
    public static void main(String[] args) throws Exception{
        Person p = new Person();
        p.sayHello();
        
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入类名：");
        String className = scan.nextLine();
        System.out.println("请输入方法名：");
        String methodName = scan.nextLine();
        
        //实例化
        Class c = Class.forName(className);
        m.invoke(o); //o.sayHello();
    }
}

利用反射调用私有方法

package reflect;

import java.lang.reflect.Method;

public class ReflectDemo5{
    public static void main(String[] args){
        Person p = new Person();
        //p.dosome; //编译不通过
        
        Class cls = Class.forName("reflect.Person");
        Object o = cls.newInstance();
        //获取Person中的私有方法dosome
        Method m = cls.getDeclaredMethod("dosome");
        m.setAccessible(true);//打破封装
        m.invoke(o);
    }
}