反射的理解[小白篇]

JAVA中的反射是运行中的程序检查自己和软件运行环境的能力，它可以根据它发现的情况进行改变。通俗的讲就是反射可以在运行时根据指定的类名获得类的信息。

首先我们先明确两个概念，静态编译和动态编译。

静态编译：在编译时确定类型，绑定对象,即通过。
动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。

我们可以明确的看出动态编译的好处，而反射就是运用了动态编译创建对象。往往对比能更加直观的向我们展示两者的不同。
此处为代码操作…

若不用反射，它是这样的代码

public interface Fruit {
	void eat();
}
public class Apple implements Fruit{
	@Override
	public void eat() {
		System.out.println("吃苹果..");
	}
}
public class Orange implements Fruit{
	@Override
	public void eat() {
		System.out.println("吃橘子...");
	}
}
//水果工厂类, 生产水果
public class FruitFactory {
	/**
	 * 根据水果名 ,得到水果对象
	 * @param fname
	 * @return
	 */
	public static Fruit getInstance(String fname) {
		Fruit f = null;
		if("apple".equals(fname)) {
			f = new Apple();
		}
		if("orange".equals(fname)){
			f = new Orange();
		}
		return f;
	}
}

public class TestFruit {
	public static void main(String[] args) {
		//根据水果工厂生产出1种水果
		Fruit f = FruitFactory.getInstance("apple");
		f.eat();
	}
}
1public interface Fruit {
    void eat();
}
public class Apple implements Fruit{
    @Override
   public void eat() {
       System.out.println("吃苹果..");
    }
}
public class Orange implements Fruit{
    @Override
    public void eat() {
       System.out.println("吃橘子...");
  }
}
//水果工厂类, 生产水果
public class FruitFactory {
   /**
     * 根据水果名 ,得到水果对象
     * @param fname
     * @return
     */
   public static Fruit getInstance(String fname) {
       Fruit f = null;
        if("apple".equals(fname)) {
            f = new Apple();
       }
        if("orange".equals(fname)){
          f = new Orange();
       }
       return f;
    }


}
public class TestFruit {

   public static void main(String[] args) {
        //根据水果工厂生产出1种水果
        Fruit f = FruitFactory.getInstance("apple");
        f.eat();
    }
}

可以发现，每当我们要添加一种新的水果的时候，我们将不得不改变Factory中的源码，而往往改变原有正确代码是一种十分危险的行为。而且随着水果种类的增加，你会发现你的factory类会越来越臃肿，不得不说这是一种比较low的做法。（初学者可能会问，为什么不直接在main方法中new水果，这是因为我们可能会在getInstance方法中做一些别的事情。。。所以不直接new）
使用反射的代码及优势(除了工厂类和测试类需要改变) 其他不用更换

public class FruitFactory {
	/**
	 * 根据水果名 ,得到水果对象
	 * @param className	传入的类名
	 * @return
	 */
	public static Fruit getInstance(String className) {
		Fruit f = null;
		try {
			//根据传入的类名 得到 水果对象 -- 是一种聪明的做法
			f = (Fruit) Class.forName(className).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return f;
	}
}

public class TestFruit {
	public static void main(String[] args) {
		//根据水果工厂生产出1种水果
		Fruit f = FruitFactory.getInstance("com.hp.reflex.Orange");
		f.eat();
	}
}




public class FruitFactory {
    /**
     * 根据水果名 ,得到水果对象
     * @param className 传入的类名
     * @return
     */

