java19(反射)

最新推荐文章于 2024-10-16 15:58:18 发布
最新推荐文章于 2024-10-16 15:58:18 发布
阅读量393 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/8386blogs/p/7668435.html
版权

反射

        终极手段。规则破坏者

        1.calss

                 定义类关键字

        2. Construtor

                 构造函数的描述符

                 Class clazz = Person.class;

                 Constructor ctor = clazz.getConstructor(...);

                 ctor.setAccessible(true);

                 ctor.newInstance(...);

        3. field

                 字段（成员变量）描述符

                Field f = clazz.getDeclaredField("name");

        4. method

                方法描述符

                静态方法也可以通过反射访问

　　　　 Method m = clazz.getDeclearMethod("run");

　　　　 m.invoke(null);

        5. Modifier

                修饰符，判断是否含有指定的修饰符

                Modifier.isStatic(m.getModifier());

// Person.java

 1 package com.hzg.reflect;
 2 
 3 public class Person {
 4     private String name;
 5     private int age;
 6     public Person() {
 7         System.out.println("new Person()");
 8     }
 9     public Person(String name) {
10         this.name = name;
11         System.out.println("new Person(String name)");
12     }
13     public String getName() {
14         return name;
15     }
16     public void setName(String name) {
17         System.out.println("setName("+name+")");
18         this.name = name;
19     }
20     public int getAge() {
21         return age;
22     }
23     public void setAge(int age) {
24         this.age = age;
25     }
26     public void sayHello() {
27         System.out.println("hello");
28     }
29 }

