java-反射初学（2）

package .com;

import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Random;

/*
 * 本次学习RTTI: 即在运行时，识别一个对象的类型；
 * 第一部分：
 * Class类 ：就像不同的人又Person 类 那么不同的类也有其类型Class类；
 * 每个类都有一个Class对象，换言之，每当编写并且编译一个新类，就会产生一个Class对象(被保存在一个同名的.class文件中)
 * 无论何时，只要我们想在运行时使用类型的信息或者知道那个对象的实际类型，就必须首先获得对这个Class对象的引用，有三
 * 种方式可以获得某个对象所对应的Class对象的引用：
 *  1.运用Class类中的静态方法：Class c = Class.forName("类的全限定名称")；
 *      Class personClass = Class.forName("com.qian.Person");我们就拿到了指向Person这个字节码的引用，
 *  2.运用Object类中的静态方法：Class c = new Person().getClass();
 *  
 *  3.运用类字面常量方式：类名.class (Person.class);其不仅可以应有于普通的类，也可以应用于接口，数组，以及基本数据类型；
 *      对于基本数据类型的包装器类，还有一个标准的TYPE字段，TYPE字段也是一个引用，指向对应的基本数据类型的Class对象。
 *      int.class 等价于  Integer.TYPE;其次使用".class"来创建Class对象的引用时，不会自动地初始化该Class对象，区分与forName();
 * 
 * 加载----->链接------>初始化
 * 分析下面 Initate One-Three过程 可见 初始化有效的实现了尽可能的 惰性 
 *  仅使用 .class语法来获得对类的引用不会引发初始化；但是为了产生Class引用 Class.forName()立即就进行了初始化；
 *  对于编译期常量的处理：
 *      对于编译期常量JVM知道其具体是多少，所有它就不会在初始化类；例如下面的:
 *      System.out.println("InitateOne.staticFinalOne is:  "+InitateOne.staticFinalOne);只会输出47不会初始化静态代码块；
 *  对于只是将一个域设置为 static 和final的还不足以确保知道这个数确切值，此时就会对类进行初始化；例如下面：
 *      System.out.println("InitateOne.staticFinalTwo is:  "+InitateOne.staticFinalTwo);
 *  对于一个static域不是final的，那么在访问它是，总是要求在读取之前，要先进性链接(为这个域分配存储空间)和初试化(初始化该存储
 *      空间)例如：System.out.println("InitateTwo.staticNonFinal is:  "+InitateTwo.staticNonFinal);
 *  
 *  
 *  第二部分：
 *  Class的泛化；
 *   Class intClass = int.class;
 *         intClass = double.class;这样也是可以的，因为普通类的引用可以被指向任何其他的Class对象
 *   通配符 ： ？ 上面式子等价于 Class<?> intClass =int.class; intClass = double.class;
 *   范围界定：Class<? extends SuperClass>  和 Class<? super SonClass>
 *   
 *  
 *  
 *  
 *  
 * */
class InitateOne{
    final static int staticFinalOne = 47;
    static final int staticFinalTwo = ReflectTwo.rand.nextInt(500);

    static{
        System.out.println("Load InitateOne through static");   

    }
    public InitateOne(){
        System.out.println("Load InitateOne through default construct");
    }
}
class InitateTwo{
    static int staticNonFinal = 147;

    static{
        System.out.println("Load InitateTwo through static");   

    }
    public InitateTwo(){
        System.out.println("Load InitateTwo through default construct");
    }
}
class InitateThree{
    static int staticNonFinal = 74;

    static{
        System.out.println("Load InitateThree through static"); 

    }
    public InitateThree(){
        System.out.println("Load InitateThree through default construct");
    }
}
//练习泛型；
class SuperClass{
    private String name;
    SuperClass(){}
    SuperClass(String name){
        this.name = name;
    }
    public void eat(){
        System.out.println(name+"  super.eat");
    }
}
class SonClass extends SuperClass{
    private String sonName;
    SonClass(){}
    public SonClass(String sonName){
        super(sonName);
    }
    public void show(){
        System.out.println(sonName+" is show()");
    }
}
class SonClass2{
    private String sonName;
    SonClass2(){}
    public SonClass2(String sonName){
        this.sonName = sonName;
    }
    public void show2(){
        System.out.println(sonName+" is show2()");
    }
}
public class ReflectTwo {
    public static Random rand = new Random(47);

    public static void main(String[] args) throws Exception {
        //1.public T cast(Object obj)//将obj对象强制转换成Class对象所表示的接口或者类;(非继承和实现就报错)
//      SuperClass sup = SuperClass.class.cast(new SonClass());
        Class sc = Class.forName("GeneIterAdaptReflect.com.SonClass");
        Method[]  sms = sc.getMethods();
        for(Method m:sms){

            Type[] t =m.getTypeParameters();
            for(Type ty:t)
                System.out.println(m.getReturnType()+"  "+m.getName()+"("+ty.getTypeName()+")");
        }

    }
    public static void initateMethod(){
        Class InitateOneClass = InitateOne.class;
        System.out.println("after create InitateOne reference throught .class");
        System.out.println("InitateOne.staticFinalOne is:  "+InitateOne.staticFinalOne);
        System.out.println("InitateOne.staticFinalTwo is:  "+InitateOne.staticFinalTwo);
        System.out.println();
        /*打印结果：
         * after create InitateOne reference throught .class
         *InitateOne.staticFinalOne is:  47
         *Load InitateOne through static
         *InitateOne.staticFinalTwo is:  258
         * */

        System.out.println("InitateTwo.staticNonFinal is:  "+InitateTwo.staticNonFinal);
        /*打印结果：
         * Load InitateTwo through static
         *InitateTwo.staticNonFinal is:  147
         */
        System.out.println();

        Class InitateThreeClass = Class.forName("GeneIterAdaptReflect.com.InitateThree");
        /*打印结果：
         * Load InitateThree through static
         * */
        System.out.println("after crete InitateThree.class reference through forNAme()");
        System.out.println("InitateThree.staticNonFinal is:  "+InitateThree.staticNonFinal);
        /*
         * after crete InitateThree.class reference through forNAme()
         * InitateThree.staticNonFinal is:  74
         * */
    }
}