反射5.14

1.1什么是反射




动态获取指定类以及类中的内容(成员)，并运行其内容。
应用程序已经运行，无法在其中进行new对象的建立，就无法使用对象。这时可以根据配置文件的类全名去找对应的字节码文件，并加载进内存，并创建该类对象实例。这就需要使用反射技术完成


静态加载:编译时刻加载类是静态加载类(new 对象是静态加载类,在编译的时刻就要加载所有可能用到的类)
动态加载:运行时刻加载类是动态加载类


1.2Java 程序的运行过程


1.3使用反射后Java 程序的运行过程


Java反射：在编译时不确定哪个类被加载，而在程序运行时才加载、探知、使用
1.4反射技术常用API
反射常用的Java 类型
1.Class类—可获取类和类的成员信息 
2.Field类—可访问类的属性  
3.Method类—可调用类的方法 
4.Constructor类—可调用类的构造方法
上述类都位于java.lang.reflect包中
1.5获取class对象的三种方式
获取Class对象的方式一：
通过对象具备的getClass方法(源于Object类的方法)。有点不方便，需要用到该类，并创建该类的对象，再调用getClass方法完成。
Person p = new Person();//创建Peron对象
Class clazz = p.getClass();//通过object继承来的方法(getClass)获取Person对应的字节码文件对象


获取Class对象的方式二：
每一个类型都具备一个class静态属性，通过该属性即可获取该类的字节码文件对象。比第一种简单了一些，仅用一个静态属性就搞定了。但是，还是有一点不方便，还必须要使用到该类。
Class clazz = Person.class;


获取Class对象方式三：
* 去找找Class类中是否有提供获取的方法呢？
* 找到了，static Class forName(className);
* 相对方便的多，不需要直接使用具体的类，只要知道该类的名字即可。
* 而名字完成可以作为参数进行传递 ,这样就可以提高扩展性。
* 所以为了动态获取一个类，第三种方式最为常用。 
    Class clazz = Class.forName("cn.itcast.bean.Person");//必须类全名


创建Person对象的方式
以前：1，先加载cn.itcast.bean.Person类进内存。
  2,将该类封装成Class对象。 
 3,根据Class对象，用new操作符创建cn.itcast.bean.Person对象。
 4,调用构造函数对该对象进行初始化。 
cn.itcast.bean.Person p = new cn.itcast.bean.Person();


通过方式三：(此外还可以使用构造，构造可以指定参数---如String.class)
String className = "cn.itcast.bean.Person";
//1，根据名称获取其对应的字节码文件对象
1，通过forName()根据指定的类名称去查找对应的字节码文件，并加载进内存。
2，并将该字节码文件封装成了Class对象。
3，直接通过newIntstance方法，完成该对象的创建。
4，newInstance方法调用就是该类中的空参数构造函数完成对象的初始化。 
Class clazz = Class.forName(className);
//2，通过Class的方法完成该指定类的对象创建。
Object object = clazz.newInstance();//该方法用的是指定类中默认的空参数构造函数完成的初始化。 


清单1，获取字节码文件中的字段。
Class clazz = Class.forName("cn.itcast.bean.Person");
//获取该类中的指定字段。比如age
Field field = clazz.getDeclaredField("age");//clazz.getField("age"); //为了对该字段进行操作，必须要先有指定类的对象。
Object obj = clazz.newInstance();
//对私有访问，必须取消对其的访问控制检查，使用AccessibleObject父类中的setAccessible的方法
field.setAccessible(true);//暴力访问。建议大家尽量不要访问私有
field.set(obj, 789);
//获取该字段的值。
Object o = field.get(obj);
System.out.println(o);
备注：getDeclaredField：获取所有属性，包括私有。
  getField:获取公开属性，包括从父类继承过来的，不包括非公开方法。
清单2，获取字节码文件中的方法。
//根据名称获取其对应的字节码文件对象
Class clazz = Class.forName("cn.itcast.bean.Person");
//调用字节码文件对象的方法getMethod获取class对象所表示的类的公共成员方法(指定方法)，参数为方法名和当前方法的参数，无需创建对象，它是静态方法
Method method = clazz.getMethod("staticShow", null);
//调用class对象所表示的类的公共成员方法，需要指定对象和方法中的参数列表
method.invoke(null, null);
………………………………………………………………………………………………………
Class clazz = Class.forName("cn.itcast.bean.Person");
//获取指定方法。
Method method = clazz.getMethod("publicShow", null);
//获取指定的类对象。 
Object obj = clazz.newInstance();
method.invoke(obj, null);//对哪个对象调用方法，是参数组
好处：大大的提高了程序的扩展性。