TestPerson.java

  1 package com.hzg.reflect.test;
  2 
  3 import java.io.File;
  4 import java.lang.reflect.Constructor;
  5 import java.lang.reflect.Field;
  6 import java.lang.reflect.Method;
  7 import java.lang.reflect.Modifier;
  8 import java.net.URL;
  9 
 10 import org.junit.Test;
 11 
 12 import com.hzg.reflect.Person;
 13 
 14 public class TestPerson {
 15     
 16     /**
 17      * 创建对象
 18      */
 19     @Test
 20     public void newObject() {
 21 /*        Person p = new Person();
 22         p.setName("tom");
 23         p.setAge(20);
 24         p.sayHello();*/
 25     }
 26     
 27     /**
 28      * 通过反射创建对象
 29      */
 30     @Test
 31     public void newObjectInReflect() throws Exception{
 32         Class<Person> clazz = Person.class;
 33         // getName()是类的完整类名
 34         //String name = clazz.getName();
 35         String sname = clazz.getSimpleName();
 36         System.out.println(sname);
 37         Person person = clazz.newInstance();
 38         System.out.println(person);
 39     }
 40     
 41     @Test
 42     public void testConstructor() throws Exception{
 43         Class<Person> clazz = Person.class;
 44         // 得到类的构造函数
 45         Constructor<Person> ctor = clazz.getDeclaredConstructor();
 46         ctor.setAccessible(true);
 47         Object obj = ctor.newInstance();
 48         System.out.println(obj);
 49     }
 50     
 51     @Test
 52     public void testConstructor2() throws Exception{
 53         Class<Person> clazz = Person.class;
 54         // 得到类的构造函数
 55         Constructor<Person> ctor = clazz.getDeclaredConstructor(String.class);
 56         Object obj = ctor.newInstance("jerry");
 57         System.out.println(obj);
 58     }
 59     
 60     @Test
 61     public void testMethod() throws Exception{
 62         Class<Person> clazz = Person.class;
 63         
 64         Object obj = clazz.newInstance();
 65         Method m = clazz.getMethod("setName", String.class);
 66         // p.setName("tomas");
 67         m.invoke(obj, "tomas");
 68         System.out.println("over");
 69         System.out.println(obj);
 70     }
 71     
 72     @Test
 73     public void getMethods() throws Exception {
 74         Class<Person> clazz = Person.class;
 75         //Method[] methods = clazz.getDeclaredMethods();//类中声明的方法
 76         Method[] methods = clazz.getMethods();//获得类的公有方法
 77         for (Method m: methods) {
 78             String name = m.getName();
 79             System.out.println(name);
 80             //System.out.println(m);
 81         }
 82     }
 83     
 84     /**
 85      * 字段描述符
 86      */
 87     @Test
 88     public void testField() throws Exception {
 89         Class<Person> clazz = Person.class;
 90         Person obj = clazz.newInstance();
 91         
 92         // 获得字段描述符
 93         Field f = clazz.getDeclaredField("name");
 94         
 95         // 设置可访问性
 96         f.setAccessible(true);
 97         
 98         // 设置字段值 === this.name = "tom";
 99         f.set(obj, "tom");
100         
101         // 取出字段值
102         Object object = f.get(obj);
103         
104         System.out.println(object);
105         
106         System.out.println(obj.getName());
107         
108     }
109     
110     /**
111      * Modifier:修饰符
112      * @throws IllegalAccessException 
113      * @throws InstantiationException 
114      */
115     @Test
116     public void testModifer() throws Exception {
117         Class<Person> clazz = Person.class;
118         Method m = clazz.getDeclaredMethod("setName", String.class);
119         // 得到方法的修饰符总和
120         int modifer = m.getModifiers();
121         System.out.println(Modifier.isPublic(modifer));
122     }
123     
124     /**
125      * 得到指定包下的所有类
126      * @throws Exception 
127      */
128     @Test
129     public void getclasses() throws Exception {
130         Class clazz = Person.class;
131         ClassLoader loader = clazz.getClassLoader();
132         // 统一资源定位符
133         URL url = loader.getResource("com/hzg/reflect");
134         
135         // 文件夹
136         File file = new File(url.toURI());
137         File[] files = file.listFiles();
138         for (File f : files) {
139             String fname = f.getName();
140             if (!fname.endsWith(".class")) {
141                 continue;
142             }
143             String className = fname.substring(0, fname.lastIndexOf("."));
144             className = "com.hzg.reflect." + className;
145             clazz = Class.forName(className);
146             System.out.println(clazz);
147         }
148         
149     }
150     
151     /**
152      * 属性复制
153      * @throws IllegalAccessException 
154      * @throws IllegalArgumentException 
155      */
156     @Test
157     public void testPropertyCopy() throws Exception {
158         // 源对象
159         Person src = new Person();
160         src.setName("tom");
161         src.setAge(20);
162         
163         // 目标对象
164         Person target = new Person();
165         
166         Class clazz = Person.class;
167         Field[] fs = clazz.getDeclaredFields();
168         for (Field f : fs) {
169             String fname = f.getName();
170             // 判断是否可以访问，设置可访问性
171             if (!f.isAccessible()) {
172                 f.setAccessible(true);
173             }
174             // 获得该字段在src对象上对应的值
175             Object fvalue = f.get(src);
176             f.set(target, fvalue);
177         }
178         System.out.println("over");
179         
180     }
181 }

 内省

        专业操作javabean

 

 

对象复制

// Animal.java

 1 package com.hzg.reflect;
 2 
 3 public abstract class Animal {
 4     private String name;
 5 
 6     public String getName() {
 7         return name;
 8     }
 9 
10     public void setName(String name) {
11         this.name = name;
12     }
13     
14 }

// Dog.java

 1 package com.hzg.reflect;
 2 
 3 public class Dog extends Animal{
 4 
 5     private String blood;
 6 
 7     public String getBlood() {
 8         return blood;
 9     }
10 
11     public void setBlood(String blood) {
12         this.blood = blood;
13     }
14     
15 }

// TestPerson2.java

 1 package com.hzg.reflect.test;
 2 
 3 import java.io.File;
 4 import java.lang.reflect.Constructor;
 5 import java.lang.reflect.Field;
 6 import java.lang.reflect.Method;
 7 import java.lang.reflect.Modifier;
 8 import java.net.URL;
 9 
