Java学习笔记9

最新推荐文章于 2024-05-13 21:50:21 发布

欢乐的每一天

最新推荐文章于 2024-05-13 21:50:21 发布

阅读量123

点赞数 1

分类专栏：笔记

本文链接：https://blog.csdn.net/a3026836480/article/details/108171618

版权

笔记专栏收录该内容

37 篇文章 1 订阅

订阅专栏

Class类

对象反射后可以得到的信息：某个类的属性、方法和构造器，某个类到底实现了那些接口，对于每个类而言，JRE都为其保留一个不变的Class类型的对象，一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有个信息
Class本身也是一个类
Class对象只能由系统建立对象
一个加载的类在JVM中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件
每个类的实例都会记得自己是由哪个Class实例生成的
通过Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源，针对任何想动态加载、运行的类，唯有先获得相应的Class对象

获取Class类的实例

若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
Class c1=Person.class;
已知某个类的实例，调用该实例的getClass()方法获取Class对象
Class c1=person.getClass();
已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
Class c1=Class.forName(“demo01,Student”);
内置基本数据类型可以直接使用类名.Type
可以利用ClassLoader

package reflection;

class Person{
    String name;

    public Person(String name) {
        this.name = name;
    }
}
class Student extends Person{

    public Student(String name) {
        super(name);
    }
}
class Teacher extends Person{
    public Teacher(String name) {
        super(name);
    }
}
//Class类的创建方式
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person p1=new Student("学生");
        //1、通过对象获得
        Class c1=p1.getClass();
        System.out.println(c1.hashCode());
        //2、通过forNmae获得
        Class c2=Class.forName("reflection.Student");
        System.out.println(c2.hashCode());
        //3、通过类名.class获得
        Class c3=Student.class;
        System.out.println(c3.hashCode());
        //4、基本内置数据类型都有一个Type属性
        Class c4=Integer.TYPE;
        System.out.println(c4);
        //5、获取父类类型
        Class c5=c1.getSuperclass();
        System.out.println(c5);

    }

}

哪些类型可以有Class对象

class:外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
interface：接口
[]:数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

package reflection;

import java.lang.annotation.ElementType;

