Java中的反射

java.类加载

API中，关于java.lang.reflect 的描述：
提供类和接口，以获得关于类和对象的反射信息。在安全限制内，反射允许编程访问关于加载类的字段、方法和构造方法的信息，并允许使用反射字段、方法和构造方法对其底层对等项进行操作。

是否允许修改类的相关信息呢？不可能吧，类在class文件中早已经被固定住了。

可以实例化一个类，进而可以修改这个对象的字段与属性等。这是自己写的程序，日后的你是否还看得懂呢？一个一个实例来测试实验，进而有很多代码已经被注释。

    /**
     * 
     */
    package reflect;
    import java.lang.reflect.*;
    /**
     * @author xiao
     *
     */
    public class TestReflect {
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Dog d = new Dog();
    //      //获取类的三种方法：
    //      //   1.对象的getClass()方法 2.类.class 3.Class.forName(类名称)  
    //      System.out.println(a1.getClass().getName());
    //      System.out.println(Dog.class.getName());
    //      
    //      Class<?> dog1 = null;
    //      try{
    //          dog1 = Class.forName("reflect.Dog");//这种方法必然产生异常
    //      } catch(Exception e){
    //          e.printStackTrace();
    //      }
    //      System.out.println(dog1.getName());
            /*
             * 通过class来实例化来获取其他的对象
             * 在使用Class实例化其他类的对象的时候，一定要自己定义一个无参数的构造函数
             */
    //      Class<?> dog1 = Dog.class;
    //      Dog d2 = null;
    //      try{
    //          d2 = (Dog) dog1.newInstance();
    //      } catch(Exception e){
    //          e.printStackTrace();
    //      }
    //      d2.setAge(3);
    //      System.out.println(d2);
            /*
             * 通过class来获取其他类的构造方法
             */
    //      Class<?> cat1 = Cat.class;
    //      Constructor<?>[] cons = cat1.getConstructors();
    //      for(Constructor<?> con : cons)
    //          System.out.println(con);
    //      
    //      Cat cat2 = null;
    //      try{
    //          cat2 = (Cat) cons[0].newInstance("kitty");
    //      }catch(Exception e){//catch多个异常的时候，范围小的要在前面，最后才是Exception
    //          e.printStackTrace();
    //      }
    //      System.out.println(cat2);
    //      
            /*
             * 通过class来获取其他类的接口信息
             * 
             */
    //      Class<?> cat1 = Cat.class;
    //      Class<?>[] inters = cat1.getInterfaces();
    //      System.out.println(cat1.getSimpleName()+"类实现的接口有：");
    //      for(Class<?> inter :inters)
    //          System.out.println("    "+inter.getSimpleName());
    //      
            /*
             * 通过class来获取其他类的字段信息
             * getDeclaredFields()表示获取的是本类字段的所有信息
             * getFields()表示获取的是父类或者接口字段的public范围的信息（注意默认权限并不是public）
             */
    //      Class<?> cat1 = Cat.class;
    //      Field[] fieldSelf = cat1.getDeclaredFields();
    //      for(Field f : fieldSelf){
    //          System.out.println(f.getName());
    //      }
            /*
             * 在上一要求的基础上
             * 通过class来修改其他类的字段信息
             * 如果该字段信息是该类的private变量，那么需要设置
             * 
             */
            Class<?> dog3 = Dog.class;
            try{
                Dog d3 =(Dog) dog3.newInstance();
                //Dog d3 = new Dog();
                Field f3 = null;
                try{//原来还可尝试多层嵌套
                    f3 = dog3.getDeclaredField("name");//获取某一个字段信息
                    //修改字段信息
                    f3.setAccessible(true);//针对的是类中的私有字段
                    f3.set(d3, "aFu");
                    System.out.println(d3.toString());
                }catch(Exception e){
                    e.printStackTrace();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
            /*
             * 
             *通过class来获取其他类的方法，并且实例化该类（通过newInstance()方法）以调用该方法 
             *getMethod(str,args)第一个表示方法名称，字符串；第二个表示输入参数类型，可以是多个
             *Class类型组成的数组，下面这个例子就是两个不同类型参数组成的数组。在真实传入的时候
             *需要编程Object数组，因为两个参数类型不一样，只能用Object数组来装。
             *
             */
    //      Class<?> cat1 = Cat.class;
    //      try{
    //          //设置Class数组在getMethod()方法中作为参数
    //          Class[] arges = new Class[2];
    //          arges[0] = String.class;
    //          arges[1] = int.class;
    //          
    //          //设置Object[]数组在invoke()方法中作为参数
    //          Object[] ars = new Object[2];
    //          ars[0] = "kitty";
    //          ars[1] = 3;
    //          
    //          //返回值是Method类
    //          Method m1 = null;
    //          m1 = cat1.getMethod("sleep",arges);
    //          m1.invoke(cat1.newInstance(),ars);
    //          //输出：kitty正在睡觉···3
    //          
    //      }catch(Exception e){
    //          e.printStackTrace();
    //      }
        }
    }
    ========================================
    public interface Animal {
        int data = 0;//接口中的变量一定是public static final
        void call(String str);
        String eat();
    }
    =========================================
    public class Dog implements Animal {
        int age;
        private String name;
        //constructor
        public Dog(){
        }
        public Dog(int age){
            this.age = age;
        }
        public Dog(String name){
            this.name = name;
        }
        public Dog(int age, String name) {
            this.age = age;
            this.name = name;
        }
        //getter and setter
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public void call(String str) {
            System.out.println("汪汪···");
        }
        @Override
        public String eat() {
            // TODO Auto-generated method stub
            return "小骨头···";
        }
        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return "age：" + age+" || "+"name："+name;
        }
    }
    ======================================
    public class Cat implements Animal {
        public int age;
        String name;
        //constructor
        public Cat(){
        }
        public Cat(int age){
            this.age = age;
        }
        public Cat(String name){
            this.name = name;
        }
        public Cat(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        //getter and setter
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public void call(String str) {
            System.out.println(str+"  喵喵···");
        }
        @Override
        public String eat() {
            return "好吃的鱼···";
        }
        @Override
        public String toString() {
            return "age：" + age+" || "+"name："+name;
        }
        public void sleep(String str, int cnt){
            System.out.println(str+"正在睡觉···"+cnt);
        }
    }