10 import org.junit.Test;
11 
12 import com.hzg.reflect.Dog;
13 import com.hzg.reflect.Person;
14 
15 public class TestPerson2 {
16 
17     /**
18      * 属性复制
19      * 
20      * @throws IllegalAccessException
21      * @throws IllegalArgumentException
22      */
23     @Test
24     public void testPropertyCopy2() throws Exception {
25         // 源对象
26         Dog src = new Dog();
27         src.setName("tom");
28         src.setBlood("A");
29 
30         // 目标对象
31         Dog target = new Dog();
32 
33         Class clazz = Dog.class;
34         Field[] fs = clazz.getDeclaredFields();
35         for (Field f : fs) {
36             String fname = f.getName();
37             Class<?> type = f.getType();
38             System.out.println(type);
39             // 判断是否可以访问，设置可访问性
40             if (!f.isAccessible()) {
41                 f.setAccessible(true);
42             }
43             // 获得该字段在src对象上对应的值
44             Object fvalue = f.get(src);
45             f.set(target, fvalue);
46         }
47         System.out.println("over");
48 
49     }
50 
51     /**
52      * 得到整个类家族树定义的所有字段
53      */
54     @Test
55     public void getAllFields() {
56         Class clazz = Dog.class;
57         printFields(clazz);
58     }
59 
60     /**
61      * 打印字段
62      */
63     private void printFields(Class clazz) {
64         /*if (clazz == Object.class) {
65             return;
66         }*/
67         if (clazz == null) {
68             return;
69         }
70         Field[] fs = clazz.getDeclaredFields();
71         if (fs != null && fs.length > 0) {
72             for (Field f : fs) {
73                 Class ftype = f.getType();
74                 String fname = f.getName();
75                 System.out.println(ftype + " " + fname);
76             }
77         }
78 
79         clazz = clazz.getSuperclass();
80         printFields(clazz);
81         
82         
83     }
84 }

// TestIntrospector.java

 1 package com.hzg.reflect.test;
 2 
 3 import java.beans.BeanInfo;
 4 import java.beans.Introspector;
 5 import java.beans.PropertyDescriptor;
 6 import java.lang.reflect.Method;
 7 
 8 import org.junit.Test;
 9 
10 import com.hzg.reflect.Dog;
11 
12 /**
13  * 内省，专业操作javabean
14  * @author zhengguohuang
15  *
16  */
17 public class TestIntrospector {
18     /**
19      * 
20      * @throws Exception
21      */
22     @Test
23     public void testIntrospective() throws Exception{
24         // 得到bean信息
25         BeanInfo bi = Introspector.getBeanInfo(Dog.class);
26         PropertyDescriptor[] pds = bi.getPropertyDescriptors();
27         for (PropertyDescriptor pd : pds) {
28             // getXxx()
29             Method getter = pd.getReadMethod();
30             System.out.println(getter);
31             // setXxx()
32             Method setter = pd.getWriteMethod();
33             System.out.println(setter);
34             //getter.invoke(, args)
35             //System.out.println(pd.getName());
36         }
37     }
38 }

使用内省实现对象的属性复制

 1 package com.hzg.reflect.test;
 2 
 3 import java.io.File;
 4 import java.io.FileOutputStream;
 5 import java.io.InputStream;
 6 import java.net.URISyntaxException;
 7 import java.net.URL;
 8 
 9 import org.junit.Test;
10 
11 /**
12  * 测试类加载器
13  * 
14  * @author zhengguohuang
15  *
16  */
17 public class TestClassLoader {
18 
19     /**
20      * 获得资源url
21      * @throws Exception 
22      * 
23      */
24     @Test
25     public void testClassLoader1() throws Exception {
26         ClassLoader loader = ClassLoader.getSystemClassLoader();
27         // 搜索类路径获取资源
28         URL url = loader.getResource("com/hzg/reflect/background.jpg");
29         File file = new File(url.toURI());
30         System.out.println(file.length());
31         System.out.println(loader);
32     }
33     
34     /**
35      * 获得资源流
36      * @throws Exception 
37      * 
38      */
39     @Test
40     public void testResourceStream() throws Exception {
41         ClassLoader loader = ClassLoader.getSystemClassLoader();
42         // 搜索类路径获取资源
43         InputStream is = loader.getResourceAsStream("com/hzg/reflect/background.jpg");
44         
45         byte[] bytes = new byte[is.available()];
46         is.read();
47         is.close();
48         new FileOutputStream("d:/xxx.jpg").write(bytes);
49         System.out.println(loader);
50     }
51 
52     /**
53      * 获得系统资源
54      * @throws Exception 
55      * 
56      */
57     @Test
58     public void testSystemResource() throws Exception {
59         InputStream is = ClassLoader.getSystemResourceAsStream("java/lang/String.class");
60         System.out.println(is.available());
61     }
62     
63     /**
64      * @throws Exception
65      * 
66      */
67     @Test
68     public void testLuncher() throws Exception {
69         // have not access
70         // sun.misc.Launcher l = new sun.misc.Launcher();
71         Class clazz = Class.forName("sun.misc.Launcher");
72         Object object = clazz.newInstance();
73         System.out.println(object);// sun.misc.Launcher@4459eb14
74         
75     }
76 }

