class，编程的基础

      我们用了这么久的class，很少有人认真的去看过我们class源码，今天我们来看看Class能带给我们什么？

     一 如何获取class实例：

    方法一：通过类本身获取class实例：

Class clazz1 = Person.class;
System.out.println(clazz1.getName());

   方法二、通过运行时类来获取class实例：

 Person p = new Person();
        Class clazz3=p.getClass();
        System.out.println(clazz3.getName());

   方法三、通过静态方法获取class实例：

 Class clazz4=Class.forName("cn.dandan.test.Person");
 System.out.println(clazz4.getName());

   方法四、通过类加载器获取class实例：

 ClassLoader classLoader=this.getClass().getClassLoader();
Class clazz5= classLoader.loadClass("java.lang.String");
System.out.println(clazz5.getName());  

  二、获取类的完整结构

1.获取类的属性：

@Test
    public void test1(){
    
        Class clazz1= Person.class;
        //只能获得运行类中与父类中生命为public 的属性
        Field[] fields=clazz1.getFields();
        
        for(int i=0;i<fields.length;i++){
            System.out.println(fields[i]);
        }
        
        //可获得本类中所有生命的属性
        Field[] fields1=clazz1.getDeclaredFields();
        
        for(int i=0;i<fields1.length;i++){
            System.out.println(fields1[i]);
        }
    }

  2.获取属性的名称类型及权限

//获取属性中各个部分的内容
    @Test
    public void test2(){
        Class clazz1= Person.class;
        //只能获得运行类中与父类中生命为public 的属性
        Field[] fields=clazz1.getDeclaredFields();
        
        for(Field f : fields){
            //获取每个属性的权限修饰符
            int i = f.getModifiers();
            String str1 = Modifier.toString(i);
            System.out.println(str1+" "+f.getName());
            //获取每个属性的变量类型
            Class type =f.getType();
            System.out.println(type);
            //获取每个属性的名称
            /*System.out.println(f.getName());*/
            System.out.println();
            
        }
    }  

  3.获取注释，修饰符，返回值类型，方法名，形参列表，异常等信息

@Test
    public void test3(){
        
        Class clazz= Person.class;
        Method[] m2= clazz.getDeclaredMethods();
        for(Method m:m2){
            Annotation[] ann= m.getAnnotations();
            for(Annotation a : ann){
                //打印注解的方法
                System.out.println(a);
            }
            //获得返回值的类型
            String str= Modifier.toString(m.getModifiers());
            
            System.out.println(str+" ");
            
            //形参列表
            Class[] type=m.getParameterTypes();
            for(int i=0;i<type.length;i++){
                System.out.println(type[i].getName()+" args-"+i);
            }
            
            Class[] exception= m.getExceptionTypes();
            for(int i=0;i<exception.length;i++){
                System.out.println(exception[i].getName());
            }
            
            /*System.out.println(m);*/
        }
    } 

  4.获取构造器

 @SuppressWarnings("rawtypes")
    @Test
    public void test4() throws ClassNotFoundException{
        String str= "cn.dandan.test.Person";
        Class clazz= Class.forName(str);
        //1.获取构造器
        Constructor[] constructor= clazz.getDeclaredConstructors();
        //
        
        for(int i=0;i<constructor.length;i++){
            System.out.println(constructor[i]);
        }
        //2.获取父类
        Class superClass= clazz.getSuperclass();
        System.out.println(superClass);
        
        //3.获取带泛型的父类
        Type type=clazz.getGenericSuperclass();
        System.out.println(type);
    }

   5.获取带泛型的父类：

 @Test
    public void test5() throws ClassNotFoundException{
        String str= "cn.dandan.test.Person";
        Class clazz= Class.forName(str);
        Class superClass= clazz.getSuperclass();
        Type type=clazz.getGenericSuperclass();
        ParameterizedType paraType=(ParameterizedType)type;
        Type[] ars=paraType.getActualTypeArguments();
        System.out.println(((Class)ars[0]).getName());
    }  
 

  6.获取父类的泛型：

 @Test
    public void test5() throws ClassNotFoundException{
        String str= "cn.dandan.test.Person";
        Class clazz= Class.forName(str);
        Class superClass= clazz.getSuperclass();
        Type type=clazz.getGenericSuperclass();
        ParameterizedType paraType=(ParameterizedType)type;
        Type[] ars=paraType.getActualTypeArguments();
        System.out.println(((Class)ars[0]).getName());
    }

  7.获取实现的接口

   @Test
        public void test6() throws ClassNotFoundException {
            String str= "cn.dandan.test.Person";
            Class clazz= Class.forName(str);
            //获取所在的包
            Package pack = clazz.getPackage();
            System.out.println(pack);
            //获取接口
            Class[] interfaces=clazz.getInterfaces();
            for(int i=0;i<interfaces.length;i++){
                System.out.println(interfaces[i]);
            }
        }  

  三  类加载机制

       我们上面讲了类能给我带来什么，下面我们来说说java的类加载机制。类加载机制就是把类装入内存中。那么，到底是怎么实现的，我们来看下面这张图：

   1.  加载过程：

      java的源程序通过javac编译成.class文件，之后我们使用JVM类加载机制加载.class文件（ps：只有使用的时候才会加载），将此.class文件加载到内存之后就是一个运行时类，并存在缓存区，一个运行时类只加载一次。

   2.JVM加载过程中产生三个层次的类加载器，分别为：系统类加载器，扩展类加载器，引导类加载器，具体我们看图：

     现在存在这样一种情况，源码中可以获取到系统类加载器，扩展类加载器，但是不能获取到引导类加载器，因为引导类加载器是JVM的核心，所以我们无法获取：

@Test
    public void test5(){
        
        ClassLoader classLoader1=ClassLoader.getSystemClassLoader();
        //获取系统类
        System.out.println(classLoader1);
        //获取扩展类
        System.out.println(classLoader1.getParent());
        //不能获取引导类
        System.out.println(classLoader1.getParent().getParent());
    } 

执行结果：

四 总结：

    有了类，才有了我们面向对象的概念，类给我们提供了很多我们想像不到的东西，好好挖掘吧！