总结:
一般创建对象时，我们直接new 类的对象,这种编程方式 称为硬编码（即:代码写死了），为了后期程序的可扩展,开发中通常采用实例类的完整限定名（包名.类名），通过反射加载字符串指定的类,并通过反射创建对象.






实例：
Cat类






package priv.aten.demo;


public class Cat {
private String name="无名";
@SuppressWarnings("unused")
public  int age=1000;
public Cat() {
super();
System.out.println("我是无参构造函数");
}
@SuppressWarnings("unused")
private Cat(Integer age ){
System.out.println("我是带参私有构造函数");
this.age=age;
}
public Cat(String name, Integer age) {
super();
System.out.println("我是带参构造函数");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@SuppressWarnings("unused")
private void show(){
System.out.println("我爱上了一只小锦");
}
public void love(){
System.out.println(name+"我为啥会爱上你呢");
}

}



main函数：








package priv.aten.demo;


import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;


public class test {


public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
// TODO Auto-generated method stub
// 1.获取属性
// 1.1获取公开的属性
// 1.1.1创建Class类的对象
@SuppressWarnings({ "rawtypes" })
Class class1=Class.forName("priv.aten.demo.Cat");
//获取class对象的三种方式
//1:通过对象具备的getClass方法(源于Object类的方法)。有点不方便，需要用到该类，并创建该类的对象，再调用getClass方法完成。
// Cat cat=new Cat();
// @SuppressWarnings({ "unused", "rawtypes" })
// Class class11=cat.getClass();
//2:每一个类型都具备一个class静态属性，通过该属性即可获取该类的字节码文件对象。比第一种简单了一些，仅用一个静态属性就搞定了。但是，还是有一点不方便，还必须要使用到该类。
// @SuppressWarnings({ "unused", "rawtypes" })
// Class class2=Cat.class;
// //3:相对方便的多，不需要直接使用具体的类，只要知道该类的名字即可。* 而名字完成可以作为参数进行传递 ,这样就可以提高扩展性。 * 所以为了动态获取一个类，第三种方式最为常用。 
// //注意，是动态获取
// @SuppressWarnings({ "unused", "rawtypes" })
// Class class5=Class.forName("priv.aten.demo.Cat");

//1.1.2
//newIntstance方法，完成该对象(class1)的创建,newInstance方法调用就是该类中的空参数构造函数完成对象的初始化。 
// Object cat=class1.newInstance();
// Field field=class1.getDeclaredField("age");
// System.out.println("年龄："+field.get(cat));
//1.1.3操作私有的属性
// Object cat=class1.newInstance();
// Field fieldname=class1.getDeclaredField("name");
// //对私有访问，必须取消对其的访问控制检查，使用AccessibleObject父类中的setAccessible的方法
// fieldname.setAccessible(true);//暴力访问。建议大家尽量不要访问私有
// System.out.println("名字："+fieldname.get(cat));
// fieldname.set(cat, "加菲猫");
// System.out.println("名字："+fieldname.get(cat));
Object cat=class1.newInstance();
@SuppressWarnings("unchecked")
Method method=class1.getMethod("getName", null);//getmethod返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Object obj=method.invoke(cat, null);//对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
System.out.println(obj);
// 1.4 对构造函数的操作 -->无非是通过构造函数 获取一个类的对象
// 1.4.1 公开
@SuppressWarnings("unchecked")
Constructor cc=class1.getConstructor(String.class,Integer.class);//Constructor 提供关于类的单个构造方法的信息以及对它的访问权限。 
//class1.getConstructor方法返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。如果该类没有公共构造方法，或者该类是一个数组类，或者该类反映一个基本类型或 void，则返回一个长度为 0 的数组
Cat cat2=(Cat)cc.newInstance("锦",1);
cat2.love();

// 1.4.2 私有的

// @SuppressWarnings({ "unchecked", "rawtypes" })
// Constructor constructor = class1.getDeclaredConstructor(Integer.class);
// constructor.setAccessible(true);
// Cat cat = (Cat) constructor.newInstance(22);
// cat.love();
}


}




***********************************注意********************************************


Object... object参数


package priv.aten.demo;


public class Demo {


public static void main(String[] args) {
// TODO Auto-generated method stub
love("我不知道自己从什么时候，");
love("开始喜欢你；");
love("经常会想起你，");
love("在我开心快乐的时候，");
love("在我孤独无助的时候。");
}
/**
* 
* @param object
*/
public static void love(Object... object){
for (Object object2 : object) {
System.out.print(object2);
}
}
}