既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上C C++开发知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
⭕ 加载到内存中的运行时类,会缓存一定的时间。在此时间之内,我们可以通过不同的方式来获取此运行时类。
1.2 类的加载过程图解
当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过如下三个步骤来对该类进行初始化。
⭕ 类的加载:将
class
文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class
对象,作为方法区中类数据的访问入口(即引用地址)。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
⭕ 类的链接:将Java类的二进制代码合并到JVM的运行状态之中的过程。
● 验证:确保加载的类信息符合JVM规范,例如:以cafe开头,没有安全方面的问题
● 准备:正式为类变量(static
)分配内存并设置类变量默认初始值的阶段,这些内存 都将在方法区中进行分配。
● 解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。
⭕ 类的初始化:
● 执行类构造器【clinit
】()方法的过程。类构造器【clinit
】()方法是由编译期自动收集类中 所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信 息的,不是构造该类对象的构造器)。
● 当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类 的初始化。
● 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。
public class ClassLoadingTest {
public static void main(String[] args) {
System.out.println(A.m);
} }
class A {
static { m = 300;
}
static int m = 100;
}
//第二步:链接结束后m=0
//第三步:初始化后,m的值由<clinit>()方法执行决定
// 这个A的类构造器<clinit>()方法由类变量的赋值和静态代码块中的语句按照顺序合并产生,类似于
// <clinit>(){
// m = 300;
// m = 100;
// }
1.3 了解:什么时候会发生类初始化?
⭕ 类的主动引用(一定会发生类的初始化)
- 当虚拟机启动,先初始化
main
方法所在的类new
一个类的对象- 调用类的静态成员(除了final常量)和静态方法
- 使用
java.lang.reflect
包的方法对类进行反射调用- 当初始化一个类,如果其父类没有被初始化,则先会初始化它的父类
⭕ 类的被动引用(不会发生类的初始化)
- 当访问一个静态域时,只有真正声明这个域的类才会被初始化
- 当通过子类引用父类的静态变量,不会导致子类初始化
- 通过数组定义类引用,不会触发此类的初始化
- 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)
1.4 类加载器的作用
⭕ 类加载的作用:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表这个类的java.lang.Class对象,作为 方法区中类数据的访问入口。
⭕ 类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器 中,它将维持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
1.5 JVM中不同类型的类的加载器
1.6 代码演示
⭕ 不同类型的类的加载器:
@Test
public void test1(){
//对于自定义类,使用系统类加载器进行加载
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2:系统类加载器
//调用系统类加载器的getParent():获取扩展类加载器
ClassLoader classLoader1 = classLoader.getParent();
System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@279f2327:扩展类加载器
//调用扩展类加载器的getParent():无法获取引导类加载器
//引导类加载器主要负责加载java的核心类库,无法加载自定义类的。
ClassLoader classLoader2 = classLoader1.getParent();
System.out.println(classLoader2);//null
ClassLoader classLoader3 = String.class.getClassLoader();
System.out.println(classLoader3);//null
}
⭕ 使用系统类加载器读取
Properties
配置文件。
/\*
Properties:用来读取配置文件。
\*/
@Test
public void test2() throws Exception {
Properties pros = new Properties();
//此时的文件默认在当前的module下。
//读取配置文件的方式一:
// FileInputStream fis = new FileInputStream("jdbc.properties");
// FileInputStream fis = new FileInputStream("src\\jdbc1.properties");
// pros.load(fis);
//读取配置文件的方式二:使用ClassLoader
//配置文件默认识别为:当前module的src下
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
pros.load(is);
String user = pros.getProperty("user");
String password = pros.getProperty("password");
System.out.println("user = " + user + ",password = " + password);
}
}
2. 何为Class类?
⭕
Class
类在Object
类中定义了以下的方法,此方法将被所有子类继承:
public final Class getClass()
以上的方法返回值的类型是一个
Class
类,此类是Java
反射的源头,实际上所谓反射从程序的运行结果来看也很好理解,即:可以通过对象反射求出类的名称。
⭕ 对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言,
JRE
都为其保留一个不变的Class
类型的对象。
一个Class
对象包含了特定某个结构(class
/interface
/enum
/annotation
/primitivetype
/void
/[]
)的有关信息。
⭕
Class
本身也是一个类
⭕
Class
对象只能由系统建立对象
⭕ 一个加载的类在
JVM
中只会有一个Class
实例
⭕ 一个Class对象对应的是一个加载到
JVM
中的一个.class
文件
⭕ 每个类的实例都会记得自己是由哪个
Class
实例所生成
⭕ 通过
Class
可以完整地得到一个类中的所有被加载的结构
⭕
Class
类是Reflection
的根源,针对任何你想动态加载、运行的类,唯有先获得相应的
3. Class类的常用方法方法
方法名 | 功能说明 |
---|---|
static Class forName(String name) | 返回指定类名 name 的 Class 对象 |
Object newInstance() | 调用缺省构造函数,返回该Class 对象的一个实例 |
getName() | 返回此Class对象所表示的实体(类、接口、数组类、基本类型或void )名称 |
Class getSuperClass() | 返回当前Class 对象的父类的Class 对象 |
Class [] getInterfaces() | 获取当前Class 对象的接口 |
ClassLoader getClassLoader() | 返回该类的类加载器 |
Class getSuperclass() | 返回表示此Class 所表示的实体的超类的Class |
Constructor[] getConstructors() | 返回一个包含某些Constructor 对象的数组 |
Field[] getDeclaredFields() | 返回Field 对象的一个数组 |
Method getMethod(String name,Class … paramTypes) | 返回一个Method 对象,此对象的形参类型为paramType |
3. 哪些类型可以有Class对象?
(1)class: 外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类
(2)interface:接口
(3)[]:数组
(4)enum:枚举
(5)annotation:注解@interface
(6)primitive type:基本数据类型
(7)void
三、获取Class类实例的四种方法
1. 调用运行时类的属性:.class
前提:若已知具体的类,通过类的class属性获取,该方法最为安全可靠, 程序性能最高
示例:Class clazz1 = String.class;
2. 通过运行时类的对象,调用getClass()
前提:已知某个类的实例,调用该实例的
getClass()
方法获取Class
对象
示例:Class clazz = “www.atguigu.com”.getClass();
3.调用Class的静态方法:forName(String classPath)
前提:已知一个类的全类名,且该类在类路径下,可通过
Class
类的静态方法forName()
获取,可能抛出ClassNotFoundException
示例:Class clazz = Class.forName(“java.lang.String”);
4. 使用类的加载器:ClassLoader
示例:
ClassLoader cl = this.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“类的全类名”);
5. 代码演示
@Test
public void test1() throws ClassNotFoundException {
//方式一:调用运行时类的属性:.class
Class clazz1 = Person.class;
System.out.println(clazz1);//class com.jiaying.java1.Person
//方式二:通过运行时类的对象,调用getClass()
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);//class com.jiaying.java1.Person
//方式三:调用Class的静态方法:forName(String classPath)
Class clazz3 = Class.forName("com.jiaying.java1.Person");
Class clazz5 = Class.forName("java.lang.String");
System.out.println(clazz3);//class com.jiaying.java1.Person
System.out.println(clazz5);//class java.lang.String
System.out.println(clazz1 == clazz2);//true
System.out.println(clazz1 == clazz3);//true
//方式四:使用类的加载器:ClassLoader (了解)
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("com.jiaying.java1.Person");
System.out.println(clazz4);//class com.jiaying.java1.Person
System.out.println(clazz1 == clazz4);//true
}
四、 创建运行时类的对象
1. 引入
⭕ 有了Class对象,能做什么?
创建类的对象:调用
Class
对象的newInstance()
方法
要求:
- 类必须有一个无参数的构造器。
- 类的构造器的访问权限需要足够。
⭕ 难道没有无参的构造器就不能创建对象了吗?
不是!只要在操作的时候明确的调用类中的构造器,并将参数传递进去之后,才可以实例化操作。
步骤如下:
- 通过
Class
类的getDeclaredConstructor(Class … parameterTypes)
取得本类的指定形参类型的构造器- 向构造器的形参中传递一个对象数组进去,里面包含了构造器中所需的各个参数。
- 通过
Constructor
实例化对象。
2. 语法步骤
(1)根据全类名获取对应的
Class
对象
String name = “atguigu.java.Person";
Class clazz = null;
clazz = Class.forName(name);
(2)调用指定参数结构的构造器,生成
Constructor
的实例
Constructor con = clazz.getConstructor(String.class,Integer.class);
(3)通过
Constructor
的实例创建对应类的对象,并初始化类属性
Person p2 = (Person) con.newInstance("Peter",20);
System.out.println(p2);
3. 代码演示
@Test
public void test1() throws IllegalAccessException, InstantiationException {
Class<Person> clazz = Person.class;
/\*
newInstance():调用此方法,创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。
要想此方法正常的创建运行时类的对象,要求:
1.运行时类必须提供空参的构造器
2.空参的构造器的访问权限得够。通常,设置为public。
在javabean中要求提供一个public的空参构造器。原因:
1.便于通过反射,创建运行时类的对象
2.便于子类继承此运行时类时,默认调用super()时,保证父类有此构造器
\*/
Person obj = clazz.newInstance();
System.out.println(obj);
}
4. 体会反射的动态性
//体会反射的动态性
@Test
public void test2(){
for(int i = 0;i < 100;i++){
int num = new Random().nextInt(3);//0,1,2
String classPath = "";
switch(num){
case 0:
classPath = "java.util.Date";
break;
case 1:
classPath = "java.lang.Object";
break;
case 2:
classPath = "com.atguigu.java.Person";
break;
}
try {
Object obj = getInstance(classPath);
System.out.println(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/\*
创建一个指定类的对象。
classPath:指定类的全类名
\*/
public Object getInstance(String classPath) throws Exception {
Class clazz = Class.forName(classPath);
return clazz.newInstance();
}
}
五、获取运行时类的完整结构
提供具有丰富内容的Person
类
//接口
public interface MyInterface {
void info();
}
//注解
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
String value() default "hello";
}
//父类
public class Creature<T> implements Serializable {
private char gender;
public double weight;
private void breath(){
System.out.println("生物呼吸");
}
public void eat(){
System.out.println("生物吃东西");
}
}
//Person类
@MyAnnotation(value="hi")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{
private String name;
int age;
public int id;
public Person(){}
@MyAnnotation(value="abc")
private Person(String name){
this.name = name;
}
Person(String name,int age){
this.name = name;
this.age = age;
}
@MyAnnotation
private String show(String nation){
System.out.println("我的国籍是:" + nation);
return nation;
}
public String display(String interests,int age) throws NullPointerException,ClassCastException{
return interests + age;
}
@Override
public void info() {
System.out.println("我是一个人");
}
@Override
public int compareTo(String o) {
return 0;
}
private static void showDesc(){
System.out.println("我是一个可爱的人");
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", id=" + id +
'}';
}
}
1. 获取当前运行时类的属性结构
方法 | 作用 |
---|---|
public Field[] getFields() | 返回此Class 对象所表示的类或接口的public 的Field |
public Field[] getDeclaredFields() | 返回此Class 对象所表示的类或接口的全部Field |
- Field方法中:
方法 | 作用 |
---|---|
public int getModifiers() | 以整数形式返回此Field 的修饰符 |
public Class<?> getType() | 得到Field 的属性类型 |
public String getName() | 返回Field 的名称 |
@Test
public void test1(){
Class clazz = Person.class;
//获取属性结构
//getFields():获取当前运行时类及其父类中声明为public访问权限的属性
Field[] fields = clazz.getFields();
for(Field f : fields){
System.out.println(f);
}
System.out.println();
//getDeclaredFields():获取当前运行时类中声明的所有属性。(不包含父类中声明的属性)
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
System.out.println(f);
}
}
//权限修饰符 数据类型 变量名
@Test
public void test2(){
Class clazz = Person.class;
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
//1.权限修饰符
int modifier = f.getModifiers();
System.out.print(Modifier.toString(modifier) + "\t");
//2.数据类型
Class type = f.getType();
System.out.print(type.getName() + "\t");
//3.变量名
String fName = f.getName();
System.out.print(fName);
System.out.println();
}
}
}
2. 获取当前运行时类的方法结构
方法 | 作用 |
---|---|
public Method[] getMethods() | 返回此Class 对象所表示的类或接口的public 的方法 |
public Method[] getDeclaredMethods() | 返回此Class 对象所表示的类或接口的全部方法 |
- Method类中:
方法 | 作用 |
---|---|
public Class<?> getReturnType() | 取得全部的返回值 |
public Class<?>[] getParameterTypes() | 取得全部的参数 |
public int getModifiers() | 取得修饰符 |
public Class<?>[] getExceptionTypes() | 取得异常信息 |
@Test
public void test1(){
Class clazz = Person.class;
//getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
Method[] methods = clazz.getMethods();
for(Method m : methods){
System.out.println(m);
}
System.out.println();
//getDeclaredMethods():获取当前运行时类中声明的所有方法。(不包含父类中声明的方法)
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods){
System.out.println(m);
}
}
/\*
@Xxxx
权限修饰符 返回值类型 方法名(参数类型1 形参名1,...) throws XxxException{}
\*/
@Test
public void test2(){
Class clazz = Person.class;
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods){
//1.获取方法声明的注解
Annotation[] annos = m.getAnnotations();
for(Annotation a : annos){
System.out.println(a);
}
//2.权限修饰符
System.out.print(Modifier.toString(m.getModifiers()) + "\t");
//3.返回值类型
System.out.print(m.getReturnType().getName() + "\t");
//4.方法名
System.out.print(m.getName());
System.out.print("(");
//5.形参列表
Class[] parameterTypes = m.getParameterTypes();
if(!(parameterTypes == null && parameterTypes.length == 0)){
for(int i = 0;i < parameterTypes.length;i++){
if(i == parameterTypes.length - 1){
System.out.print(parameterTypes[i].getName() + " args\_" + i);
break;
}
System.out.print(parameterTypes[i].getName() + " args\_" + i + ",");
}
}
System.out.print(")");
//6.抛出的异常
Class[] exceptionTypes = m.getExceptionTypes();
if(exceptionTypes.length > 0){
System.out.print("throws ");
for(int i = 0;i < exceptionTypes.length;i++){
if(i == exceptionTypes.length - 1){
System.out.print(exceptionTypes[i].getName());
break;
}
System.out.print(exceptionTypes[i].getName() + ",");
}
}
System.out.println();
}
}
}
3. 获取当前运行时类的构造器结构
方法 | 作用 |
---|---|
public Constructor<T>[] getConstructors() | 返回此 Class 对象所表示的类的所有public 构造方法。 |
public Constructor<T>[] getDeclaredConstructors() | 返回此 Class 对象表示的类声明的所有构造方法。 |
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
System.out.print(exceptionTypes[i].getName());
break;
}
System.out.print(exceptionTypes[i].getName() + ",");
}
}
System.out.println();
}
}
}
#### 3. 获取当前运行时类的构造器结构
| 方法 | 作用 |
| --- | --- |
| `public Constructor<T>[] getConstructors()` | 返回此 `Class` 对象所表示的类的所有`public`构造方法。 |
| `public Constructor<T>[] getDeclaredConstructors()` | 返回此 `Class` 对象表示的类声明的所有构造方法。 |
[外链图片转存中...(img-arskMcrt-1715815691294)]
[外链图片转存中...(img-htYBUZxX-1715815691294)]
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**[需要这份系统化的资料的朋友,可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**