day23:Class,ClassLoader,junit,枚举

Class
    java.lang.Class
        描述正在运行的字节码文件
    如何获取一个类的字节码文件对象
        1.Object类
               Class getClass()
        2.任意类型 包括基本类型 都有一个隐藏的静态属性 class
                类型.class
        3.Class类的静态方法
               public static Class forName(String className)
            //获取类名 带包名
        String name = c.getName();
            //获取类名 不带包名
        String simpleName = c.getSimpleName();
            //获取父类
        Class superclass = c.getSuperclass();
            //获取实现的所有接口
        Class[] interfaces = c.getInterfaces();
        for (Class anInterface : interfaces) {
            System.out.println(anInterface);
        }
    constructor
        反射获取Person类空参构造方法 并运行
            1.获取字节码文件对象
                Class c = Class.forName("com.doit.beans.Person");
            2.获取空参构造方法
          Class类
              方法
                  Constructor<?>[] getConstructors() 获取所有公共权限的构造方法
                   Constructor  getConstructor() 获取空参构造方法 公共权限
                //获取所有公共权限的构造方法
       Constructor[] cons = c.getConstructors();
       cons.for(遍历)
                //获取指定空参构造方法
        Constructor con = c.getConstructor();
            3.运行空参构造方法
        Constructor类
             Object  newInstance()  运行空参构造方法
        反射 获取Person带参构造方法 并运行
            1.获取字节码文件对象
                Class c = Class.forName("com.doit.beans.Person");
            2.获取带参构造方法
          Class类
               Constructor<T> getConstructor(Class<?>... parameterTypes) 获取指定的构造方法 公共权限
                                         获取指定参数类型的构造方法  Class<?>... parameterTypes 比如 String -->String.class
                //获取指定构造方法
        Constructor con = c.getConstructor(String.class, int.class);
            3.运行构造方法
        Constructor
                T newInstance(Object... initargs)
                        Object... initargs:运行构造方法 需要给定的实际参数
                //运行带参构造方法
        Object obj = con.newInstance("柳岩", 38);
                等于
        Object obj = new Person("柳岩", 38)
        获取Person类私有的构造方法 并运行(暴力反射)
            1.获取字节码文件对象
                Class c = Class.forName("com.doit.beans.Person");
            2.获取指定的构造方法
            Class类
                  Constructor<?>[] getDeclaredConstructors() 获取所有构造方法 包括私有
                   Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取指定构造方法 可以获取私有
                //获取指定构造方法 可以获取私有
        Constructor con = c.getDeclaredConstructor(String.class);
            3.取消访问权限检查
            AccessibleObject
                  方法
                         void setAccessible(boolean flag)  flag值为true 反射时 取消权限检查
            Constructor Method  Fiedl都是其子类 可以直接使用
                //取消访问权限检查
        con.setAccessible(true);
            4.运行构造方法
                //运行构造方法
        Object obj = con.newInstance("唐嫣");
        反射创建对象的快捷方式
            前提
         类必须具有空参构造
         并且空参构造被public修饰
            1.获取字节码文件对象
2.直接反射创建对象
             Class类
             Object newInstance()
                Class c = Class.forName("com.doit.beans.Person");
                Object obj = c.newInstance();

ClassLoader
    类的加载器
        根类加载器 BootstrapClassLoader  c++编写
                主要负责加载 java核心类
         扩展类加载器  ExtClassLoader
                主要负责加载 扩展包下的类
        应用类加载器  AppClassLoader
                主要负责加载 我们自己写的类 和第三方jar包
    获取一个类的类加载器
        Class类
             ClassLoader getClassLoader() 获取类加载器
             public static void boot(){
        //如果一个类的类加载器 获取到的是null 说明这个类被根类加载器 加载
        ClassLoader classLoader = String.class.getClassLoader();
        System.out.println(classLoader);
        ExtClassLoader 是AppClassLoader的父加载器
            public static void ext(){
        ClassLoader ext = DNSNameService.class.getClassLoader();
        System.out.println(ext);
        BootstrapClassLoader 是 ExtClassLoader 父加载器
            public static  void app(){
        ClassLoader app = Teat(所在类名).class.getClassLoader();
        System.out.println(app);
    双亲委托机制
        如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去加载。
        好处
            保证一个类只加载一次
沙箱安全机制 避免 你自己一定义一个类 将java的类替换

junit
    import org.junit.Test;
    单元测试
         属于白盒测试 可以理解为 取代main方法
        public void test(){
      //  System.out.println(1/0);
        System.out.println("单元测试");

        int he = sum(10, 20);
        System.out.println(he);
        @org.junit.Test
public int sum(int a ,int b){
        return  a + b;
    }

枚举
    public enum Color {RED,BLUE,BLACK("aaa");
    private String name;

    private Color(){}

    private Color(String name){
        this.name = name;
    }
}
        Color[] arr = new Color[3];

arr[0] = Color.RED;