反射

反射（reflect）机制的作用

　　1.反编译：.class--->.java

　　2.通过反射机制访问java类的属性，方法，构造方法等

获取Class的三种方式

package com.yuijam.reflect;

public class Employee {
    
    private String name;
    
    public Employee(){
        
    }
    
    public Employee(String name){
        this.name = name;
    }
    
    public void m1(){
        
    }
    
}

package com.yuijam.reflect;

public class ReflectTest01 {

    public static void main(String[] args) throws Exception{
        //第一种
        Class c1 = Class.forName("com.yuijam.reflect.Employee");
        //c1保存内存地址指向堆中的对象，该对象代表的是Employee整个类
        
        //第二种
        //Java中任何一个对象都有getClass方法
        Class c2 = Employee.class;
        
        //第三种
        //Java中每个类型都有class属性，注意这里说的是类型不是类，所以可以int.class
        Employee e = new Employee();
        Class c3 = e.getClass();
        
        //因为Employee这个类在JVM中只有一个，所以c1,c2,c3的内存地址是一样的，指向堆中的唯一一个对象
        System.out.println(c1==c2);
        System.out.println(c3 == c2);
    }

}

一个知识点

package com.yuijam.reflect;

public class ReflectTest02 {

    public static void main(String[] args) throws Exception{
        //将A.class文件装载到JVM的过程，会执行静态语句块，打印输出
        Class c1 = Class.forName("com.yuijam.reflect.A");
        
        //不会执行静态语句块
        Class c2 = A.class;
        
    }

}

class A{
    static{
        System.out.println("A----");
    }
}

通过Class类对象创建java对象

package com.yuijam.reflect;

import java.text.SimpleDateFormat;
import java.util.Date;

public class ReflectTest03 {

    public static void main(String[] args) throws Exception{
        Class c = Class.forName("com.yuijam.reflect.Employee");
        
        //创建此Class对象所表示的类的一个新实例
        Object o = c.newInstance();//调用Employee的无参数构造方法
        //如果将Employee的无参数构造方法注释掉，会抛出异常
        System.out.println(o);
        
        Class d = Class.forName("java.util.Date");
        Object o1 = d.newInstance();
        if ( o1 instanceof Date){
            Date t = (Date)o1;
            System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(t));
        }
        
    }

}

Employee的无参数构造方法执行！
com.yuijam.reflect.Employee@15db9742
2016-10-23 21:41:20 754

关于Java的可变长参数

package Test;

/**
 * Created by Arenas on 2016/10/24.
 */
public class ReflectTest04 {
    //该方法在调用的时候传递的实参可以是0~N个
    public static void m1(int... i){
        System.out.println("test");
    }
    //如果有可以精确匹配的方法，则调用该方法，而不会调用可变长参数的那个方法
    public static void m1(int i){
        System.out.println(i);
    }
    //可变长参数可以等同看作数组
    public static void m2(String... s){
        for (String s1 : s) {
            System.out.println(s1);
        }
    }
    //可变长参数只能出现一次，并且只能出现在参数列表最后一个，下面这样是不行的
//    public static void m3(int... i , String s){
//
//    }
    //这个是可以的
    public static void m3(int s , int... i){

    }

    public static void main(String[] args) {
        m1();
        m1(1);
        m1(1,2);
        m1(3,4,5);

        m2("kobe" , "kg" , "duncan" , "tracy");
    }

}

test
1
test
test
kobe
kg
duncan
tracy

Properties和IO的使用

首先在D盘新建一个文件info.txt，内容为username=tracy

package Test;

import java.io.FileInputStream;
import java.util.Properties;

/**
 * Created by Arenas on 2016/10/24.
 */
public class PropertiesIOTest {

    public static void main(String[] args) throws Exception{
        //创建输入流
        FileInputStream fis = new FileInputStream("D:/info.txt");

        //创建属性对象，和Map一样，只不过key和value只能是字符串类型
        Properties properties = new Properties();
        //将file流中的所有数据加载到属性对象中
        properties.load(fis);

        //关闭流
        fis.close();
        
        String v = properties.getProperty("username");
        System.out.println(v);
    }
}

输出：tracy

info这样的文件通常称为配置文件，配置文件的作用是使程序更加灵活。像info这样一个具有特殊内容的配置文件，通常又称为属性文件。Java规范中要求属性文件以.properites结尾

属性文件的要求：

　　1.key和value之间可以使用“空格”，“冒号”，“等号”作为分隔符

　　2.当“空格”，“冒号”，“等号”同时出现时，按最先出现的那个作为分隔符

这里注意一个问题，在info文件中再加一条带中文的，如chinesename=麦迪

输出一个乱码：ÂóµÏ

这个时候进入cmd，输入如下：

再将转换成的unicode码复制到info中替换中文麦迪，即可输出中文麦迪

利用reflect、IO、properties创建Java对象

在D盘新建文件ClassInfo.properites，内容为className=java.util.Date

package Test;

import java.io.FileReader;
import java.util.Properties;

/**
 * Created by Arenas on 2016/10/24.
 */
public class ReflectTest05 {

    public static void main(String[] args)throws Exception{
        //创建属性对象
        Properties properties = new Properties();
        //创建流
        FileReader reader = new FileReader("D:/ClassInfo.properites");
        //加载
        properties.load(reader);
        //记得关闭流
        reader.close();
        //通过key获取value
        String className = properties.getProperty("className");
        //创建对象并打印出来
        Class c = Class.forName(className);
        System.out.println(c.newInstance());
    }
}

输出：Mon Oct 24 19:35:54 CST 2016