动态代理

        不改变源码，增加新的功能

// Person.java

 1 package com.hzg.reflect;
 2 
 3 public class Person {
 4     private String name;
 5     private int age;
 6     public Person() {
 7         System.out.println("new Person()");
 8     }
 9     public Person(String name) {
10         this.name = name;
11         System.out.println("new Person(String name)");
12     }
13     public String getName() {
14         return name;
15     }
16     public void setName(String name) {
17         System.out.println("setName("+name+")");
18         this.name = name;
19     }
20     public int getAge() {
21         return age;
22     }
23     public void setAge(int age) {
24         this.age = age;
25     }
26     public void sayHello() {
27         System.out.println("hello");
28     }
29 }

 

// PersonDao.java

 1 package com.hzg.reflect.proxy;
 2 
 3 import com.hzg.reflect.Person;
 4 
 5 /**
 6  * Dao:data access object
 7  * @author zhengguohuang
 8  *
 9  */
10 public interface PersonDao {
11 
12     public void insert(Person p);
13     
14     public void update(Person p);
15 }

// PersonDao2.java

 1 package com.hzg.reflect.proxy;
 2 
 3 import com.hzg.reflect.Person;
 4 
 5 /**
 6  * Dao:data access object
 7  * @author zhengguohuang
 8  *
 9  */
10 public interface PersonDao2 {
11 
12     public void insert2(Person p);
13     
14     public void update2(Person p);
15 }

// PersonDaoImpl.java

 1 package com.hzg.reflect.proxy;
 2 
 3 import com.hzg.reflect.Person;
 4 
 5 /**
 6  * Dao实现类
 7  * @author zhengguohuang
 8  *
 9  */
10 public class PersonDaoImpl implements PersonDao, PersonDao2{
11 
12     @Override
13     public void insert(Person p) {
14         System.out.println("insert");
15     }
16 
17     @Override
18     public void update(Person p) {
19         System.out.println("update");
20     }
21 
22     @Override
23     public void insert2(Person p) {
24         System.out.println("insert2");
25     }
26 
27     @Override
28     public void update2(Person p) {
29         System.out.println("update2");
30     }
31 
32 }

// MyInvovationHandler.java

 1 package com.hzg.reflect.proxy;
 2 
 3 import java.lang.reflect.InvocationHandler;
 4 import java.lang.reflect.Method;
 5 
 6 public class MyInvocationHandler implements InvocationHandler {
 7 
 8     private Object target;
 9     
10     public MyInvocationHandler(Object target) {
11         this.target = target;
12     }
13 
14     @Override
15     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
16         System.out.println("hello");// 调用方法之前
17         Object ret = method.invoke(target, args);
18         System.out.println("over");// To do ... after invoke
19         return ret;
20     }
21 
22 }

// App.java

 1 package com.hzg.reflect.proxy;
 2 
 3 import java.lang.reflect.Proxy;
 4 
 5 import com.hzg.reflect.Person;
 6 
 7 public class App {
 8 
 9     public static void main(String[] args) {
10         ClassLoader loader = ClassLoader.getSystemClassLoader();
11         Class[] interfaces = {PersonDao.class, PersonDao2.class};
12         PersonDao dao = new PersonDaoImpl();
13         MyInvocationHandler h = new MyInvocationHandler(dao);
14         
15         Object proxy = (PersonDao)Proxy.newProxyInstance(loader, interfaces, h);
16         ((PersonDao)proxy).insert(new Person());
17         ((PersonDao)proxy).update(null);
18         ((PersonDao2)proxy).insert2(null);
19         ((PersonDao2)proxy).update2(null);
20     }
21 
22 }

 