//所有类型的Class
public class Test03 {
    public static void main(String[] args) {
        Class c1=Object.class;//类
        Class c2=Comparable.class;//接口
        Class c3=String[].class;//一维数组
        Class c4=String[][].class;//二维数组
        Class c5=Override.class;//注解
        Class c6= ElementType.class;//枚举
        Class c7=Integer.class;//基本数据类型
        Class c8=void.class;
        Class c9=Class.class;
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        //只要元素类型与维度一致，就是同一个Class
        int a[]=new int[10];
        int b[]=new int[50];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对类进行初始化

类的加载(Load)
将类的class文件读入内存，并为之创建一个java.lang.Class对象，此过程由类加载器完成
类的链接(Link)
将类的二进制数据合并到JRE中
类的初始化(Initialize)
JVM负责对类进行初始化

类的加载与ClassLoader的理解

加载:将class文件字节码内容加载到内存中，并将这些静态数据转化成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象
链接:将java类的二进制代码合并到JVM的运行状态之中的过程
验证:确保加载的类信息符合JVM规范，没有安全方面的问题
准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段
解析：虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程
初始化：执行类构造器()方法的过程。类构造器()方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的(类构造器是构造类信息的，不是构造该类对象的构造器)
当初始化一个类的时候，如果发现其父类还没有初始化，则需要先触发其父类的初始化
虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

package reflection;

public class Test04 {
    public static void main(String[] args) {
        A a=new A();
        System.out.println(a);
        /*
        整个过程为
        1、加载到内存，产生一个类对应的Class对象
        2、链接，链接结束后m=0
        3、初始化
        <clinit>(){
                      System.out.println("A类静态代码块初始化");
                      m=300;
                      m=100;
        }
        m=100
        */
    }
}
class A{
    static {
        System.out.println("A类静态代码块初始化");
        m=300;
    }
    static int m=100;
    public A()
    {
        System.out.println("A类无参构造初始化");
    }
}

什么时候发生类初始化

类的主动引用(一定会发生类的初始化)

当虚拟机启动时，先初始化main方法所在的类
new 一个类的对象
调用类的静态成员(除了final常量)和静态方法
使用java.lang.reflect包的方法对类进行反射调用
当初始化一个类，如果其父类没有初始化，则会先初始化其父类
类的被动引用(不会发生类的初始化)
当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：通过子类引用父类的静态变量，不会导致子类初始化
通过数组定义类引用，不会触发此类的初始化
引用常量不会触发类的初始化(常量在链接阶段就存入调用类的常量池中了)

package reflection;

public class Test05 {
    static {
        System.out.println("main方法对应类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1、主动引用
        //Son son=new Son();
        //2、反射产生主动引用
        //Class.forName("reflection.Son");
        //不会产生类的引用的方法
        //System.out.println(Son.a);
        //System.out.println(Son.C);
        Son[] son=new Son[3];

    }
}
class Father{
    static int a=100;
    static {
        System.out.println("父类被加载");
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载");
        b=20;
    }
    static int b=10;
    static final int C=3;
}

类加载器的作用

作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个java.lang.Class对象，作为方法区中类数据的访问入口
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载(缓存)一段时间。JVM垃圾回收机制可以回收这些Class对象
源程序(.java)–>Java编译器–>字节码(.class文件)–>类装载器–>字节码校验器–>解释器–>操作系统平台
JVM规范定义了下面几种类型的类加载器

引导类加载器：用C++编写，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库，该加载器无法直接获取
扩展类加载器：负责将jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库
系统类加载器：负责将java -classpath或-D java.class.path所指的目录下的类与jar包装入工作库，是最常用的加载器
自定义类加载器
这几个加载器自顶向下尝试加载类，自底向上检查类是否已加载

package reflection;

public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemLoader=ClassLoader.getSystemClassLoader();
        System.out.println(systemLoader);
        //获取系统类加载器的父类加载器--扩展类加载器
        ClassLoader parent=systemLoader.getParent();
        System.out.println(parent);
        //获取扩展类加载器的父类加载器--根加载器(引导类加载器)
        ClassLoader parent1=parent.getParent();
        System.out.println(parent1);
        //测试当前类是由哪个加载器加载的
        ClassLoader temp=Class.forName("reflection.Test06").getClassLoader();
        System.out.println(temp);
        //测试JDK内置类由哪个加载器加载
        temp=Class.forName("java.lang.Object").getClassLoader();
        System.out.println(temp);
        //获取系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));

    }
}

双亲委派机制

当某个类加载器需要加载某个.class文件时，它首先把这个任务委托给它的上级类加载器，递归这个操作，如果上级类的加载器没有加载，它才会加载这个类

获取运行时类的完整结构

通过反射获取运行时类的完整结构
Field、Method、Constructor、Superclass、interface、Annotation
实现的全部接口
所继承的父类
全部的构造器
全部的方法
全部的Field
注解

package reflection;

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

public class Test07 {
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
        User user=new User();
        Class c1=user.getClass();
        //获取类名
        System.out.println(c1.getName());//包名+类名
        System.out.println(c1.getSimpleName());//类名
        //获取类属性
        System.out.println("---------");
        Field[] fields=c1.getFields();//只能找到public属性
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("*****");
        fields=c1.getDeclaredFields();//找到全部属性
        for (Field field : fields) {
            System.out.println(field);
        }
        //获取指定属性
        Field name=c1.getDeclaredField("name");
        System.out.println(name);
        System.out.println("-----");
        //获得类的方法
        Method[] method=c1.getMethods();//获得本类及其父类的所有public方法
        for (Method method1 : method) {
            System.out.println("本类及父类public："+method1);
        }
        method=c1.getDeclaredMethods();//获得本类的所有方法
        for (Method method1 : method) {
            System.out.println("本类所有："+method1);
        }
        //获得指定方法
        Method m1=c1.getMethod("getName",null);
        System.out.println(m1);
        //获得所有构造器
        System.out.println("-----");
        Constructor[] constructor=c1.getConstructors();
        for (Constructor constructor1 : constructor) {
            System.out.println(constructor1);
        }
         constructor=c1.getDeclaredConstructors();
        for (Constructor constructor1 : constructor) {
            System.out.println(constructor1);
        }
        //获取指定构造器
        Constructor con1=c1.getDeclaredConstructor(String.class,int.class,int.class);
        System.out.println(con1);


    }
}