反编译某个类的所有Field

新建User

package Test;

/**
 * Created by Arenas on 2016/10/24.
 */
public class User {
    private String name;
    private int age;
    protected String addr;
    boolean married;

    private User(){

    }

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

    public boolean login(String username , String password){
        return (username.equals("admin") && password.equals("123456"));
    }

    public void loginout(){
        System.out.println("login out");
    }
}

package Test;

import java.io.FileReader;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Properties;

/**
 * Created by Arenas on 2016/10/24.
 */
public class ReflectTest06 {

    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();
        FileReader reader = new FileReader("D:/ClassInfo.properties");
        properties.load(reader);
        reader.close();
        String className = properties.getProperty("className");
        Class c = Class.forName(className);
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields){
            int i = field.getModifiers();
            System.out.println(Modifier.toString(i));
            Class type = field.getType();
            String str = field.getName();
            System.out.println(type.getName());
            System.out.println(str);
        }
    }
}

private
java.lang.String
name
public
int
age
protected
java.lang.String
addr

boolean
married

反编译User类

package Test;

import java.io.FileReader;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Properties;

/**
 * Created by Arenas on 2016/10/24.
 */
public class ReflectTest06 {

    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();
        FileReader reader = new FileReader("D:/ClassInfo.properties");
        properties.load(reader);
        reader.close();
        String className = properties.getProperty("className");
        Class c = Class.forName(className);
        Field[] fields = c.getDeclaredFields();

        StringBuilder builder = new StringBuilder();
        builder.append(Modifier.toString(c.getModifiers()));
        builder.append(" class ");
        builder.append(c.getSimpleName());
        builder.append("{
");

        for (Field field : fields){
            builder.append("	");
            builder.append(Modifier.toString(field.getModifiers()));
            builder.append(" ");
            builder.append(field.getType().getSimpleName());
            builder.append(" ");
            builder.append(field.getName());
            builder.append(";
");
        }
        builder.append("}");
        System.out.println(builder.toString());
    }
}

将User换成java.lang.String等也同样可以顺利打出

获取某个指定的Field

package Test;

import java.lang.reflect.Field;

/**
 * Created by Arenas on 2016/10/25.
 */
public class ReflectTest07 {
    //获取某个指定的属性
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("Test.User");
        //获取age属性，这里如果用getField只能获取public的属性，如果属性为private会抛出异常
        Field field = c.getDeclaredField("age");
        //使用反射机制可以打破封装属性，导致了Java对象的属性不安全
        //这里如果注释掉这条，对于private属性来说会抛出异常
        field.setAccessible(true);
        Object o = c.newInstance();
        //给o对象的age属性赋值110
        field.set(o , 110);
        System.out.println(field.get(o));
    }
}

 获取所有方法

package Test;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * Created by Arenas on 2016/10/25.
 */
public class ReflectTest08 {

    public static void main(String[] args) throws Exception{
        Class c = Class.forName("Test.User");
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods){
            //获取返回值类型
            System.out.println(method.getReturnType().getSimpleName());
            System.out.println(Modifier.toString(method.getModifiers()));
            System.out.println(method.getName());
            //获得形参
            Class[] paras = method.getParameterTypes();
            for (Class para : paras){
                System.out.println(para.getSimpleName());
            }
        }
    }

}

boolean
public
login
String
String
void
public
loginout

获取指定方法

package Test;

import java.lang.reflect.Method;

/**
 * Created by Arenas on 2016/10/25.
 */
public class ReflectTest09 {

    public static void main(String[] args)throws Exception{
        Class c = Class.forName("Test.User");
        //通过方法名和形参列表确定一个方法
        Method method = c.getDeclaredMethod("login" , String.class , String.class);
        Object o = c.newInstance();
        //调用o对象中的method方法，并传入两个参数，获取返回值returnValue
        Object returnValue = method.invoke(o , "admin" , "123456");
        System.out.println(returnValue);
    }
}

true

获取所有构造方法

package Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;

/**
 * Created by Arenas on 2016/10/25.
 */
public class ReflectTest10 {

    public static void main(String[] args) throws Exception{
        Class c = Class.forName("Test.User");
        Constructor[] constructors = c.getDeclaredConstructors();
        StringBuilder builder = new StringBuilder();
        for (Constructor constructor : constructors){
            String modifer = Modifier.toString(constructor.getModifiers());
            builder.append(modifer);
            builder.append(" ");
            String constructorName = constructor.getName();
            builder.append(constructorName);
　　　　　　　builder.append(" ");
            Class[] paras = constructor.getParameterTypes();
            for (Class para : paras){
                builder.append(para.getSimpleName());
                builder.append(",");
            }
            builder.append("
");
        }
        System.out.println(builder.toString());
    }
}

private Test.User
public Test.User String,int,

同理可以根据参数类型来确定特定的构造方法

通过getSuperclass()来获取父类，单继承，所以只有一个父类

通过getInterfaces()获取接口，可以实现多个接口，所以返回一个Class数组

反射的两个缺点

　　1.性能问题

　　用反射基本上属于一种解释操作，我们可以告诉JVM，我们希望做什么，并且他满足我们的要求。用字段和方法接入时，反射要远慢与直接代码。性能问题的程度取决于程序是如何使用反射的，如果他作为程序中很少涉及的部分，缓慢的性能将不会是一个问题。大量使用反射要慎重

　　2.使用反射会模糊程序内部实际要发生的事情，程序员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比直接代码更复杂。保守的使用反射，仅在他真正可以增加灵活性的地方使用。