Java-反射机制

1.反射

反射库(Reflection Library)提供一个丰富的工具集，以便编写能够动态操作Java代码的程序。这项功能被

大量的应用在JavaBeans中，它是Java组件的体系结构。

能够分析类能力的程序称为反射(Reflection),即可以将一个类(或基本数据类型)，类成员当成一个对象来操作。

它是运行时检测和修改某个对象的结构及其行为，与内省(introspection)不同。内省是反射的一个子集。

反射：用于运行时检测和修改某个对象的结构及其行为。

内省：用于运行时检测某个对象的类型及其包含的属性。

注意：这里是指运行时期，即如果编译时期不可以做的事情，我在运行时期使用反射就可以做了，如向定义了ArrayList <String>的集合里，运用反射加入int型数据

内省实例： 对象名 instanceof 类名/接口名;//检测某个对象是否属于某个类或接口

反射实例：Class.forName()方法可以获取某个类。

2.Class类

一个Class对象实际上表示的是一个类型，这个类型不一定是一种类，因为它也可以表示基本数据类型。

它可以将Java里的所有东西(类，接口，数组，基本数据类型，void)当成一个对象来对它的属性进行访问。

3.反射包(java.lang.reflect)下的Constructor类，Field类(成员变量)，Method类(成员方法)

总结:

1,创建Class实例对象的三种方法：

a,Class<?> c=Class.forName(String name);

b,Class<?> c=p.getClass();//对象名.getClass()

c,Class<?> c=Person.Class ;//类名.Class;

2,获取构造方法(Constructor)，成员变量(Field)，成员方法(Method)，接口(interface)

Class类： getDeclaredXxxx();// 获取本类中的所有Xxxx,不包括继承父类中xxx

getXxxx();//获取本类中的public权限的Xxxx。

