基于java中反射的总结分析

刚开始学习java的时候真的很难理解反射到底是个什么东西

一些书籍，哪怕是很经典的书籍都解释的让人感觉懵懵的，或许的确是我太笨

况且，网上说在将来学习框架的时候需要经常应用到反射机制，这样一来总让人心里有些不安

就方才偶然又把讲解反射的章节和视频看了一点，觉得能理解一些了

现在决定一鼓作气，边看边写，顺便把一些主要的内容和操作都记载到这里

我想，对于我这么一个笨笨的人来说，学习的最好方法也许就是不断重复

遇到不懂的知识就停下来把以往的重新学一遍，虽然浪费了很多时间，但对我也有些效果

 

我的理解是：所谓反射，就是根据一个已经实例化了的对象来还原类的完整信息

至少对我而言，我认为它带给我的好处是，让我从下往上的又了解了一遍面向对象

x_x 在此又痛恨一边那些厚部头们，把我的脑细胞搞死一片

 

class类

如果要完成反射，那么必须了解class类

实例1：通过对象取得包名和类名

package org.siu;

class test {

}

public class demo {
    public static void main(string[] args) {
        test t = new test();
        system.out.println(t.getclass());
        system.out.println(t.getclass().getname());
    }
}

编译结果如下，注意包的编译方式即可

此处的getclass()方法是默认继承自object类的

 

在java中，object类是所有类的父类，同样，所有类的实例化对象也都是class类的实例

因此，这样一来就会牵扯到向上转型和向下转型的概念

由于向下转型的不安全因素，在这里泛型也会接踵而来

（不过我想说的是，此处的泛型设计很刺眼！尼玛，整个java的语法设计同样刺眼，超恶心！！！）

 

实例2：class类的实例化

由于class类没有构造方法，所以实例化class类的方式有点特殊，有三种方式：

对象.getclass( )
类.class
forname( )

class test {

}

public class demo {
    public static void main(string[] args) {
        //方式一：
        test t = new test();
        class<? extends test> c1 = t.getclass();
        system.out.println(c1);

        //方式二：
        //为了避免特殊性，这里不用test类，而用java库中的string类
        class<string> c2 = string.class;
        system.out.println(c2);

        //方式三：
        //forname()方法会抛出异常
        class<?> c3 = null;
        try {
            c3 = class.forname("test");
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }
        system.out.println(c3);
    }
}

其中，forname( )方法需要重点掌握，因为它可以在类不确定的情况下实例化class，更具灵活性

 

class类的应用

class类中有一个方法叫做newinstance( ),它可以用来创建一个class类对象的新实例

怎么说呢？class对象包含的内容就是反射好的那个类，我们要构造那个类的新实例（新对象）

实例3：class类的无参构造对象

public class demo {
    public static void main(string[] args) {
        //实例化class对象，forname()方法会抛异常
        class<?> c = null;
        try {
            //这里需要完整的包名和类名
            c = class.forname("java.lang.string");
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }

        //生成一个字符串的引用
        string s = null;
        try {
            //将构造好的对象向下转型为string类
            //newinstance()方法会抛异常
            s = (string) c.newinstance();
        } catch (instantiationexception e) {
            e.printstacktrace();
        } catch (illegalaccessexception e) {
            e.printstacktrace();
        }
        system.out.println("字符串长度： " + s.length());
    }
}

这样就通过无参数的形式构造了一个新的对象，如同正常模式中

通过无参构造方法来构造新对象一样

我们知道，类中除了有无参构造方法，还会存在有参数的构造方法

那在反射中如何通过有参数的形式构造对象呢？接着看

 

实例4：class类的有参构造对象

import java.lang.reflect.constructor;

public class demo {
    //下面的几个方法抛出来的异常太多，为了代码的紧凑性，这里就直接抛给虚拟机了
    public static void main(string[] args) throws exception {
        class<?> c = null;
        try {
            c = class.forname("java.lang.string");
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }
        char[] ch = {'h','e','l','l','o'};
        string s = null;
        //获得class类对象的有参构造方法，括号里面参数的写法是：类型.class
        constructor<?> con = c.getconstructor(char[].class);
        //用此构造方法构造一个新的字符串对象，参数为一个char数组
        s = (string) con.newinstance(ch);
        system.out.println("构造的字符串：" + s);
    }
}

我们还是使用string类做例，因为string类用的比较多，便于理解

这里需要注意的是，构造方法需要使用getconstructor( )方法获得

至于参数类型则是：原有类型.class

还有一点，无论是有参还是无参，这里所使用的构造方法，原本的类里面必须对应存在

那么，如何才能知道原有类里面的构造方法，普通方法，继承的父类等详细信息呢？接着看

 

获取类的结构

要通过反射获取类的结构我们这里要导入一个新的包java.lang.reflect

实例5：取得类的构造方法

import java.lang.reflect.constructor;
import java.util.arrays;

public class demo {
    //下面的几个方法抛出来的异常太多，为了代码的紧凑性，这里就直接抛给虚拟机了
    public static void main(string[] args) throws exception {
        class<?> c = null;
        try {
            c = class.forname("java.lang.boolean");
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }
        //这里的getconstructors()方法返回的是一个constructor数组
        constructor<?>[] cons = c.getconstructors();
        //打印的方式你可以自己写，为了方便我用arrays.tostring()，凑合着看
        system.out.println(arrays.tostring(cons));
    }
}

我选择了boolean类来做例，因为boolean类的构造方法就两个，方便看

 

实例6：取得类所实现的接口

