java笔录---反射机制(1)

引言

  为了方便记忆java的反射机制，在这里仔细的总结了一下。主要是怕以后忘记了，这样也方便回忆。因为最近利用空余时间深入的了解spring和Mybatis框架，

  像spring中核心模块IOC底层实现的原理就是反射机制，mybatis也是利用java的反射机制来获取和设置对象的值的。由此看来java反射机制还是很强大的，其实也蛮有趣的。

  Java语言允许通过程序化的方式间接对Class的对象实例操作，Class文件由类装载器装载后，在JVM中将形成一份描述Class结构的元信息对象，通过该元信息对象可以获知Class的结构信息：构造函数、属性和方法等。Java允许用户借由这个Class相关的元信息对象间接调用Class对象的功能.

反射定义:

  JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。注意是在运行状态中。

  “程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。Java不是动态语言。但是Java有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

理解反射

看了定义有点稍微的明白了，

反射之中包含了一个“反”的概念，要解释反射就必须先从“正”开始解释，一般而言，要产生实例化对象一定要有类。如下：

import java.util.Date;//先导入类
public class ReflectionDemo {
	public static void main(String[] args) {
		Date date = new Date();//再产对象
		System.out.println(date);
	}
}

而所谓的“反”，是通过对象找到类。在Object类里面提供有一个方法：

public final Class<!--?--> getClass()

通过getClass方法我们可以获取到这个对象对应的反射类

注：反射之中的所有泛型都定义为?，返回值都是Object。

import java.util.Date;//先导入类
public class ReflectionDemo {
	public static void main(String[] args) {
		Date date = new Date();//再产对象
		Class<?> c =date.getClass();
		System.out.println(c);
	}
}
输出为：class java.util.Date

我们发现，调用getClass()后，得到了类的完整名称。也就找到了对象的出处

Class类对象实例化

  java.lang.Class是一个类，它和一般类一样继承自Objec。这个类是反射操作的源头，即所有的反射都要从此类开始进行，如何获取一个对象对应的反射类Class，在Java中我们有三种方法可以获取一个对象的反射类：

1.调用Object类的getClass()方法（很少用到）

即上述例子，此处略过。

2.调用Class类提供的一个静态方法forName：

//import java.util.Date;//先导入类
public class ReflectionDemo {
	public static void main(String[] args) throws Exception  {
		Class<?> c = Class.forName("java.util.Date");
		System.out.println(c);
	}
}
输出：class java.util.Date

注意：此时，无需使用import语句导入一个明确的类，而类名称是采用字符串的形式进行描述的。

3.使用“类.class”取得：

import java.util.Date;//先导入类
public class ReflectionDemo {
	public static void main(String[] args){
		Class<?> c = Date.class;
		System.out.println(c);
	}
}

反射实例化对象

一般情况下，对象的实例化操作需要依靠构造方法和关键字new完成。可是有了Class类对象之后，可以利用反射来实现对象的实例化。

Class<?> c = Class.forName("com.putao.Person");
	Person p = (Person)c.newInstance();//相当于使用new调用无参构造实例化对象
	p.setName("张三");
	System.out.println(p.getName());
输出：张三

  注意：newInstance只能调用默认的无参构造方法,若类中不提供无参构造方法，只能明确的调用有参构造方法。（一般创建类的时候尽量保留有无参构造）

Class类中有取得构造的方法

public Constructor<t> getConstructor(Class<!--?-->... parameterTypes)

Class<?> c = Class.forName("com.putao.Person");
//		Person p = (Person)c.newInstance();
//		p.setName("张三");
	Constructor<?> con = c.getConstructor(String.class,int.class);
    Object obj = con.newInstance("李四",22);//实例化对象
    Person p2 = (Person) obj;
	System.out.println(p2.toString());
输出：Person [name=李四, age=22]

工厂模式的实现

  程序的开发尽量降低耦合。而降低耦合的最好做法是使用接口，但是就算使用了接口也逃不出关键字new，所以实际上new是造成耦合的关键元凶。反射机制实例化对象的时候实际上只需要“包.类”就可以

	package com.putao;
	interface Fruit{
	    public void eat();
	}

	class Apple implements Fruit{
	    @Override
	    public void eat(){
	        System.out.println("eat apple");
	    }
	}
	class Grape implements Fruit{
	    @Override
	    public void eat(){
	        System.out.println("eat grape");
	    }
	}
	class Orange implements Fruit{
	    @Override
	    public void eat(){
	        System.out.println("eat orange");
	    }
	}

	class Factory{
	    public static Fruit getInstance(String className){
	        /*if("apple".equals(className)){
	            return new Apple();
	        }else if("orange".equals(className)){
	            return new Orange();
	        }
	        return null;*/
	        Fruit f = null;
	        try {
	            f = (Fruit)Class.forName(className).newInstance();

	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	        return f;

	    }
	}

	public class FactoryDemo{
	    public static void main(String[] args){
	        /*Fruit f = Factory.getInstance("apple");
	        f.eat();

	        Fruit f1 = Factory.getInstance("orange");
	        f1.eat();*/

	        Fruit f1= Factory.getInstance("com.putao.Apple");
	        f1.eat();

	        Fruit f2 = Factory.getInstance("com.putao.Orange");
	        f2.eat();
	        Fruit f3 = Factory.getInstance("com.putao.Grape");
	        f3.eat();

	    }
	}
	输出：eat apple
	eat orange
	eat grape

即使后来增加了接口的子类，工厂类照样可以完成对象的实例化操作，这样的工厂类，可以应对于所有的变化。这就完成了解耦合的目的，而且扩展性非常强。

通过反射调用方法、成员

Class类中有

取得一个类中的全部方法：
public Method[] getMethods() throws SecurityException
取得指定方法：
public Method getMethod(String name, Class<?>... parameterTypes) throws
NoSuchMethodException, SecurityException
取得全部成员：
public Field[] getDeclaredFields() throws SecurityException
取得指定成员：
public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException

例：获取方法

Class<?> c = Class.forName("com.putao.Person");
	Object obj =c.newInstance();
	Method setMet = c.getMethod("setName", String.class);
	setMet.invoke(obj, "张三");//等价于调用person类的setName("张三")
	Method getMet = c.getMethod("getName");
	System.out.println(getMet.invoke(obj));//等价于调用person类的getName()方法
	输出：张三

例：获取属性

Class<?> c = Class.forName("com.putao.Person");
	Object obj =c.newInstance();
	Field titleField = c.getDeclaredField("name");
    titleField.setAccessible(true);//解除封装
    titleField.set(obj, "张三");//相当于Person类对象.name = "张三"
    System.out.println(titleField.get(obj));//相当于Person类对象。name