    public static Fruit getInstance(String className) {
        Fruit f = null;
        try {
            //根据传入的类名 得到 水果对象 -- 是一种聪明的做法


            f = (Fruit) Class.forName(className).newInstance();


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


    public static void main(String[] args) {


        //根据水果工厂生产出1种水果


        Fruit f = FruitFactory.getInstance("com.hp.reflex.Orange");


        f.eat();


   }
}

在出现新品种水果的时候，完全不用去修改原有代码。从上面的案例中，我们可以清楚的体会到反射的优越性。

那么有的人又会问，这个例子能完全明白，但是如果放到实际的编程，应用中，我们又会在什么情况下用到反射那？

举一个看到过的例子，在实际开发中，我们需要把一个包中的class
new出来，但是这个包中的类总是需要变动，那么怎么办，难道总是修改main方法中xxx=new xxx()吗。这样无疑是麻烦的。而运用反射。

我们可以相应的增加一个配置文件，在里面记录包中所有的类名，包中类增加时就加一个类名，删除时就删除一个类名。让main方法去读取这个配置文件中的类名，通过反射获得实例，完全不用我们去修改main方法中的代码。(Spring的IOC就是这个原理)

他甚至可以修改其他类中的私有属性。android开发中，我们需要改变一个私有标志位的时候，android源码并没有提供set方法，我们又不能改变源码，怎么办，反射可以完美解决这个问题。

说了这么多，那么我们的开发中，为什么不全部都用反射那？一个原因，开销，它的开销是比较昂贵的，所以尽量在最需要的地方使用反射,而不要在任意一个地方都是用反射。

说完是什么，为什么，我们必然需要掌握如何使用反射，先看反射中涉及了哪些方法。
Class
c=Class.forName(“className”);注明：className必须为全名，也就是得包含包名，比如，cn.zz.pojo.UserInfo;
Object obj=c.newInstance();//创建对象的实例
OK，有了对象就什么都好办了，想要什么信息就有什么信息了。

获得类的构造函数
Constructor getConstructor(Class[] params)//根据指定参数获得public构造器
Constructor[] getConstructors()//获得public的所有构造器
Constructor getDeclaredConstructor(Class[]
params)//根据指定参数获得public和非public的构造器
Constructor[] getDeclaredConstructors()//获得public的所有构造器

获得类中的方法
Method getMethod(String name, Class[] params),根据方法名，参数类型获得方法
Method[] getMethods()//获得所有的public方法
Method getDeclaredMethod(String name, Class[]
params)//根据方法名和参数类型，获得public和非public的方法
Method[] getDeclaredMethods()//获得所以的public和非public方法

获得类中属性
Field getField(String name)//根据变量名得到相应的public变量
Field[] getFields()//获得类中所以public的方法
Field getDeclaredField(String name)//根据方法名获得public和非public变量
Field[] getDeclaredFields()//获得类中所有的public和非public方法
看到这些，你就明白，反射是多么的强大了，当你正确使用这些方法的时候，基本上是掌握了反射的技巧。

还有 反射操作数组：
String[] str = (String[]) Array.newInstance(String.class, 5);
//反射调用sleep方法
Object invoke = method.invoke(obj, 5);//obj.sleep(5);
System.out.println(invoke);

扩展资料:
如果不知道某个对象的确切类型，RTTI可以告诉你，但是有一个前提：这个类型在编译时必须已知，这样才能使用RTTI来识别它。Class类与java.lang.reflect类库一起对反射进行了支持，该类库包含Field、Method和Constructor类，这些类的对象由JVM在启动时创建，用以表示未知类里对应的成员。

这样的话就可以使用Contructor创建新的对象，用get()和set()方法获取和修改类中与Field对象关联的字段，用invoke()方法调用与Method对象关联的方法。另外，还可以调用getFields()、getMethods()和getConstructors()等许多便利的方法，以返回表示字段、方法、以及构造器对象的数组，这样，对象信息可以在运行时被完全确定下来，而在编译时不需要知道关于类的任何事情。

反射机制并没有什么神奇之处，当通过反射与一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类。因此，那个类的.class对于JVM来说必须是可获取的，要么在本地机器上，要么从网络获取。所以对于

RTTI和反射之间的真正区别只在于：
RTTI，编译器在编译时打开和检查.class文件
反射，运行时打开和检查.class文件