Class对象的作用

创建类的对象：调用Class对象的newInstance()方法 1. 创建的类必须有一个无参构造器 2. 类的构造器访问权限足够 - 没有无参构造器，创建类的对象的方法只有在操作中明确的调用类的构造器，并将参数传递进去，才可以实例化操作步骤如下 1、通过Class类的getDeclaredConstructor(Class…parameterType)取得本类指定构造器 2、向构造器形参传递一个对象数组，里面包含了构造器所需的各个参数 3、通过Constructor实例化对象

调用指定的方法

通过反射，调用类中的方法，通过Method类完成
1、通过Class类的getMethod方法(String name,Class…parameterTypes)方法取得一个Method对象，设置此方法操作所需的参数类型
2、使用对象.invoke(Object obj,Object[] args)进行调用，并向方法中传递要设置的对象的参数信息

package reflection;

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

//通过反射动态创建对象
public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c1=Class.forName("reflection.User");
        //创建类的对象,调用类的无参构造器
        User user=(User)c1.newInstance();
        System.out.println(user);
        //通过构造器创建对象
        Constructor constructor=c1.getDeclaredConstructor(String.class,int.class,int.class);
        User user1=(User)constructor.newInstance("test",16,0);
        System.out.println(user1);
        //通过反射调用普通方法
        //通过反射获取一个方法
        Method method=c1.getDeclaredMethod("setName", String.class);
        //invoke激活的意思
        //对象，方法的值
        method.invoke(user1,"test2");
        System.out.println(user1.getName());
        //通过反射操作属性
        System.out.println("-------");
        Field name=c1.getDeclaredField("name");
        //不能直接操作私有属性，需要先关闭程序的安全性检查
        //属性或方法的setAccessible(true);
        name.setAccessible(true);
        name.set(user1,"test3");
        System.out.println(user1.getName());
    }

}

setAccessible

Method和Field、Constructor对象都有setAccessible方法
setAccessible的作用是启动和禁用访问安全检查的开关
参数值为true则指示反射的对象在使用时应关闭Java语言访问检查
- 提高反射的效率。如果代码中必须用反射，如该语句需要频繁调用，则需设为true
- 使原本无法访问的私有成员也能访问
参数值为false则指示反射的对象应该实施java语言访问检查

package reflection;

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

//性能分析
public class Test09 {
    //普通方式调用
    public static void test1()
    {
        User user=new User();
        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            user.getName();
        }
        long endTime=System.currentTimeMillis();
        System.out.println("普通方式调用花费"+(endTime-startTime)+"ms");
    }
    //反射调用
    public static void test2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user=new User();
        Class c1=user.getClass();
        Method method=c1.getDeclaredMethod("getName",null);
        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            method.invoke(user,null);
        }
        long endTime=System.currentTimeMillis();
        System.out.println("普通方式调用花费"+(endTime-startTime)+"ms");
    }
    //反射调用，关闭检测
    public static void test3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user=new User();
        Class c1=user.getClass();
        Method method=c1.getDeclaredMethod("getName",null);
        method.setAccessible(true);
        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            method.invoke(user,null);
        }
        long endTime=System.currentTimeMillis();
        System.out.println("反射调用，关闭检测花费"+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) {
        try {
            test1();
            test2();
            test3();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}