java反射抄的例子

package com.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/*
 * 反射的概念
 *     指程序可以访问，检测和修改它本身状态或者行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义
 *     反射是java中的一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以运行时的装配，无需在组件之间进行源代码链接
 * 
 * 反射机制的作用：
 *     1、反编译：.class-->.java
 *     2、通过反射机制访问java对象的属性，方法构造等
 * 
 * sun提供的反射机制的类：
 *     Class
 *     Constructor
 *    Field
 *     Method
 *     Modifier
 */
public class Study01 {
    
    public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchFieldException, InstantiationException, IllegalAccessException {
        Study01 s=new Study01();
        s.test04();
    }
    public void test01() throws ClassNotFoundException{
        //获取类的三种方法：
        Class c1=Class.forName("DVD");
        
        Class c2=ClassDemo.class;
        
        ClassDemo c=new ClassDemo();
        Class c3=c.getClass();
    }
    
    public void test02() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
        //创建对象，利用newInstance
        Class c=Class.forName("DVD");
        
        Object o=c.newInstance();
    }
    
    public void test03() throws ClassNotFoundException{
        //获取整个类
        Class c=Class.forName("com.entity.DVD");//注意class.forName（）需要类的全名，包括包
        //获取所有所有的属性
        Field[] fs=c.getDeclaredFields();
        //定义可变长的字符串来存储属性
        StringBuilder sb=new StringBuilder();
        //通过追缴的方法，将每个属性凭借到此字符串中
        //最外边的public定义
           sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{
"); 
           //里面的每一个属性
           for(Field field:fs){
               sb.append("	");
               sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的访问修饰符
               sb.append(field.getType().getSimpleName()+" ");//属性的类型名
               sb.append(field.getName()+";
");//属性的名字+回车
           }
           sb.append("}");
           System.out.println(sb);
    }
    
    public void test04() throws ClassNotFoundException, SecurityException, NoSuchFieldException, InstantiationException, IllegalAccessException{
        //获取指定属性
        Class c=Class.forName("com.entity.DVD");
        Field name=c.getDeclaredField("name");
        Object o=c.newInstance();
        name.setAccessible(true);//使用反射机制可以打破封装性，导致了java对象的属性不安全
        name.set(o, "guo");//给o对象的id赋值“guo"
        System.out.println(name.get(o));
    }
    
    public void test05(){
        /*
         * 方法关键字：
         * getDeclaredMethods() 获取所有方法
         * getReturnType() 获取返回值类型
         * getParameterTypes() 获取方法的传入参数类型
         * getDeclaredMethod("方法名",参数类型.class...) 获得特定方法
         * 
         * 构造关键字：
         * getDeclaredConstructors() 获取所有的构造方法
         * getDeclaredConstructors(参数类型.class,...)获取特定构造
         * 
         * 父类和接口
         * getSuperclass() 获取某类的父类
         * getInterfaces() 获取某类实现的接口
         * 
         * 对于java这种先编译后执行的语言来说，反射机制可以使代码更灵活，更加容易实现面向对象         */
    }
}

package com.reflect02;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

class Study01 {
    public static void main(String[] args) {
        hello h=new hello();
        h.test15();
    }
}


class Demo{
    
}
class hello{
    /*
     * 通过一个对象获取完整的包名和类名
     */
    public void test01(){
        Demo demo=new Demo();
        System.out.println(demo.getClass().getName());
    }
    
    /*
     * 实例化class类对象
     */
    public void test02(){
        Class<?> demo1=null;
        Class<?> demo2=null;
        Class<?> demo3=null;
        try {
            demo1=Class.forName("com.reflect02.Demo");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        demo2=new Demo().getClass();
        demo3=Demo.class;
        
        System.out.println("类名称  "+demo1.getName());
        System.out.println("类名称 "+demo2.getName());
        System.out.println("类名称 "+demo3.getName());
    }
    /*
     * 通过无参构造实例化对象
     */
    public void test03(){
        Class<?> demo=null;
        try {
            demo=Class.forName("com.reflect02.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Person per=null;
        try {
            per=(Person) demo.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        per.setName("guo");
        per.setAge(12);
        System.out.println(per);
    }
    
    /*
     * 调用各种构造创建对象
     */
    public void test04(){
        Class<?> demo=null;
        try {
            demo=Class.forName("com.reflect02.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Person per1=null;
        Person per2=null;
        Person per3=null;
        Person per4=null;
        
        Constructor<?> cons[]=demo.getConstructors();
//        System.out.println(cons[0]);可以先输出找到他们的顺序
//        System.out.println(cons[1]);
//        System.out.println(cons[2]);
//        System.out.println(cons[3]);
//        
        try {
            per2=(Person) cons[0].newInstance((Object)"guo",(Object)12);
            per3=(Person) cons[1].newInstance("liu");
            per4=(Person) cons[2].newInstance(23);
            per1=(Person) cons[3].newInstance();
            
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        System.out.println(per1);
        System.out.println(per2);
        System.out.println(per3);
        System.out.println(per4);
    }
    /*
     * 返回一个类实现的接口
     */
    public void test05(){
        Class<?> demo=null;
        try {
            demo=Class.forName("com.reflect02.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Class<?> intes[]=demo.getInterfaces();
        for(Class<?> c:intes){
            System.out.println("实现的接口："+c.getName());
        }
    }
    /*
     * 取得其他类中的父类
     */
    public void test06(){
        Class<?> demo=null;
        try {
            demo=Class.forName("com.reflect02.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Class<?> temp=demo.getSuperclass();
        System.out.println("继承的父类为："+temp.getName());
    }
    /*
     * 获取其他类中全部构造函数
     */
    public void test07(){
        Class<?> demo=null;
        try {
            demo=Class.forName("com.reflect02.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Constructor<?> cons[]=demo.getConstructors();
        for(Constructor<?> c:cons){
            System.out.println(demo.getName()+"的构造方法:"+c);
        }
    }
    /*
     * 获取访问权限修饰符
     */
    public void test08(){
        Class<?> demo=null;
        try {
            demo=Class.forName("com.reflect02.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Constructor<?> cons[]=demo.getConstructors();
        for(int i=0;i<cons.length;i++){
            Class<?> p[]=cons[i].getParameterTypes();
            System.out.println("构造方法：");
            int mo=cons[i].getModifiers();
            System.out.print(Modifier.toString(mo)+" ");
            System.out.print(cons[i].getName()+"(");
            for(int j=0;j<p.length;j++){
                System.out.print(p[j].getName()+" arg"+j);
                if(j<p.length-1){
                    System.out.print(",");
                }
            }
            System.out.println("){}");
        }
    }
    /*
     * 获取所有方法
     */
    public void test09(){
        Class<?> demo=null;
        try {
            demo=Class.forName("com.reflect02.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Method method[]=demo.getMethods();
        for(Method m:method){
            Class<?> returnType=m.getReturnType();
            Class<?> para[]=m.getParameterTypes();
            int temp=m.getModifiers();
            System.out.print(Modifier.toString(temp)+" ");
            System.out.print(returnType.getName()+" ");
            System.out.print(m.getName()+" ");
            System.out.print("(");
            for(int i=0;i<para.length;i++){
                System.out.print(para[i].getName()+" arg"+i);
                if(i<para.length-1){
                    System.out.print(",");
                }
            }
             Class<?> exce[]=m.getExceptionTypes();
             if(exce.length!=0){
                 System.out.println(")throws ");
                 for(int j=0;j<exce.length;j++){
                     System.out.print(exce[j].getName()+" ");
                     if(j<exce.length-1){
                         System.out.print(",");
                     }
                 }
             }else{
                 System.out.print(")");
             }
             System.out.println();
        }
    }
    /*
     * 获取其他类的全部属性
     */
    public void test10(){
        Class<?> demo=null;
        try {
            demo=Class.forName("com.reflect02.Person1");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("=================本地属性===================");
        Field[] field=demo.getDeclaredFields();
        for(int i=0;i<field.length;i++){
            //访问权限修饰符
            int mo=field[i].getModifiers();
            String priv=Modifier.toString(mo);
            //属性数据类型
            Class<?> type=field[i].getType();
            System.out.println(priv+" "+type.getName()+" "+field[i].getName()+";");        
        }
        

        System.out.println("=============实现的接口或父类的属性");
        Field[] filed1=demo.getFields();
        for(int j=0;j<filed1.length;j++){
            //权限修饰符
            int mo=filed1[j].getModifiers();
            String priv=Modifier.toString(mo);
            //属性类型
            Class<?> type=filed1[j].getType();
            System.out.println(priv+" "+type.getName()+" "+filed1[j].getName()+";");
            
        }
        
    }
    /*
     * 通过反射调用其他类中的方法
     */
    public void test11(){
        Class<?> demo=null;
        try {
            demo=Class.forName("com.reflect02.Person1");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            Method method=demo.getMethod("sayChina");
            method.invoke(demo.newInstance());
            
            method=demo.getMethod("sayHello",String.class,int.class );
            method.invoke(demo.newInstance(), "guo",22);
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        
    }
    /*
     * 调用其他类的set和get方法
     */
    public void test12(){
        Class<?> demo=null;
        Object obj=null;
        try {
            demo=Class.forName("com.reflect02.Person1");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            obj=demo.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        setter(obj,"Sex","男",String.class);
        getter(obj,"Sex");
        
    }
    /*
     * 通过反射操作属性
     */
    public void test13(){
        Class<?> demo=null;
        Object obj=null;
        try {
            demo=Class.forName("com.reflect02.Person1");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            obj=demo.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        
        try {
            Field field=demo.getDeclaredField("sex");
            field.setAccessible(true);//允许操作属性
            field.set(obj, "男");
            System.out.println(field.get(obj));
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    /*
     * 通过反射取得并修改数组的信息
     */
    public void test14(){
        int[] temp={1,2,3,4,5};
        Class<?> demo=temp.getClass().getComponentType();
        System.out.println("数组类型："+demo.getName());
        System.out.println("数组长度："+Array.getLength(temp));
        System.out.println("数组的第一个元素："+Array.get(temp, 0));
        Array.set(temp, 0, 100);
        System.out.println("修改之后数组第一个元素是："+Array.get(temp, 0));
    }
    /*
     * 通过反射修改数组大小
     */
    public void test15(){
        int[] temp={1,2,3,4,5,6,7,8,9};
        int[] newTemp=(int[]) arrayInc(temp,15);
        printA(newTemp);
        System.out.println("=======================");
        String[] atr={"a","b","c"};
        String[] str1=(String[]) arrayInc(atr,8);
        printA(str1);
    }
    
    
    public Object arrayInc(Object obj,int len){//截取一定长的数组
        Class<?> arr=obj.getClass().getComponentType();
        Object newArr=Array.newInstance(arr, len);
        int co=Array.getLength(obj);
        System.out.println(obj);
        System.arraycopy(obj,0,newArr,0,co);
        return newArr;
    }
    public void printA(Object obj){//打印数组元素
        Class<?> c=obj.getClass();
        if(!c.isArray()){
            return;
        }
        System.out.println("数组的长度为："+Array.getLength(obj));
        for(int i=0;i<Array.getLength(obj);i++){
            System.out.print(Array.get(obj, i)+" ");
        }
    }
    public void getter(Object obj,String att){
        Method method;
        try {
            method = obj.getClass().getMethod("get"+att);
            System.out.println(method.invoke(obj));
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        
    }
    public void setter(Object obj,String att,Object value,Class<?> type){
        Method method;
        try {
            method = obj.getClass().getMethod("set"+att, type);
            method.invoke(obj, value);
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        
    }
    
}
class Person{
    private String name;
    private int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person(String name){
        this.name=name;
    }
    public Person(int age){
        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 + "]";
    }
    
}
interface China{
    public static final String name="guo";
    public static int age=20;
    public void sayChina();
    public void sayHello(String name,int age);
}
class Person1 implements China{
    private String sex;
    @Override
    public void sayChina() {
        System.out.println("hello,China");
    }

    @Override
    public void sayHello(String name, int age) {
        System.out.println("hello,"+name+" "+age);
    }

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

    public String getSex() {
        return sex;
    }

    @Override
    public String toString() {
        return "Person1 [sex=" + sex + "name=" + name+ "age=" + age+"]";
    }
    
    
}

package com.reflect02;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Study02 {
    public static void main(String[] args) {
        Study02 s=new Study02();
        s.test02();
    }
    /*
     * 动态代理
     */
    public void test01(){
        test t=new test();
        System.out.println("类加载器  "+t.getClass().getClassLoader().getClass().getName());
    }
    /*
     * 在java中有三种类加载器
     * Bookstrap ClassLoader此加载器采用c++编写，一般在开发中很少见
     * Extension ClassLoader用来进行拓展类的加载，一般对应的是jrelibext目录中的类
     * AppClassLoader加载classpath指定的类，是罪常用的加载器，同时也是java中的默认加载器
     */
    public void test02(){
        MyInvocationHandler demo=new MyInvocationHandler();
        Subject sub=(Subject) demo.bind(new RealSubject());
        String info=sub.say("guo", 22);
        System.out.println(info);
    }
    /*
     * 类的生命周期
     * 
     * 在一个类编译完成之后，下一步就需要开始使用类，如果使用一个类，肯定离不来JVM。在程序执行中JVM通过装载，链接，初始化这3个步骤完成。
     * 
     * 类的装载是通过类加载器完成的，加载器将.class文件的二进制文件装入JVM的方法区，并且在堆去创建描述这个类的java.lang.Class对象。用来封装数据。但是同一个类只会被类装载器装载一次
     * 
     * 链接就是把二进制数据组装为可以运行的状态
     * 
     * 链接分为校验，准备，解析这3个阶段
     * 校验一般用来确定此二进制文件是否适合当前的JVM(版本)
     * 准备就是为静态成员分配内存空间，并设置默认值
     * 解析值得是转换常量池中的代码直接作为直接引用的过程，知道所有的符号引用都可以被运行程序使用（建立完整的对应关系）
     * 完成之后，类型也就完成了初始化，初始化之后的类的对象就可以正常使用了，看到一个对象不再使用之后，将被垃圾回收。释放空间。
     * 当没有任何引用指向class对象时就会被卸载，结束类的生命周期
     */
}
class test{
    
}
interface Subject{
    public String say(String name,int age);
}
class RealSubject implements Subject{

    @Override
    public String say(String name, int age) {
        return name+" "+age;
    }
    
}
/*
 * 想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作
 */
class MyInvocationHandler implements InvocationHandler{
    private Object obj=null;
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object temp=method.invoke(this.obj,args);
        return temp;
    }
    
    public Object bind(Object obj){
        this.obj=obj;
        return  Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), this);
    }
    
}