package hq.com.ClassDemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ClassDemo {

/**
* class类的演示
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
Demo1();
System.out.println("---------------------");
Demo2();
System.out.println("---------------------");
Demo3();
System.out.println("---------------------");
Demo4();
System.out.println("---------------------");
Demo5();
System.out.println("---------------------");
Demo6();
System.out.println("---------------------");
Demo7();
System.out.println("---------------------");
Demo8();
}
//1.任何所有东西都是Class类的实例对象
//创建Class实例的三种方法，Class.forName(),类名.class,对象名.getClass().
public static void Demo1() throws ClassNotFoundException
{
Class<?> c1=null;
Class<?> c2=null;
Class<?> c3=null;
//1,Class.forName()方法，推荐
c1=Class.forName("hq.com.ClassDemo.Person");
System.out.println("Demo1(写法1：forName()):类名="+c1.getName());
//2,类名.class。在java中，每个class都有一个相应的Class对象，当编写好一个类，
// 编译完成后，在生成的.class文件中，就产生一个class对象
c2=Person.class;
System.out.println("Demo1(写法2：类名.class)：类名="+c2.getName());
//3，object类的getClass()方法
Person p=new Person();
c3=p.getClass();
System.out.println("Demo2(写法3:getClass()):类名="+c3.getName());
}
// 2，Object的getClass()方法，Class的getName()，getPackage().
// 演示反射机制获取类的包名和类名
public static void Demo2() {
Person p = new Person("hq", 22);
System.out.println("person的类名：" + p.getClass().getName());
System.out.println("person的包名：" + p.getClass().getPackage().getName());
}
//3,class的newInstance()方法
//  通过反射，用class来创建类对象(这是反射的意义所在)
public static void Demo3() throws  Exception
{
Class c=Class.forName("hq.com.ClassDemo.Person");
Person p= (Person) c.newInstance();//要强转，默认是Object类
p.setName("hq");
System.out.println("Demo3(class的newInstance()方法)：name="+p.getName());
}
//4,class的getConstructors();以数组形式返回该类的所有公共构造方法
//   java.lang.reflect.Constructor;构造方法类
public static void Demo4() throws  Exception
{
//用构造方法类创建该类的实例对象。
//注意必须按顺序获取Constructor,即ct[0]在ct[1]之前，不能反过来
Class   c = null;
Person p1 = null;
Person p2 = null;
c = Class.forName("hq.com.ClassDemo.Person");
Constructor<?> [] ct=c.getConstructors();
p1=(Person) ct[0].newInstance();
p1.setName("hh");
p2=(Person) ct[1].newInstance("hq",22);
System.out.println("Demo4(getConstructors()构造方法类创建实例对象):p1:name="+p1.getName());
System.out.println("Demo4(getConstructors()构造方法类创建实例对象):p2:name="+p2.getName());
}

//5,class:  getDeclaredField(String name);获取该类的成员变量
//  Field类:操作类对象的成员变量，set，get方法
public static void Demo5() throws Exception
{
//class的getDeclaredField(String name)方法获取类中的某个成员变量
//Field类的set(Object obj,Object value)，修改该字段上某个对象对应的值
Class  c=Class.forName("hq.com.ClassDemo.Person");
Person p=(Person)c.newInstance();
Field f=c.getDeclaredField("age");
f.setAccessible(true);
f.set(p, 11);
System.out.println("Demo5(Field的set(对象,值))：person:age="+p.getAge());
System.out.println("Field.get():"+f.get(p));

}
//6,获取该类的父类信息，成员方法，接口，成员变量(字段)
public static void Demo6() throws  Exception
{
//注意：getDeclaredFields()和getFields()区别是，
//前者是所有声明的字段,后者是仅为public权限的字段
//注意：两者获取的字段均为该类内部中定义的，不包括继承父类的字段
Class<?> c=Class.forName("hq.com.ClassDemo.SuperMan");
Class<?> superClass=c.getSuperclass();
System.out.println("Demo6:superman的父类是："+superClass.getName());
//获取类中所有字段
Field [] fs=c.getDeclaredFields();
int i=0;
for(Field f:fs)
{
i++;
System.out.println("superman的第"+i+"个成员："+f.getName());
}
//获取类中所有方法
Method [] ms=c.getDeclaredMethods();
for(Method m:ms)
{
i++;
System.out.println("superman的第"+i+"个成员方法："+m.getName());
}
//获取类实现的接口
Class<?>[] is=c.getInterfaces();
for(Class<?> j:is)
{
System.out.println("superman的第"+i+"个接口："+j.getName());
}
}
//7,调用类的方法，Method类的invoke()方法
public static void Demo7() throws Exception
{
Class<?> c=Class.forName("hq.com.ClassDemo.SuperMan");
//调用类中的无参数方法
Method  m1=c.getMethod("fly");
System.out.print("Demo7:superman中的无参数方法fly():");
m1.invoke(c.newInstance());
//调用类中的参数方法，先取出该方法，再放入参数（实例，方法参数）
Method m2=c.getMethod("walk",int.class);
System.out.print("Demo7:superman中的有参数方法walk():");
m2.invoke(c.newInstance(),4);
}
/**
* Demo8: 通过Java反射机制得到类加载器信息
*
* 在java中有三种类类加载器。[这段资料网上截取]

1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。

2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类

3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。
*/
public static void Demo8() throws ClassNotFoundException
{
Class<?> class1 = null;
class1 = Class.forName("hq.com.ClassDemo.SuperMan");
String nameString = class1.getClassLoader().getClass().getName();

System.out.println("Demo8: 类加载器类名: " + nameString);
}
}
class SuperMan extends Person implements ActionInterface
{

private boolean BlueBriefs;
public boolean isBuleBriefs()
{
return this.BlueBriefs;
}
public void setBuleBriefs(boolean BlueBriefs)
{
this.BlueBriefs=BlueBriefs;
}
public void fly()
{
System.out.println("超人会飞哦～～");
}
@Override
public void walk(int m) {
// TODO Auto-generated method stub
System.out.println("超人也会走耶～～走了"+m+"米后走不动了");
}

}
interface ActionInterface
{
public void walk(int m);
}
class Person {
private int age;
private String name;

public Person() {

}

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

public void setAge(int age) {
this.age = age;
}

public int getAge() {
return this.age;
}

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

public String getName() {
return this.name;
}
}