反射（一）---类Class

装载：类的装载是通过类加载器完成的，加载器将.class文件的二进制文件装入JVM的方法区，并且在堆区创建描述这个类的java.lang.Class对象。用来封装数据。 但是同一个类只会被类装载器装载一次，记住：只装载一次！

链接：链接就是把二进制数据组装为可以运行的状态。链接分为校验，准备，解析这3个阶段。校验一般用来确认此二进制文件是否适合当前的JVM（版本），准备就是为静态成员分配内存空间，并设置默认值。解析指的是转换常量池中的代码作为直接引用的过程，直到所有的符号引用都可以被运行程序使用（建立完整的对应关系）。

初始化：初始化就是对类中的变量进行初始化值；完成之后，类型也就完成了初始化，初始化之后类的对象就可以正常使用了，直到一个对象不再使用之后，将被垃圾回收。释放空间。
当没有任何引用指向Class对象时就会被卸载，结束类的生命周期。如果再次用到就再重新开始装载、链接和初始化的过程。

通过上面的这一段只想告诉大家一点：类只会被装载一次！！！！利用装载的类可以实例化出各种不同的对象！

类只会被装载一次，利用装载的类可以实例化出各种不同的对象。而反射就是通过获取装载的类来做出各种操作的

IAnimal

package com.harvic.blog_reflect_1;

public interface IAnimal {
	void setName(String name);

	String getName();
}

Animal

package com.harvic.blog_reflect_1;

import java.io.Serializable;

public class Animal implements IAnimal, Serializable {
	private String name;

	@Override
	public String getName() {
		return name;
	}

	@Override
	public void setName(String name) {
		this.name = name;
	}
}

AnimalImpl

package com.harvic.blog_reflect_1;

import java.io.Serializable;

public final class AnimalImpl extends Animal implements Serializable {
}

MyActivity

package com.harvic.blog_reflect_1;

import android.app.Activity;
import android.os.Bundle;
import android.text.SpannableStringBuilder;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import java.lang.reflect.Modifier;

public class MyActivity extends Activity {
	private String TAG = "TAG";

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		Button btn = (Button) findViewById(R.id.btn);
		btn.setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View v) {

				try {
					/**
					 * 1、获取类类型的方法
					 */
					createClassDemo();

					/**
					 * 2.1类名，包名获取
					 */
					getPackageAndName();

					/**
					 * 2.2 获取超类superclass的Class对象
					 */
					getSuperClass();

					/**
					 * 2.3 获取类所直接继承的接口的Class对象
					 */
					getInterfaceClas();

					/**
					 * 3、获取类的访问修饰符
					 */
					getclassModifiers();

					/**
					 * 4、获取接口的访问修饰符
					 */
					getInterfaceModifiers();

				} catch (Exception e) {
					Log.e(TAG, e.getMessage());
				}
			}
		});
	}

	/**
	 * 1、 获取类类型的方法
	 * 
	 * @throws Exception
	 */
	public void createClassDemo() throws Exception {
		// 方法一
		Animal animal = new Animal();
		Class<?> clazz1 = animal.getClass();
		// 方法二
		Class<?> clazz2 = Animal.class;
		// 方法三
		Class<?> clazz3 = Class.forName("com.harvic.blog_reflect_1.Animal");
		// 方法四
		Class<?> clazz4 = getClassLoader().loadClass(
				"com.harvic.blog_reflect_1.Animal");

		// 类只会被加载一次，所以clazz1，clazz2，clazz3，clazz4都是相等的
		boolean result = (clazz1 == clazz2 && clazz3 == clazz4 && clazz1 == clazz3);
		Log.d(TAG, "这四个class的对象对比的结果是：" + result + "");

	}

	/**
	 * 2.1类名，包名获取
	 */
	public void getPackageAndName() {
		Class<?> clazz = Animal.class;
		Package package1 = clazz.getPackage();
		Log.d(TAG, "完整的类名：" + clazz.getName());
		Log.d(TAG, "仅获取类名：" + clazz.getSimpleName());
		Log.d(TAG, "包名：" + package1.getName());
	}

	/**
	 * 2、2获取超类superclass的Class对象
	 * 
	 * @throws Exception
	 */
	public void getSuperClass() throws Exception {
		// 获取超类Class对象
		Class<?> clazz = Class.forName("com.harvic.blog_reflect_1.AnimalImpl");
		Class<?> parentClass = clazz.getSuperclass();
		Log.d(TAG, "父类：" + parentClass.getName());
	}

	/**
	 * 2、3获取类所直接继承的接口的Class对象
	 * 
	 * @throws Exception
	 */
	public void getInterfaceClas() throws Exception {
		Class<?> class3 = Animal.class;
		Class<?>[] interfaces = class3.getInterfaces();
		for (Class interItem : interfaces) {
			Log.d(TAG, "Animal继承的接口：" + interItem.getName());
		}

		class3 = AnimalImpl.class;
		interfaces = class3.getInterfaces();
		if (interfaces.length > 0) {
			for (Class interItem : interfaces) {
				Log.d(TAG, "AnimalImpl继承的接口：" + interItem.getName());
			}
		} else {
			Log.d(TAG, "AnimalImpl无继承的接口");
		}
	}

	/**
	 * 3、获取类的访问修饰符
	 * 
	 * @throws Exception
	 */
	public void getclassModifiers() throws Exception {
		// 返回类的定义修饰符
		Class<?> clazz = getClassLoader().loadClass(InnerClass.class.getName());
		int modifiers = clazz.getModifiers();
		String retval = Modifier.toString(modifiers);
		boolean isFinal = Modifier.isFinal(modifiers);
		Log.d(TAG, "InnerClass的定义修饰符:" + retval);
		Log.d(TAG, "is Final:" + isFinal);
	}

	/**
	 * 4、获取接口的访问修饰符
	 * 
	 * @throws Exception
	 */
	public void getInterfaceModifiers() throws Exception {
		// 获取接口的访问修饰符
		Class<?> clazz2 = InnerInteface.class;
		int modifiers = clazz2.getModifiers();
		String retval = Modifier.toString(modifiers);
		boolean isInteface = Modifier.isInterface(modifiers);
		Log.d(TAG, "InnerClass的定义修饰符:" + retval);
		Log.d(TAG, "isInteface:" + isInteface);

	}

	public static final class InnerClass {

	}

	public static interface InnerInteface {

	}

}