当调用Java命令运行某个程序时,该命令将会启动一个Java虚拟机进程,不管该Java程序有多么复杂,该程序启动了多少个线程,它们都处于Java虚拟机进程里。即同一个JVM的所有线程、所有变量都处于同一个进程里,它们都使用该JVM进程的内存区,当系统出现以下几种情况时,JVM进程将会被终止:
1、程序运行到最后正常结束
2、程序运行到使用System.exit()或Runtime.getRuntime().exit()代码结束程序
3、程序进行过程中遇到未捕获的异常或错误而结束
4、程序所在平台强制结束了JVM进程
程序运行结束时,JVM进程结束,该进程在内存中的状态将会丢失。每次重新运行JVM时,都会重新初始化类——前一次运行JVM结束后,它对类做的修改将全部丢失,两次运行java程序处于两个不同的JVM进程中,两个JVM之间并不会共享数据。
类加载器的机制:
当程序主动使用某个类时,如果该类未被加载到内存中,则系统会通过加载、连接、初始化三个步骤对类进行初始化。三个步骤也称为类加载或类初始化。
类加载指的是将类的class文件读入内存中,并为之创建一个java.lang.Class对象。
类的加载由类加载器完成,类加载器通常由JVM提供,JVM提供的也称为系统类加载器,开发者也可以通过继承ClassLoader基类来创建自己的类加载器。
使用不同的类加载器,可以从不同来源加载类的二进制数据,如下几种来源:
1、从本地文件系统加载class文件
2、从JAR包加载class文件
3、通过网络加载class文件
4、把一个Java源文件动态编译、并执行加载。
类加载器通常无需等到“首次使用”该类时才加载该类,Java虚拟机规范允许系统预先加载某些类。
类的连接:
类被加载之后,系统会为之生成一个对应的Class对象,接着将会进入连接阶段,连接阶段负责把类的二进制数据合并到JRE中,连接分为三阶段:
1、验证:验证阶段用于检验被加载的类是否有正确的内部结构,并和其他类协调一致。
2、准备:类准备阶段则负责为类的类变量分配内存,并设置默认初始值
3、解析:将类的二进制数据的符号引用替换成直接引用。
类的初始化:
初始化阶段,虚拟机负责对类进行初始化,主要就是对类变量进行初始化,初始化步骤:
1、假如这个类还没有被加载黑连接,则程序先加载并连接该类
2、假如该类的直接父类没有被初始化,则先初始化直接父类
3、假如该类中有初始化语句,则系统一次执行这些初始化语句。
HVM最先初始化的总是java.lang.Object类,当程序主动使用任何一个类时,系统会保证该类以及所有父类都会被初始化。
类初始化的时机:
Java程序首次通过以下6中方式使用类或接口时,系统会初始化该类或接口:
1、创建类的实例。包括new 创建、反射创建和反序列化的方式创建。
2、调用某个类的类方法(静态方法)
3、访问某个类或接口的类变量,或为该类变量赋值
4、使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。
5、初始化某个类的子类。
6、直接使用java.exe命令来运行某个主类。
对于一个final修饰的类变量,如果该类变量的值在编译时就可以确定下来,name这个类变量相当于“宏变量”,Java编译器会在编译时直接把这个类变量出现的地方替换成它的值,因此即使程序使用该静态类变量也不会导致该类的初始化。(此时相当于使用常量)
当使用ClassLoader类的对象loadClass()方法来加载某个类时,该方法只是加载该类,并不会执行该类的初始化,使用Class的静态方法forName()才会导致强制初始化该类。
类加载器负责将.class文件加载到内存中,并为之生成对应的java.lang.Class对象。一个类被载入JVM中,同一个类就不会被再次载入了。
对于Java程序而言,如何识别同一个类:只要该类的全限定类名相同即可(类名和包名都要相同)。
对于类加载器而言,如何识别同一个类:类名相同、包名相同、类加载器也相同。
当JVM启动时,会形成由三个类加载器组成的初始类加载器层次结构:
Bootstrap ClassLoader:根(引导/原始)类加载器:负责加载Java的核心类
Extension ClassLoader:扩展类架子阿奇
System ClassLoader:系统类加载器
类加载机制:
1、全盘负责,当一个类加载器来加载某个Class时,该Class所依赖或引用的其他类都将由该类加载器负责加载。除非显式使用另外一个类加载器来加载。
2、父类委托:JVM首先尝试使用父类加载器来加载某个类,只有当父类加载器无法加载某个类时,才会去使用其子类加载器。
3、缓存机制:类加载会自动保证所有被加载过的类都会被缓存,当程序需要使用某个Class时,类加载器先从缓存区中搜索该Class,只有当缓存区中不存在Class对象时,系统才会读取该类对应的二进制数据,并将其转换为Class对象,存入缓存区中。
Java的4种类加载器:
1、根类加载器(Bootstrap)
2、扩展类加载器(平台类加载器)
3、系统类加载器
4、用户定义的类加载器(通过继承ClassLoader实现)
类加载器之间的父子关系并不是继承上的负责关系,这里的父子关系是类加载器实例之间的关系。
访问JVM的类加载:ClassLoader systemLoader = ClassLoader.getSystemClassLoader()返回系统 类加载器
获取系统类加载器的加载路径:systemLoader.getResources(“”) 返回Enumeration对象
加载路径通常由CLASSPATH环境变量指定。若不指定,以当前路径作为加载路径
获取系统类加载器的父类加载器,得到扩展类加载器:systemLoader.getParent()
若获取扩展类加载器对象的getParent()获取它的父类加载器(根类加载器),将会得到null,这是因为根类加载器并没有继承ClassLoader抽象类,根类加载器并不是Java实现的,所以扩展类加载器的getParent()返回null
系统类加载器是AppClassLoader类的实例,扩展类加载器是PlatformClassLoader类的实例,
实际上,这两个类都是URLClassLoader类的子类。
面试题:能不能写一个类替换Java自身的:java.lang.String类
Java提供了ClassLoader对象来代表加载器
Java的根加载器并不是使用java语言实现的,因此程序无法访问根类加载器。
classLoader提供了如下方法来访问类加载器:
getSystemClassLoader():获取系统类加载器
getPlatformClassLoader():获取平台类加载器(扩展类加载器)
实例方法:对象.getParent()获取上一级父类加载器。
何时实现自定义类加载器:
程序只要继承ClassLoader基类,就可以实现自定义的类加载器。一般来说,并不需要实现自定义的的类加载器。
继承ClassLoader基类实现类加载器时,通常要实现如下两个方法:
Class<?> LoadClass(String name,boolean resolve):该方法是ClassLoad的关键方法,ClassLoader正是调用该方法来得到对应的Class对象。
findClass():根据名称来找到类
通常重写findClass()方法,而不是重写loadClass()方法,loadClass()执行步骤如下:
1、用findLoadedClass(String)检查是否已经加载该类,如果已经加载则直接返回。
2、在父类加载器上调用loadClass()方法,如果父类加载器为null,则使用根类加载器来加载
3、调用findClass(String)方法查找类
如上可知:重写findClass(String)方法可以避免覆盖默认类加载器的父类委托、缓冲机制两种策略。
通常而言,主要是在程序需要对类文件做一些混淆、加密时,此时就可能需要提供自己的类加载器。
URLClassLoader:该类是系统类加载器和扩展类加载器的父类,它是java提供的一个基于URL的类加载器,因此它可以直接加载网络上(任意指定路径)的二进制文件来生成Class对象。
URLClassLoader就是java本身提供的一个用户自定义的类加载器,因此它可以用于加载指定路径(文件系统、网络)的JAR包或二进制文件来生成class对象。有如下构造器:
URLClassLoader(URL[] urls):使用默认的父类加载器创建一个ClassLoader对象,该对象将从url所指定的系列路径来查询并加载类
URLClassLoader(URL[] urls,ClassLoader parent):使用指定父类加载器创建一个ClassLoader对象,该对象将从url所指定的系列路径来查询并加载类
由构造器可知,参数为URL[]数组,该数组元素为url,可以加载网路各个路径的类。
一旦得到了URLClassLoader对象后,就可以调用loadClass()方法加载指定类。
理解反射:
反射作用:动态使用java(创建对象、调用方法)
1、动态创建对象,2、动态调用方法
如果代码是具有一定通用性质的、属于基础框架性质的。由于是框架,因此项目后期可能出现的类都是动态的——此处就必须使用动态创建对象、动态调用方法——这就是反射。
某些对象在运行时会出现两种类型:编译时类型和运行时类型,如:Person p = new Student()
编译时类型为Person,运行时为Student,此时若希望调用该对象的运行时方法(即Student独有的方法),此时就可以使用反射。解决办法:
1、若编译时和运行时完全知道该类具体类型的真实信息,可以先使用instanceof运算符判 断,再强制转换成运行时类型的变量即可
2、编译时无法预知该对象和类可能属于哪些类,程序只依靠运行时信息来发现该对象和类 的真实信息,此时必须使用反射。
Class:代表一个类,Class又是一个对象。
Class代表所有类的类,每个Class实例代表一个具体的类。
类在加载后,系统就会为该类生成一个对应的Class对象,通过该Class对象就可以访问到JVM中的这个类。可以以如下三种方式获得Class对象:
1、使用Class类的静态方法forName(String clazzName)。clazzName参数的值是全限定类名
2、调用某个类的class属性来获取该类对应的Class对象,如:Person.class
3、调用对象的getClass()方法,该方法是Object的方法,该方法返回该对象所属类对应的 Class对象
对比1和2两种方式比较,方式2有两大优势:
优势一:代码更安全,程序在编译阶段就可以检查需要访问的Class对象是否存在
优势二:程序性能更好,因为这种方式无需调用方法。
因此,大部分时候使用第二种方式来获取指定类的Class对象。若只能得到一个字符串,则只能使用方式1,方式1会抛出一个ClassNotFoundException异常。
获取到类对应的Class对象之后,就可以调用Class对象的方法获得该对象和该类的真实信息。
从Class对象获取信息:
类的五大成员:成员变量、方法、构造器、初始化块、内部类
类上注解,这些东西都可以通过反射来获取。
在Class类提供的方法中,带Declared字样的就是获取所有的指定成员,不带Declared字样的只是获取public的指定成员。P858—860
获取构造器:返回值都是Constructor对象(即构造器对象)或Constructor<?>[]
getConstructor(Class<?>…parameterTypes):返回此Class对应类的、带指定形参列表的public 构造器,papameterTypes指定形参列表参数类型。如String类型 则传入时写:String.class
getConstructors():返回此Class对应类的所有public构造器
getDeclaredConstructor(Class<?>…parameterTypes):返回此Class对应类的、带指定形参列表 的构造器访问权限无关
getDeclaredConstructors():返回此Class对应类的所有构造器,与访问权限无关
获取方法:返回值都是Method(即方法对象)或Method[]
getMethod(String name,Class<?>…parameterTypes):返回此Class对象对应类的、带指定形参 列表的public方法,name指定方法名,papameterTypes指定形参列表参数类型。
getMethods():返回此Class对象对应类的所有public方法
getDeclaredMethod(String name,Class<?>…parameterTypes):返回此Class对象对应类的、带 指定形参列表的方法,与方法的访问权限无关。
getDeclaredMethods():返回此Class对象对应类的所有方法,与方法的访问权限无关。
获取成员变量:返回值都是Field(即变量对象)或Field[]
getField(String name):返回此Class对象对应类的、指定名称的public成员变量
getFields():返回此Class对象对应类的所有public成员变量
getDeclaredField(String name):返回此Class对象对应类的、指定名称的成员变量,与访问权 限无关。
getDeclaredFields():返回此Class对象对应类的所有成员变量,与访问权限无关
获取注解:
getAnnotation(Class annotationClass):尝试获取该Class对象对应类上存在的、指定类型 的Annotation,如果该类型的注解不存在,返回null
getDeclaredAnnotation(Class annotationClass):尝试获取直接修饰该Class对象对应类的、 指定类型的Annotation,如果该类型的注解不存在,返回null
getAnnotations(Class annotationClass):返回修饰该Class对象对应类上存在所有Annotation
getDeclaredAnnotation(Class annotationClass):返回直接修饰该Class对象对应类的 Annotation
获取内部类:
getClasses():获取所有public内部类
getDeclaredClasses():返回该Class对象对用类里包含的全部内部类
目前操作的Class本身就是其他类的内部类时,用以下方法获取外部类:
getDeclaringClass():获取该类本身所在的外部类
获取继承的父类:
getSuperclass():返回该Class对象对应类所继承的父类
获取该类所有实现的接口:
getInterfaces():返回该Class对象所实现的全部接口
获取该类的修饰符
Int getModifiers():返回该类或接口的所有修饰符,返回的是一个整数,需要使用Modifier 工具类的方法来解码才可以获取真实的修饰符
Package getPackage():获取此类的包
String getName():返回此Class对象所表示的类的名称
getSimpleName():返回此Class对象所表示的类的简称
Class对象还可以通过以下方法判断该类是否为接口、枚举、注解类型:
isAnnotation():该Class对象是否表示一个注解类型
isAnnotationPresent(Class<? extends Annotation> annotationClass):判断此Class对象是否使用 了Annotation修饰
isAnonymousClass():是否是一个匿名类
isArray():是否是一个数组类
isEnum():shifou shi yige meiju
isInterface():是否是一个接口
isInstance(Object obj):判断obj是否是此Class对象的实例,和instance相似
【注意】反射获取的是运行时Class对象,所以无法获取到只能在源码上保留的注解。
Executable抽象基类,代表可执行的类成员,该类派生的子类有Constructor和Method
,Executable提供了大量方法来获取修饰方法或构造器的注解信息。
isVarArgs():判断该方法或构造器是否包含数量可变的形参
getModifiers():获取该方法或构造器的修饰符
【关键点:】编译java源文件的时候需要增加-parameters选项,这样java编译器才会保留方法的形参名和形参上的 修饰符。
getParameterCount():获取该构造器或方法的形参个数
Parameter[] getParameters():获取该构造器或方法的所有形参。得到Parameter参数后,Parameter:代表一个参数,可用于获取参数相关的信息,Parameter也提供了大量方法来获取参数的泛型等参数信息:
getModifiers():获取修饰该形参的修饰符
String getName():获取形参名
Type getParameterizedType():获取带泛型的形参类型
Class<?> getType():获取形参类型
Boolean isNamePresent():该方法返回该类的class文件中是否包含了方法的形参名信息。
Boolean isVarArgs():该方法用于判断该参数是否为个数可变的形参。否则得不到形参名
使用这些方法时,需要在编译时加-parameters选项。
使用反射生成并操作对象:
创建对象:使用Class对象获取指定的Constructor对象,再调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例。
在很多Java EE框架中,需要根据配置文件信息来创建Java对象,从配置文件中读取的只是某个类的字符串类名,程序需要根据该字符串来创建对应的实例就必须使用反射。
【重要发现】:构造器的真正的方法名:
动态创建对象:
通过默认的构造器
//根据字符创来创建对象(该对象可以是动态改变的)
Class<?> clazz = Class.forName(“java.util.Date”);
Constructor c = clazz.getConstructor();//获取public 无参数的构造器
//newInstance用于调用指定构造器来创建对象,可传入可变个数的参数。
Object obj = c.newInstance();
通过Class动态创建对象:实际是通过调用构造器的newInstance(参数)方法来创建对象。
获取指定构造器创建:调用时需要传入对应的参数。
Class<?> clazz = Class.forName(“java.util.Date”);
Constructor c = clazz.getConstructor(Long.class);//获取指定参数类型构造器
Object obj = C.newInstance(220033);//传入对应的参数创建对象。
动态地调用方法:
通过调用Method的invoke(调用者,个数可变的参数)方法来调用。
Object invoke(Object obj,Object…args):invoke第一个参数obj是方法的调用者,因此,如果方法是static方法,invoke的第一个参数可使用null,后面是该方法的实参
如果需要调用某个对象的private方法,则先调用Mthod如下方法:
setAccessible(boolean flag):将Method对象的accessible设置为指定的布尔值。值为true指示该Method在使用时应该取消Java语言的访问权限检查,值为false,指示该Method在使用时要实施Java语言的访问权限检查,。
以上方法并不属于Method本身,而是属于它的父类AccessibleObject,因此Method、Constructor、Field都可以调用该方法取消访问权限检查。
动态访问Field
getField()获取到Field变量对象后,就可以调用Fiel=对象的如方法动态获取和设置Field的值:
getXxx(Object obj):返回obj对象的成员变量field的值,此处Xxx对应8种基本类型,如果 该成员变量的类型是引用类型,则取消get后面的Xxx,参数obj为后去的对象
setXxx(target,val):将obj对象的该成员变量设置成val值,参数target为获取的对象,val为 要设置的值
Field的get或者set方法的第一个参数是调用者,因此如果该Field是static,get或者set时第一个参数可以使用null.
【总结论】:不管是构造器、还是方法、Field,即使它是private修饰的。在反射时,只要调用setAccessible(true),它们就可以不去管访问权限的修饰符的限制。
动态生成数组:
在java.lang.reflect包下还提供了一个Array类,Array类对象可以代表所有的数组。程序可以通过使用Array来动态地创建数组。
Array类的方法都是static,是一个工具类。如下:
static Object newInstance(Class<?> componentType,int…length):创建一个具有指定的元素类 型、指定维度的新数组,length是一个可变参数,填在最后的是元素个数,如要创建一 个String类型的三维数组 Array.newInstance(String.class,3,4,10)表示一个3维的,1维10 个元素,二维4个,三维3个。
Static xxx getXxx(Object array,int index):返回数组中第index个元素,其中Xxx是各种基本数 据类型,如果数组元素是引用类型,则方法变为get(Object array,int index)。
Static void setXxx((Object array,int index,xxx val):将array数组中第index个元素的值设为val,其中xxx是各种基本数据类型,如果是引用类型,可以去掉Xxx
Java 11新增的嵌套访问权限
【java的private成员的特殊点】
1、Java的外部类可以直接访问内部类的private成员
2、同一个类中的多个内部类之间,它们可以互相访问对方的private成员。
但在java 11之前
1、java的外部类通过反射反而不能访问内部类的private成员,除非设置setAccessible(true);
2、同一个类的多个内部类之间,通过反射也不能互相访问对方的private成员,除非设置setAccessible(tru e);
Java11之后,java把它们进行了统一,
1、Java的外部类可以直接、也可以通过反射访问内部类的private成员
2、同一个类中的多个内部类之间,它们可以直接互相访问、也可以通过反射访问对方的private成员。
Java 11之所以能进行这样的改进,关键就在于增加了一个嵌套访问权限:
Java 11为Class增加了如下方法:
GetNestHost():获取该类所在的属主类——外部类的属主是它本身
IsNestmateOf():判断一个类是否为另一个类的嵌套同伴——同一类的多个内部类属于嵌套同伴,外部类和它所有的内部类之间也属于嵌套同伴。
Class[] getNestMenbers():获取该类所有的内部类——其中也包括它本身。
Java.lang.reflect包下提供了Proxy类和InvocationHandler接口,使用这个类和接口可以生成JDK动态代理类或动态代理对象。Proxy类提供了用于创建动态代理类和动态代理对象的静态方法,是所有动态代理类的父类,如果需要在程序中为一个或多个接口动态生成实现类可以使用Proxy来创建动态代理类,如果需要为一个或多个接口动态地创建实例,也可以使用Proxy来创建动态代理实例。
JDK动态代理:可以在运行时动态地生成一个类、或者动态生成一个类的实例,被生成的类,看不到class文件,或者说它在内存中动态生成了class文件。
JDK动态代理类似的技术:
CGLIB:Code generator lib(代码生成库):可以在运行时动态地生成一个类、或者动态生成一个类的实例。
Javassist:运行时动态地生成一个类、或者动态生成一个类的实例。(Hibernate)
JDK动态代理要求被代理的类必须实现了接口,但CGLIB和Javcassist就没有这个限制。
JDK动态代理的实现机制:
Proxy类:提供了如下方法来创建动态代理类和动态代理实例:
Static Class<?> GetProxyClass(ClassLoader loader,Class<?>…interface):创建一个动态代理类所对应的Class对象,该代理类将实现interface所指定的多个接口,第一个ClassLoader参数指定生成动态代理类的类加载器。
Static Object newProxyInstance(ClassLoader loader,Class<?> interfaces,InvocationHandler h):创建一个动态代理对象,该代理对象的实现类实现了interface指定的系列接口欧,执行代理对象的每个方法都会被替换执行InvocationHadnler对象的invoke方法。
若使用GetProxyClass创建动态代理类后,希望使用该动态代理类创建对象,依然需要传入一个InvocationHandler对象,即系统生成的每个代理对象都有一个与之关联关联的invocationHandler对象。
动态代理对象需要实现所代理类的所有接口里定义的所有方法,实现这些方法体由InvocationHadnler对象
【关键点】:当程序员为InvocationHandler的invoke(…)方法提供实现体时,实际上就是为动态代理类的所有方法体提供了实现体。
直接生成动态代理类实例的代码片段1:
InvocationHandler handler = new MyInvocationHandler(…);
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
new Class<?>[] { Foo.class },handler);
先生成动态代理类,再生成实例的代码片段2(功能类似,但先生成动态代理类本身):
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class );
Constructor con = proxyClass.getConstructor(InvocationHandler.class);
InvocationHandler handler = new MyInvocationHandler(…);
Foo f = (Foo)con.newInstance(handler);
自定义动态代理:
1、定义一个接口,用于被动态代理生成动态代理类或动态代理对象
2、定义一个类实现InvocationHandler接口,并实现invoke方法,在调用代理对象的所有方法时,都会被替换成执行该方法,调用的对象、方法名和参数会传入该invoke方法,如下:
Public Object invoke(Object proxy,Method method,Object[] args):
proxy:代表动态代理对象
method:代表正在执行的方法
args:代表调用目标方法时传入的实参
3、创建实现InvocationHandler接口的类对象,得到InvocationHandler对象,随后使用Proxy的newProxyInstance(Classloader,InvocationHandler)创建动态代理对象,此时调用动态代理对象的所有方法就会被替换成调用InvocationHandler对象的invoke方法(调用的对象、方法名、参数等都会传递给invoke作为参数)。
JDK动态代理与AOP
Spring的AOP就是基于JDK动态代理的。当被代理的目标类没有实现接口,Spring AOP不得不使用CGLIB作为补充
【说明】:由于动态代理类的所有方法都将被替换成InvocationHandler的invoke()方法,因此,如果要为代理对象的所有方法都增加某种通用处理(或者进行某种修改),只要修改该invoke方法即可。
在该invoke方法的method参数代表了正在被调用的方法(method是动态变化),因此程序可通过method去回调目标对象正在被执行的方法。
实现步骤:
1、定义一个Dog接口,再定义一个GunDog实现Dog接口。且实现info和run方法
2、创建自定义的调用处理对象类MyInvocationHandler实现InvocationHandler接口
3、实现invoke方法,定义对实现接口Dog的类对象的所有方法都执行通用处理的代码块
,在中间通过method参数回调执行的方法:method.invoke(target,age)
4、此时,只要调用动态代理类对象执行任何方法,都相当于执行invoke方法,在所有方法前后都已经加上了通用的处理。
泛型和Class类,如:String.class的类型实际是Class,如果Class对应的类型位置,则使用Class<?>
若使用Field对象的getType方法只能获取到普通类型的参数类型,若需要获取指定成员变量的泛型类型,先使用如下方法获取该成员变量的泛型类型:
Field f = clazz.getField(“xx”);
Type gTyoe = f.getGenericType();
以上得到泛型类型Type后,强制转换为ParameterizedType对象,ParameterizedType代表被参数化的类型,也就是增加了泛型限制的类型,ParameterizedType有一下方法获取泛型:
getRawType():返回没有泛型信息的原始类型,也就是没有带泛型的类型
getActualTypeArguments()返回泛型参数的类型(有可能有多个,如Map<String,Integer>)
Java 9的模块化
模块化的价值:
1、java太庞大,急切需要把java分模块加载,使得java运行环境更轻量化。
2、包的职责太薄弱了,通过模块可以把java按功能分成不同的组件。
一个项目可包含N个模块,一个模块包含N个包,一个包包含N个类。
从文件结构来看,项目需要专门为模块建一个文件夹
Module-info.java是一个模块说明文件,该文件主要定义以下5种语句
1、导出语句:export,将该模块
2、开放语句:open
3、需要语句:require
4、使用语句:use
5、提供语句:provide