import java.util.arrays;

public class demo {
    public static void main(string[] args) throws exception {
        class<?> c = null;
        try {
            c = class.forname("java.lang.boolean");
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }
        class<?>[] in = c.getinterfaces();
        system.out.println(arrays.tostring(in));
    }
}

没什么好说的，看结果

 

实例7：取得父类

public class demo {
    public static void main(string[] args) throws exception {
        class<?> c = null;
        try {
            c = class.forname("java.lang.boolean");
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }
        //注意了，这里不会是数组，why？
        class<?> su = c.getsuperclass();
        system.out.println(su);
    }
}

别忘了，java中是单继承，父类只有一个

 

实例8：取得类的全部方法

import java.lang.reflect.method;

public class demo {
    public static void main(string[] args) throws exception {
        class<?> c = null;
        try {
            c = class.forname("java.lang.boolean");
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }
        method[] m = c.getmethods();
        //好吧，这次我就大发慈悲的写个打印列表出来
        for (int i = 0; i < m.length; i++) {
            system.out.println(m[i]);
        }
    }
}

截取一部分，看看，意思下就行了……这几个例子都比较简单

 

实例9：取得本类的全部属性

import java.lang.reflect.field;

class person {
    private string name;
    private int age;
}

public class demo {
    public static void main(string[] args) throws exception {
        class<?> c = null;
        try {
            c = class.forname("person");
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }
        field[] f = c.getdeclaredfields();
        for (int i = 0; i < f.length; i++) {
            system.out.println(f[i]);
        }
    }
}

getdeclaredfielsd()方法可以获取全部属性，getfields()只能获取公共属性

 

实例10：获取本类中属性的值

import java.lang.reflect.field;

class person {
    public string name;
    private int age;

    public person(string name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class demo {
    public static void main(string[] args) throws exception {
        person p = new person("zhangsan",12);

        class<?> c = p.getclass();

        //获取公共属性的值
        field f1 = c.getfield("name");
        //get(p)表明要获取是哪个对象的值
        string str = (string) f1.get(p);
        system.out.println("姓名： " + str);

        //获取私有属性的值
        field f2 = c.getdeclaredfield("age");
        //age是私有属性，所以要设置安全检查为true
        f2.setaccessible(true);
        int age = (int) f2.get(p);
        system.out.println("年龄： " + age);
    }
}

要注意的是：setaccessible()方法可以设置是否访问和修改私有属性

 

坦白说，java学到现在我还没发现什么能亮瞎我钛金眼的知识在里边

每次都是写一堆繁琐的语法实现个小玩意儿，不然就是拼命调用api，拼命的抛异常

让本身显得不够紧凑的代码变得愈发累赘

如果我喜欢一门语言，在我利用它做出东西来之前，它本身的特性必须能够打动我

显然，java并不让我快乐，也许很多程序员跟我一样是*使用java的

仅以此来安抚我那颗孤独编码的心，下面接着看内容

 

反射的应用实例11：通过反射修改属性

import java.lang.reflect.field;

class person {
    private string name;

    public person(string name) {
        this.name = name;
    }

    public string tostring() {
        return "姓名： " + this.name;
    }
}

public class demo {
    public static void main(string[] args) throws exception {
        person p = new person("王二狗");
        system.out.println(p);
        class<?> c = p.getclass();

        //定义要修改的属性
        field f = c.getdeclaredfield("name");
        f.setaccessible(true);
        //修改属性，传入要设置的对象和值
        f.set(p, "张二蛋");
        system.out.println(p);
    }
}

几个方法都是有联系的，如果看不懂就先熟悉上面几个例子

 

实例12：通过反射调用方法

import java.lang.reflect.method;

class person {
    public void print(int i) {
        system.out.println("我在写数字： " + i);
    }

    public static void say(string str) {
        system.out.println("我在说： " + str);
    }
}

public class demo {
    public static void main(string[] args) throws exception {
        person p = new person();
        class<?> c = p.getclass();

        //getmethod()方法需要传入方法名，和参数类型
        method m1 = c.getmethod("print", int.class);
        //invoke()表示调用的意思，需要传入对象和参数
        m1.invoke(p, 10);

        method m2 = c.getmethod("say", string.class);
        //这里的null表示不由对象调用，也就是静态方法
        m2.invoke(null, "你妹");
    }
}

这里演示了一个普通的有参方法和一个静态方法

既然有参数的都写出来了，那么无参的就更简单了，直接传入一个对象即可

 

实例13：通过反射操作数组

import java.lang.reflect.array;

public class demo {
    public static void main(string[] args) throws exception {
        int[] arr = {1,2,3,4,5};
        class<?> c = arr.getclass().getcomponenttype();

        system.out.println("数组类型： " + c.getname());
        int len = array.getlength(arr);
        system.out.println("数组长度： " + len);
        system.out.print("遍历数组： ");
        for (int i = 0; i < len; i++) {
            system.out.print(array.get(arr, i) + " ");
        }
        system.out.println();
        //修改数组
        system.out.println("修改前的第一个元素： " + array.get(arr, 0));
        array.set(arr, 0, 3);
        system.out.println("修改后的第一个元素： " + array.get(arr, 0));
    }
}

这里要注意一点，getcomponenttype( )返回的是数组元素的class

 

暂时就写这么多，我看的书中还有反射在工厂模式中的应用

无非是用forname()方法替换一下，没什么可说的

我是个java初级黑，我恨java那种恶心的语法和设计

这都是为了android，为了打基础，为了适应以后的工作