14.2 Class 对象
https://github.com/zhaojiatao/javase
1、什么是Class对象，Class对象是用来做什么的？
Class对象是java程序用来创建类的所有常规对象用的；每个类都有一个Class对象；
2、Class对象是如何创建的？
当程序创建第一个对类的静态成员(static修饰的成员以及构造方法)的引用时，就会加载这个类。类加载器首先检查这个类的
Class对象是否已经加载；如果尚未加载，默认的类加载器就会查找.class文件。在加载字节码后会执行安全验证，之后会根
据字节码在内存中创建这个类的Class对象；
3、除了jvm的类加载器会获取某个类的Class对象之外，我们自己如何获取某个类的Class对象的引用？
这个例子会介绍第一种方法：使用Class类的forName()方法，获取类的Class对象的引用；这个方法的副作用是，如果jvm
还未加载这个类的Class对象的话就加载这个类；在类加载的过程中，会初始化static成员；
注意，传递给forName方法的名字，必须是全限定名；
此外，还可以使用类字面常量的方法来生成对类Class对象的引用；
package thinkingInJava.chapter_14_classInfo; /**
* @author zhaojiatao
* @date 2018/9/9
*
* 1、什么是Class对象，Class对象是用来做什么的？
* Class对象是java程序用来创建类的所有常规对象用的；每个类都有一个Class对象；
* 2、Class对象是如何创建的？
* 当程序创建第一个对类的静态成员(static修饰的成员以及构造方法)的引用时，就会加载这个类。类加载器首先检查这个类的
* Class对象是否已经加载；如果尚未加载，默认的类加载器就会查找.class文件。在加载字节码后会执行安全验证，之后会根
* 据字节码在内存中创建这个类的Class对象；
* 3、除了jvm的类加载器会获取某个类的Class对象之外，我们自己如何获取某个类的Class对象的引用？
* 这个例子会介绍第一种方法：使用Class类的forName()方法，获取类的Class对象的引用；这个方法的副作用是，如果jvm
* 还又有加载这个类的Class对象的话就加载这个类；在类加载的过程中，会初始化static成员；
* 注意，传递给forName方法的名字，必须是全限定名；
* 此外，还可以使用类字面常量的方法来生成对类Class对象的引用；
*
*
*/
interface HasBatteries{} interface Waterproof{} interface Shoots{} class Toy{
Toy(){}
Toy(int i){}
} class FancyToy extends Toy implements HasBatteries,Waterproof,Shoots{
FancyToy(){
super(1);
}
} public class Test2 { //通过Class对象，可以得到Class对象的多有信息
static void printInfo(Class cc){
System.out.println("Class name:"+cc.getName()+"is interface?["+cc.isInterface()+"]");
System.out.println("Simple name:"+cc.getSimpleName());
System.out.println("Canonical name:"+cc.getCanonicalName());
} public static void main(String[] args) {
Class c=null; try{
//注意，必须使用全限定名
c=Class.forName("thinkingInJava.chapter_14_classInfo.FancyToy");
}catch (ClassNotFoundException e){
System.out.println("Can't find Test2");
System.exit(1);
} printInfo(c); for(Class face:c.getInterfaces()){
printInfo(face);
} Class up=c.getSuperclass();
Object obj=null;
try{
//使用newInstance来创建的类，必须带有默认构造器
obj=up.newInstance();
}catch(InstantiationException e){
System.out.println("Cannot instantiate");
System.exit(1);
}catch (IllegalAccessException e){
System.out.println("Cannot access");
System.exit(1);
}
printInfo(obj.getClass()); System.out.println(obj instanceof Toy); } }
14.2.1 字面类常量
除了使用class的forName方法获取类的Class对象的引用外，还可以使用类字面常量；
这种方式不仅简单，且更安全，因为会在类编译期就进行安全检查；
注意，使用.class的方式，获取类的Class对象的引用，不会像forName()那样初始化类的Class对象；
.class的方式仅仅是获取了Class对象的引用，只有到了类真正被初始化结束后，Class对象才真正被初始化；即：
只有在对静态方法或非常数静态域进行首次引用时才执行初始化；
package thinkingInJava.chapter_14_classInfo; import java.util.Random; /**
* @author zhaojiatao
* @date 2018/9/10
*
* 除了使用class的forName方法获取类的Class对象的引用外，还可以使用类字面常量；
* 这种方式不仅简单，且更安全，因为会在类编译期就进行安全检查；
* 注意，使用.class的方式，获取类的Class对象的引用，不会像forName()那样初始化类的Class对象；
* .class的方式仅仅是获取了Class对象的引用，只有到了类真正被初始化结束后，Class对象才真正被初始化；即：
* 只有在对静态方法或非常数静态域进行首次引用时才执行初始化；
*
*/
public class Test2_1 {
public static Random rand=new Random(47); public static void main(String[] args) throws ClassNotFoundException {
Class initable=Initable.class;
System.out.println("这个时候仅仅是获取到了Initable类的Class对象引用，Class对象还没初始化");
//对于static final值是编译期常量，则该值无需对类初始化就可以被读取；
System.out.println(Initable.staticFinal);
//非编译期常量，即使被static和final修饰，也必须先初始化类Class对象，才能读取；
System.out.println(Initable.staticFinal2); //如果一个static域不是final的，那么在对它访问时，总是要求在它被读取之前，先进行链接(为这个域分配存储空间)
//以及初始化(初始化该存储空间)
System.out.println(Initable2.staticNonFinal); //使用forName方法，就会初始化类
Class initable3=Class.forName("thinkingInJava.chapter_14_classInfo.Initable3");
System.out.println(Initable3.staticNonFinal); } } class Initable{
static final int staticFinal=47;
static final int staticFinal2=(int)(1+Math.random()*(10-1+1));
static {
System.out.println("Initializing Initable");
}
} class Initable2{
static int staticNonFinal=147;
static {
System.out.println("Initializing Initable2");
}
} class Initable3{
static int staticNonFinal=74;
static{
System.out.println("Initializing Initable3");
}
}
14.2.2 泛化
学习范型在Class引用的使用过程的应用
package thinkingInJava.chapter_14_classInfo; import org.junit.Test; import java.util.ArrayList;
import java.util.List; /**
* @author zhaojiatao
* @date 2018/9/11
*
*
* 学习范型在Class引用的使用过程的应用
*
*
*/
public class Test2_2 { @Test
public void Test01() {
Class intClass=int.class;
Class<Integer> genericIntClass=int.class;
genericIntClass=Integer.class;
//如果将genericIntClass这个Class引用赋值给double.class的话，会由于类型检查失败，是无法编译；
//genericIntClass=double.class;
//普通类的引用可以赋值为任何其他的Class对象；
intClass = double.class;
} //可以使用通配符?代替上例中的<Integer>，
@Test
public void Test02() {
Class<?> intClass=int.class;
intClass = double.class;
} //如果我像创建一个Class对象的引用，并指定这个Class对象的类型为指定类型或其子类型，则需要使用? extend XXX
@Test
public void Test03() {
Class<? extends Number> bounded=int.class;
bounded = double.class;
bounded = Number.class;
} //至此，可以得出结论，使用范型语法的目的是为了提供编译期检查； @Test
public void Test04(){
FilledList<CountedInteger> fl=new FilledList<CountedInteger>(CountedInteger.class);
System.out.println(fl.create(15));
} @Test
public void Test05() throws IllegalAccessException, InstantiationException {
Class<A> a=A.class;
A aa=a.newInstance();
//注意，这里如果不写成这样会报错
Class<? super A> b=a.getSuperclass(); //注意：b.newInstance返回的不是精确值，而是Object;
Object bb=b.newInstance(); } } class CountedInteger{
private static long counter;
private final long id=counter++;
public String toString(){
return Long.toString(id);
}
} //注意，由于这个类中使用了type.newInstance()方法，所以，必须保证T传进来的类有默认构造方法；
class FilledList<T>{
private Class<T> type;
public FilledList(Class<T> type){
this.type=type;
} public List<T> create(int nElements){
List<T> result=new ArrayList<T>();
try{
for(int i=0;i<nElements;i++){
//注意，当在type上使用范型，newInstance()方法将产生确定的类型；
result.add(type.newInstance());
}
}catch (Exception e){
e.printStackTrace();
}
return result;
} } class A{ } class B extends A{ }
14.3 类型转换前先做检查
在类型转换之前先做检查，如果贸然强制转换，可能会抛出ClassCastException异常；
学习使用instance of 和isInstance()进行类型检查；
主要区别就是instance of是编译器进行类型检查；
而 isInstance方法是运行期，动态进行类型检查，可用于反射、泛型中；
package thinkingInJava.chapter_14_classInfo; /**
* @author zhaojiatao
* @date 2018/9/11
*
* 在类型转换之前先做检查，如果贸然强制转换，可能会抛出ClassCastException异常；
* 学习使用instance of 和isInstance()进行类型检查；
* 主要区别就是instance of是编译器进行类型检查；
* 而 isInstance方法是运行期，动态进行类型检查，可用于反射、泛型中；
*
*/ public class Test3 {
public static boolean DynamicEqual(Object fatherObj,Object sonObj){
return fatherObj.getClass().isInstance(sonObj); // pass
// return sonObj.getClass().isInstance(fatherObj);
// return sonObj instanceof Father; // pass
// return sonObj instanceof (fatherObj.getClass()); //error
} public static void main(String[] args){
//instance of 编译器类型检查
Father father = new Father();
Son son = new Son(); System.out.println(son instanceof Son); // true
System.out.println(son instanceof Father); // true
System.out.println(son instanceof Object); // true
System.out.println(null instanceof Object); // false
System.out.println(); //运行时动态类型检查(括号里的是子类)
System.out.println(Son.class.isInstance(son)); // true
//很明显是错误的，但编译是可以通过的
System.out.println(Integer.class.isInstance(son));//false
System.out.println(Father.class.isInstance(son)); // true
System.out.println(Object.class.isInstance(son)); // true
System.out.println(Object.class.isInstance(null)); // false
System.out.println(); //different using
System.out.println(DynamicEqual(father, son));
} } class Father{} class Son extends Father{}
14.4注册工厂
工厂设计模式：将对象的创建工作交给类自己去完成；工厂方法可以被多态地调用，从而为你创建恰当类型的对象。
package thinkingInJava.chapter_14_classInfo; import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random; /**
* @author zhaojiatao
* @date 2018/9/12
* 工厂方法设计模式：
* 将对象的创建工作交给类自己去完成；工厂方法可以被多态地调用，从而为你创建恰当类型的对象。
*/
public class Test4 { public static void main(String[] args) {
for(int i=0;i<10;i++){
System.out.println(Part.createRandom());
}
} } interface Factory<T>{
T create();
} class Part{
public String toString(){
return getClass().getSimpleName();
} static List<Factory<? extends Part>> partFactories=new ArrayList<>(); static {
/*partFactories.add(new FuelFilter.Factory());
partFactories.add(new AirFilter.Factory());
partFactories.add(new CabinAirFilter.Factory());
partFactories.add(new OilFilter.Factory()); partFactories.add(new FanBelt.Factory());
partFactories.add(new GeneratorBelt.Factory());
partFactories.add(new PowerSteeringBelt.Factory());*/
Collections.addAll(partFactories,new FuelFilter.Factory(),new AirFilter.Factory(),new CabinAirFilter.Factory(),
new OilFilter.Factory(),new FanBelt.Factory(),new GeneratorBelt.Factory(),new PowerSteeringBelt.Factory()
); } private static Random rand=new Random(47);
public static Part createRandom(){
int n =rand.nextInt(partFactories.size());
return partFactories.get(n).create();
} } class Filter extends Part{} class FuelFilter extends Filter{
public static class Factory implements thinkingInJava.chapter_14_classInfo.Factory<FuelFilter>{
@Override
public FuelFilter create() {
return new FuelFilter();
}
}
} class AirFilter extends Filter{
public static class Factory implements thinkingInJava.chapter_14_classInfo.Factory<AirFilter>{
@Override
public AirFilter create() {
return new AirFilter();
}
}
} class CabinAirFilter extends Filter{
public static class Factory implements thinkingInJava.chapter_14_classInfo.Factory<CabinAirFilter>{
@Override
public CabinAirFilter create() {
return new CabinAirFilter();
}
}
} class OilFilter extends Filter{
public static class Factory implements thinkingInJava.chapter_14_classInfo.Factory<OilFilter>{
@Override
public OilFilter create() {
return new OilFilter();
}
}
} class Belt extends Part{ } class FanBelt extends Belt{
public static class Factory implements thinkingInJava.chapter_14_classInfo.Factory<FanBelt>{
@Override
public FanBelt create() {
return new FanBelt();
}
}
} class GeneratorBelt extends Belt{
public static class Factory implements thinkingInJava.chapter_14_classInfo.Factory<GeneratorBelt>{
@Override
public GeneratorBelt create() {
return new GeneratorBelt();
}
}
} class PowerSteeringBelt extends Belt{
public static class Factory implements thinkingInJava.chapter_14_classInfo.Factory<PowerSteeringBelt>{
@Override
public PowerSteeringBelt create() {
return new PowerSteeringBelt();
}
}
}
14.5 instanceof 与 Class的等价性
这一章节，其实主要就是讲解instanceof、isInstance()、class对象== 三者的不同；
instanceof和isInstance()是一组，结果是相同的，区别在前文已经说过，前者需要在编译器进行类型检查，后者只在运行时进行类型检查；
而比较class对象的==和equals一组，结果也是相同的，应为equals是比较两个class对象的内存地址是否一致；
但综合起来看，这两组的结果是不一样的。instance和isInstance()考虑了继承的情况，而后一组没有；
package thinkingInJava.chapter_14_classInfo; /**
* @author zhaojiatao
* @date 2018/9/12
*/
public class Test5 {
public static void main(String[] args) {
FamilyVsExactType.test(new Base());
FamilyVsExactType.test(new Derived());
}
} class Base{}
class Derived extends Base{} class FamilyVsExactType {
static void test(Object x){
System.out.println("Testing x of type "+x.getClass());
System.out.println("x instanceof Base "+(x instanceof Base));
System.out.println("x instanceof Derived "+Derived.class.isInstance(x));
System.out.println("Base.isInstance(x) "+Base.class.isInstance(x));
System.out.println("Derived.isInstance(x) "+Derived.class.isInstance(x));
System.out.println("x.getClass()==Base.class "+(x.getClass()==Base.class));
System.out.println("x.getClass()==Derived.class "+(x.getClass()==Derived.class));
System.out.println("x.getClass().equals(Base.class) "+x.getClass().equals(Base.class));
System.out.println("x.getClass().equals(Derived.class) "+x.getClass().equals(Derived.class));
}
}
14.6 反射与内省
14.6.1Java反射机制的适用场景及其利与弊(引用：https://blog.csdn.net/zolalad/article/details/29370565)
一、反射的适用场景是什么？
1）.Java的反射机制在做基础框架的时候非常有用，有一句话这么说来着：反射机制是很多Java框架的基石。而一般应用层面很少用，不过这种东西，现在很多开源框架基本都已经给你封装好了，自己基本用不着写。典型的除了Hibernate之外，还有Spring也用到很多反射机制。经典的就是在xml文件或者properties里面写好了配置，然后在Java类里面解析xml或properties里面的内容，得到一个字符串，然后用反射机制，根据这个字符串获得某个类的Class实例，这样就可以动态配置一些东西，不用每一次都要在代码里面去new或者做其他的事情，以后要改的话直接改配置文件，代码维护起来就很方便了，同时有时候要适应某些需求，Java类里面不一定能直接调用另外的方法，这时候也可以通过反射机制来实现。
总的来说，自己写的很少，具体什么时候要用那要看需求，反射机制无非就是根据一个String来得到你要的实体对象，然后调用它原来的东西。但是如果是要自己写框架的话，那就会用得比较多了。
2）当你做一个软件可以安装插件的功能，你连插件的类型名称都不知道，你怎么实例化这个对象呢？因为程序是支持插件的（第三方的），在开发的时候并不知道 。所以无法在代码中 New出来 ，但反射可以，通过反射，动态加载程序集，然后读出类，检查标记之后再实例化对象，就可以获得正确的类实例。
3）在编码阶段不知道那个类名,要在运行期从配置文件读取类名, 这时候就没有办法硬编码new ClassName(),而必须用到反射才能创建这个对象.反射的目的就是为了扩展未知的应用。比如你写了一个程序，这个程序定义了一些接口，只要实现了这些接口的dll都可以作为插件来插入到这个程序中。那么怎么实现呢？就可以通过反射来实现。就是把dll加载进内存，然后通过反射的方式来调用dll中的方法。很多工厂模式就是使用的反射。
二、程序员在自己的业务开发中应该尽量的远离反射
反射：在流行的库如Spring和Hibernate中，反射自然有其用武之地。不过内省业务代码在很多时候都不是一件好事，原因有很多，一般情况下我总是建议大家不要使用反射。
首先是代码可读性与工具支持。打开熟悉的IDE，寻找你的Java代码的内部依赖，很容易吧。现在，使用反射来替换掉你的代码然后再试一下，结果如何呢？如果通过反射来修改已经封装好的对象状态，那么结果将会变得更加不可控。请看看如下示例代码：
如果这样做就无法得到编译期的安全保证。就像上面这个示例一样，你会发现如果getDeclaredField()方法调用的参数输错了，那么只有在运行期才能发现。要知道的是，寻找运行期Bug的难度要远远超过编译期的Bug。
最后还要谈谈代价问题。JIT对反射的优化程度是不同的，有些优化时间会更长一些，而有些甚至是无法应用优化。因此，有时反射的性能损失可以达到几个数量级的差别。不过在典型的业务应用中，你可能不会注意到这个代价。
总结一下，我觉得在业务代码中唯一合理(直接)使用反射的场景是通过AOP。除此之外，你最好远离反射这一特性。
三、性能分析
反射机制是一种程序自我分析的能力。用于获取一个类的类变量，构造函数，方法，修饰符。
优点：运行期类型的判断，动态类加载，动态代理使用反射。
缺点：性能是一个问题，反射相当于一系列解释操作，通知jvm要做的事情，性能比直接的java代码要慢很多。
14.6.2反射的一些常用操作：参考：https://blog.csdn.net/sinat_38259539/article/details/71799078
package thinkingInJava.chapter_14_classInfo; import org.junit.Test; import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Properties; /**
* @author zhaojiatao
* @date 2018/9/13
*
* 反射的应用场景：https://blog.csdn.net/zolalad/article/details/29370565
* 反射的一些常用操作：参考：https://blog.csdn.net/sinat_38259539/article/details/71799078
*
*/
class Student { //---------------构造方法-------------------
//（默认的构造方法）
Student(String str){
System.out.println("(默认)的构造方法 s = " + str);
} //无参构造方法
public Student(){
System.out.println("调用了公有、无参构造方法执行了。。。");
} //有一个参数的构造方法
public Student(char name){
System.out.println("姓名：" + name);
} //有多个参数的构造方法
public Student(String name ,int age){
System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。
} //受保护的构造方法
protected Student(boolean n){
System.out.println("受保护的构造方法 n = " + n);
} //私有构造方法
private Student(int age){
System.out.println("私有的构造方法 年龄："+ age);
} //**********字段*************//
public String name;
protected int age;
char sex;
private String phoneNum; //**************成员方法***************//
public void show1(String s){
System.out.println("调用了：公有的，String参数的show1(): s = " + s);
}
protected void show2(){
System.out.println("调用了：受保护的，无参的show2()");
}
void show3(){
System.out.println("调用了：默认的，无参的show3()");
}
private String show4(int age){
System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);
return "abcd";
} @Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", sex=" + sex
+ ", phoneNum=" + phoneNum + "]";
} public static void main(String[] args) {
System.out.println("main方法执行了。。。");
} public void show(){
System.out.println("is show()");
} } public class Test6 {
/*
* 通过Class对象可以获取某个类中的：构造方法、成员变量、成员方法；并访问成员；
*
* 1.获取构造方法：
* 1).批量的方法：
* public Constructor[] getConstructors()：所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有) * 2).获取单个的方法，并调用：
* public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
* public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
*
* 调用构造方法：
* Constructor-->newInstance(Object... initargs)
*
* 2.设置字段的值：
* Field --> public void set(Object obj,Object value):
* 参数说明：
* 1.obj:要设置的字段所在的对象；
* 2.value:要为字段设置的值；
*
*
*/ //通过反射获取构造方法并使用
@Test
public void test01() { //1.加载Class对象
Class clazz = null;
try {
clazz = Class.forName("thinkingInJava.chapter_14_classInfo.Student");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} //2.获取所有公有构造方法
System.out.println("**********************所有公有构造方法*********************************");
//Returns an array containing Constructor objects reflecting all the public constructors of the class represented by this Class object.
Constructor[] conArray = clazz.getConstructors();
for(Constructor c : conArray){
System.out.println(c);
} System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");
//Returns an array of Constructor objects reflecting all the constructors declared by the class represented by this Class object.
conArray = clazz.getDeclaredConstructors();
for(Constructor c : conArray){
System.out.println(c);
} System.out.println("*****************获取公有、无参的构造方法*******************************");
Constructor con = null;
try {
con = clazz.getConstructor(null);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
//1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
//2>、返回的是描述这个无参构造函数的类对象。 System.out.println("con = " + con);
//调用构造方法
Object obj = null;
try {
obj = con.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
System.out.println("obj = " + obj);
Student stu = (Student)obj;
System.out.println("使用无参构造方法创建的Student对象的实例：stu="+stu.toString()); System.out.println("******************获取私有构造方法，并调用*******************************");
try {
con = clazz.getDeclaredConstructor(char.class);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
System.out.println(con);
//调用构造方法
con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
try {
obj = con.newInstance('男');
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} System.out.println("obj = " + obj);
stu = (Student)obj;
System.out.println("使用私有构造方法创建的Student对象的实例：stu="+stu.toString()); } //获取成员变量并调用
@Test
public void test02() throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException,
InvocationTargetException, InstantiationException {
//1.获取Class对象
Class stuClass = Class.forName("thinkingInJava.chapter_14_classInfo.Student");
//2.获取字段
System.out.println("************获取所有公有的字段********************");
Field[] fieldArray = stuClass.getFields();
for(Field f : fieldArray){
System.out.println(f);
}
System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");
fieldArray = stuClass.getDeclaredFields();
for(Field f : fieldArray){
System.out.println(f);
}
System.out.println("*************获取公有字段xx并调用***********************************");
Field f = stuClass.getField("name");
System.out.println(f);
//获取一个对象
Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
//为字段设置值
f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
//验证
Student stu = (Student)obj;
System.out.println("验证姓名：" + stu.name); System.out.println("**************获取私有字段****并调用********************************");
f = stuClass.getDeclaredField("phoneNum");
System.out.println(f);
f.setAccessible(true);//暴力反射，解除私有限定
f.set(obj, "18888889999");
System.out.println("验证电话：" + stu); } //获取成员方法并调用
@Test
public void test03() throws Exception { //1.获取Class对象
Class stuClass = Class.forName("thinkingInJava.chapter_14_classInfo.Student");
//2.获取所有公有方法
System.out.println("***************获取所有的”公有“方法*******************");
stuClass.getMethods();
Method[] methodArray = stuClass.getMethods();
for(Method m : methodArray){
System.out.println(m);
}
System.out.println("***************获取所有的方法，包括私有的*******************");
methodArray = stuClass.getDeclaredMethods();
for(Method m : methodArray){
System.out.println(m);
}
System.out.println("***************获取公有的show1()方法*******************");
Method m = stuClass.getMethod("show1", String.class);
System.out.println(m);
//实例化一个Student对象
Object obj = stuClass.getConstructor().newInstance();
m.invoke(obj, "刘德华"); System.out.println("***************获取私有的show4()方法******************");
m = stuClass.getDeclaredMethod("show4", int.class);
System.out.println(m);
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result); } //反射main方法
@Test
public void test04(){
try {
//1、获取Student对象的字节码
Class clazz = Class.forName("thinkingInJava.chapter_14_classInfo.Student"); //2、获取main方法
Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，
//3、调用main方法
// methodMain.invoke(null, new String[]{"a","b","c"});
//第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
//这里拆的时候将 new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一
//methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二 } catch (Exception e) {
e.printStackTrace();
} } //反射方法的其它使用之---通过反射运行配置文件内容
@Test
public void test05() throws Exception {
Properties pro = new Properties();
{//此方式要求 配置文件在 src 文件夹 内 //类名.class.getClassLoader().getResourceAsStream("文件名")
InputStream inStream = this.getClass().getClassLoader().getResourceAsStream("pro.properties");
pro.load(inStream);
inStream.close();
} //通过反射获取Class对象
Class stuClass = Class.forName(pro.getProperty("className"));//"cn.fanshe.Student"
//2获取show()方法
Method m = stuClass.getMethod(pro.getProperty("methodName"));//show
//3.调用show()方法
m.invoke(stuClass.getConstructor().newInstance()); } //反射方法的其它使用之---通过反射越过泛型检查
@Test
public void test06() throws Exception{
ArrayList<String> strList = new ArrayList<String>();
strList.add("aaa");
strList.add("bbb"); // strList.add(100);
//获取ArrayList的Class对象，反向的调用add()方法，添加数据
Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
//获取add()方法
Method m = listClass.getMethod("add", Object.class);
//调用add()方法
m.invoke(strList, 100); //遍历集合
for(Object obj : strList){
System.out.println(obj);
} } }
14.6.3 内省(参考：http://www.cnblogs.com/peida/archive/2013/06/03/3090842.html)
内省(Introspector) 是Java 语言对 JavaBean 类属性、事件的一种缺省处理方法。
JavaBean是一种特殊的类，主要用于传递数据信息，这种类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。如果在两个模块之间传递信息，可以将信息封装进JavaBean中，这种对象称为“值对象”(Value Object)，或“VO”。方法比较少。这些信息储存在类的私有变量中，通过set()、get()获得。
什么时候会用到内省？
在框架设计的时候使用比较多，像mybatis中类与表的映射关系的类的属性与表的列一一对应，框架在赋值和获取值得时候会调用对应的setter和getter方法；
例如spring 中初始化bean的时候取药用到反射的方式实例化bean，在set值的时候会根据变量名获得settter方法，把配置好的值set进去；
package thinkingInJava.chapter_14_classInfo; import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.junit.Test; import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; /**
* @author zhaojiatao
* @date 2018/9/13
*
* 内省:
* http://www.cnblogs.com/peida/archive/2013/06/03/3090842.html
* https://blog.csdn.net/u010445297/article/details/60967146
*
*/
public class Test6_Introspector { public static void main(String[] args) {
UserInfo userInfo=new UserInfo();
userInfo.setUserName("peida");
try {
BeanInfoUtil.getProperty(userInfo, "userName"); BeanInfoUtil.setProperty(userInfo, "userName"); BeanInfoUtil.getProperty(userInfo, "userName"); BeanInfoUtil.setPropertyByIntrospector(userInfo, "userName"); BeanInfoUtil.getPropertyByIntrospector(userInfo, "userName"); BeanInfoUtil.setProperty(userInfo, "age");
//说明：BeanInfoUtil.setProperty(userInfo, "age");报错是应为age属性是int数据类型，
//而setProperty方法里面默认给age属性赋的值是String类型。所以会爆出argument type mismatch参数类型不匹配的错误信息。 } catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } @Test
public void testBeanUtils(){
UserInfo userInfo=new UserInfo();
try {
BeanUtils.setProperty(userInfo, "userName", "peida"); System.out.println("set userName:"+userInfo.getUserName()); System.out.println("get userName:"+BeanUtils.getProperty(userInfo, "userName")); BeanUtils.setProperty(userInfo, "age", 18);
System.out.println("set age:"+userInfo.getAge()); System.out.println("get age:"+BeanUtils.getProperty(userInfo, "age")); System.out.println("get userName type:"+BeanUtils.getProperty(userInfo, "userName").getClass().getName());
System.out.println("get age type:"+BeanUtils.getProperty(userInfo, "age").getClass().getName()); PropertyUtils.setProperty(userInfo, "age", 8);
System.out.println(PropertyUtils.getProperty(userInfo, "age")); System.out.println(PropertyUtils.getProperty(userInfo, "age").getClass().getName()); PropertyUtils.setProperty(userInfo, "age", "8");
}
catch (IllegalAccessException e) {
e.printStackTrace();
}
catch (InvocationTargetException e) {
e.printStackTrace();
}
catch (NoSuchMethodException e) {
e.printStackTrace();
}
} } class BeanInfoUtil { public static void setProperty(UserInfo userInfo,String userName){
PropertyDescriptor propDesc= null;
try {
propDesc = new PropertyDescriptor(userName,UserInfo.class);
} catch (IntrospectionException e) {
e.printStackTrace();
}
Method methodSetUserName=propDesc.getWriteMethod();
try {
methodSetUserName.invoke(userInfo, "wong");
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
System.out.println("set userName:"+userInfo.getUserName());
} public static void getProperty(UserInfo userInfo,String userName){
PropertyDescriptor proDescriptor = null;
try {
proDescriptor = new PropertyDescriptor(userName,UserInfo.class);
} catch (IntrospectionException e) {
e.printStackTrace();
}
Method methodGetUserName=proDescriptor.getReadMethod();
Object objUserName= null;
try {
objUserName = methodGetUserName.invoke(userInfo);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
System.out.println("get userName:"+objUserName.toString());
} public static void setPropertyByIntrospector(UserInfo userInfo,String userName){
BeanInfo beanInfo= null;
try {
beanInfo = Introspector.getBeanInfo(UserInfo.class);
} catch (IntrospectionException e) {
e.printStackTrace();
}
PropertyDescriptor[] proDescrtptors=beanInfo.getPropertyDescriptors();
if(proDescrtptors!=null&&proDescrtptors.length>0){
for(PropertyDescriptor propDesc:proDescrtptors){
if(propDesc.getName().equals(userName)){
Method methodSetUserName=propDesc.getWriteMethod();
try {
methodSetUserName.invoke(userInfo, "alan");
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
System.out.println("set userName:"+userInfo.getUserName());
break;
}
}
}
} public static void getPropertyByIntrospector(UserInfo userInfo,String userName){
BeanInfo beanInfo= null;
try {
beanInfo = Introspector.getBeanInfo(UserInfo.class);
} catch (IntrospectionException e) {
e.printStackTrace();
}
PropertyDescriptor[] proDescrtptors=beanInfo.getPropertyDescriptors();
if(proDescrtptors!=null&&proDescrtptors.length>0){
for(PropertyDescriptor propDesc:proDescrtptors){
if(propDesc.getName().equals(userName)){
Method methodGetUserName=propDesc.getReadMethod();
Object objUserName= null;
try {
objUserName = methodGetUserName.invoke(userInfo);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
System.out.println("get userName:"+objUserName.toString());
break;
}
}
}
}
} class UserInfo { private long userId;
private String userName;
private int age;
private String emailAddress; public long getUserId() {
return userId;
}
public void setUserId(long userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getEmailAddress() {
return emailAddress;
}
public void setEmailAddress(String emailAddress) {
this.emailAddress = emailAddress;
} }
14.7 jdk动态代理(参考：https://www.cnblogs.com/xiaoluo501395377/p/3383130.html)
jdk的动态代理依赖接口，有局限性；底层是通过反射，执行method；