转载于:https://www.cnblogs.com/8386blogs/p/7668435.html

aihua5318
关注
java技术专家 【JDK各个版本特性讲解】JDK19特性
大壮
12-19 914
java技术专家 【JDK各个版本特性讲解】JDK19特性
第十六章：Java之反射和枚举
快乐江湖的博客
10-12 755
Java反射(reflection)：反射机制是指在运行状态中，对于任意一个类，我们都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能称之为Java的反射机制在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。
java19
qq_54262540的博客
05-18 415
文章目录一异常处理1如果try中出现多个异常对象，那么可以使用多个catch来进行异常处理2如果try中产生了异常，那么就会执行catch中的异常处理逻辑二多个异常，如何处理三 finally关键字1.finally不能单独使用，必须和try一起使用2.finally一般用于资源释放(资源回收)，无论程序是否出现异常，都要释放资源(I/O)代码及结果大数据2005周敏2020080605048 一异常处理 1如果try中出现多个异常对象，那么可以使用多个catch来进行异常处理 2如果try中产生了异常，那
Java 19 正式发布，七大特性齐发，最常用的还是 Java 11
最新发布
2401_87878486的博客
10-16 368
时隔六个月，9 月 20 日，Java 19 如期而至，这一版本是自 Oracle 宣布 Java 以六个月为一周期发布的第十个版本。不过值得注意的是，JDK 19 是标准的非 LTS（长期支持）版本。 话不多说，我们先来一起看一下最新版本的 Java 带来了哪些更新？ Java 19 的七大亮点更新 根据官方发布的公告显示，Java 19 版本带来了七大主要功能更新，包括结构化并发、记录模式、外部函数和内存 API 的预览，以及对开源的 Linux/RISC-V 指令集架构（ISA）的支持。
JAVA19
JOKER_IN_RAIN的博客
06-13 254
内部类 分为静态和非静态。成员内部类是外部类成员，可以调用外部类成员。外部类使用内部类的成员创建类对象。局部内部类内部类可以访问外部类成员。基本类型的封装类。 int为基本类型 Integer封装类. char为基本类型 转为 Character封装类.其他基本的大写第一个字母就可以。 int的型转为string是用toString。String转为int是用parseInt或者valueof。 Java提供了String、StringBuffer、StringBuilder三个类来封装字符串，Sting创
Java 19新特性：虚拟线程(Virtual Threads )
XiumingLee的博客
09-11 6113
JDK19马上就要发布了，今天我们来谈一谈JDK 19的新特性虚线程，它属于JEP 425 Project Loom(425:)。这可能是JDK 19中最值得期待的预览特性之一。我们知道Java阻塞平台线程的代价很高，这就是为什么要不惜一切代价避免这种情况，以及为什么要基于回调编写响应式代码。响应式代码做得很好，但它使代码难以阅读和测试，这显然不是理想的情况。使用DK9和虚拟线程，阻塞线程变得如此廉价，以至于我们不再需要编写响应式代码，我们 的老式阻塞同步代码也可以很好地工作！
java 防止反射_解决反射型XSS漏洞攻击
weixin_29777019的博客
02-25 3259
对于程序员来说安全防御，无非从两个方面考虑，要么前端要么后台。一、首先从前端考虑过滤一些非法字符。前端的主控js中，在 输入框标签中，找到点击发送按钮后，追加到聊天panel前 进行过滤input输入内容1 // 过滤xss反射型漏洞2 filterinputtxt: function (html) {3 html = html.repl...
Java中的反射和枚举
EXECEL的博客
03-27 736
1、枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承与 java.lang.Enum2、枚举可以避免反射和序列化问题。
JAVA-反射（应用：动态代理）
wa的一声就哭了
06-19 468
目录反射的理解​反射机制能提供的功能关于java. lang. Class类的理解创建对应运行时类的对象获取运行时类的全部结构获取指定结构反射的应用：动态代理 Reflection (反射是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。➢在运行时判断任意一个对象所属的类 ➢在运行时构造任意一个类的对象 ➢在运行时判断任意一个类所具有的成员变量和方法 ➢在运行时获取泛型信息 ➢在运行时调用任意一个对象的成员变量和方
Java 中的反射（包含注解类简介）
wzskqfzl_zg的博客
02-16 435
value 和 isdelete 都有默认值，所以可赋值可不赋值，在类上的注解中，这两个参数我都未赋值，在属性上的注解中，我给 value 赋值为“清华”，与默认值“hello world”不一致，可以理解为这次使用中赋值覆盖了默认值，最终 Student 的注解中 value 的输出结果为“hello world”，info 的注解中 value 的输出结果为“清华”一个 Class 对象包含了特定某个类的有关信息：类的数据成员名、方法和构造器，类实现的接口等。1. @Target：注解的作用目标。
2021-05-13
m0_55689512的博客
05-13 103
Java学习 day19 目录 try–catch 语句块 finally 语句块 多异常处理 1、try–catch 语句块 如果异常出现的话，会立刻终止程序,所以我们得处理异常: 1.该方法不处理，而是声明抛出，由该方法的调用者来处理(throws)。 2.在方法中使用try-catch的语句块来处理异常。 try-catch的方式就是捕获异常。 捕获异常:Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。 捕获异常语法如下: try{ 编写可能会出现异
JDK 19 / Java 19 正式发布，虚拟线程来了！
良月柒
10-01 970
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 2.8 分钟。来自：OSC开源社区（ID：poschina2013)记录模式 （预览版）Linux/RISC-V 移植外部函数和内存 API （预览版）虚拟线程（预览版）Vector API （第四次孵化）Switch 模式匹配（第三预览版）结构化并发（孵化阶段）JDK 19 / Java 19 已正式发布。图片新版本总共包含 ...
Java19
m0_52900812的博客
05-13 206
一，捕获异常try…catch try:该代码块中编写可能产生异常的代码 catch: 1.如果try中出现了多个异常对象，那么可以使用多个catch来进行异常处理 2.如果try中产生了异常那么就会执行catch中的异常处理逻辑，执行完catch中的逻辑后会继续执行try–catch，如果try没有产生异常，那么就不会执行catch中的异常逻辑，直接执行后续代码 finally关键字 1.finally不能单独使用，必须和try一起使用 2.finally一般用于资源释放(资源回收)，无论程序是否出现异常
7月12日Java学习（JDBC数据库编程）
m0_51947717的博客
07-12 380
JDBC（Java Database Connectivity）Java数据库连接技术官方JDK中提供的与JDBC有关的API都在java.sql包里面API（Application Programming Interface）API是三方库中的一系列类和接口中方法的集合调用API指的就是调用三方库中代码注册mysql的驱动需要让mysql驱动包中的Driver类发生类加载即可Class.forName（String）；这个方法是JDK提供的专门用于类加载的方法参数写类的路径的字符串，必须是全路径“包名+类
Java基础——Java重点基础之IO流（二）
梦想家Eva的专栏
12-07 332
一，字符流FileReader 1.字符流是什么 字符流是可以直接读写字符的IO流字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出. 2.FileReader FileReader类的read()方法可以按照字符大小
JDK 19 / Java 19 新特性
ejinxian的专栏
04-24 1703
JDK 19 预计今年 9 月发布，推出两个重要特性。 一个是 Vector API，另一个则是将 JDK 移植到 RISC-V。其中前者 Vector API 是一个表达向量计算的 API，JDK 移植到开源的 Linux/RISC-V 指令集架构（ISA）。 JDK 19 包含通用泛型、值对象和记录模式等大量的特性 ，增加新的 Vector API 和移植到 RISC-V 两个特性。 RISC-V 是一个自由和开源的 RISC 指令集架构（ISA），最初由加利福...
Java19---JavaScript (1)
hala22的博客
01-26 574
导读 1.JavaScript简介 JavaScript简介
Java面试精华：多态、反射、并发与内存管理详解
19. **ClassLoader（类加载器）**：负责加载Java类到内存，每个线程有自己的类加载器，防止类加载冲突。理解类加载器机制有助于优化部署和解决依赖问题。 这些知识点构成了Java开发的核心基础，掌握它们对于应聘...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值