Java反射（用浅显的例子带你入坑） --- Java内功心法

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量123 收藏
点赞数
分类专栏： SE基础 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64247824/article/details/130126602
版权

目录

1.定义：

2.用途：

3.反射的使用：

3.1获取class文件的三种方式：

3.2反射获取构造函数：

3.3反射获取成员变量：

3.4反射获取成员方法：

4.反射的利与弊：

1.定义：

        Java的反射机制（reflection）机制就是在运行状态中，对于任何一个类，都能获取这个类的属性和方法。对于如何一个对象，都能够调用它任意的方法和属性（包括private修饰的字段），那么既然我们能够拿到这些方法和属性，那么我们当然就可以修改它们了。这种动态获取信息以及动态调用方法的功能就被称为Java语言的反射机制。

        通俗地讲，反射就是把类里的属性和方法映射为一个个Java对象，我们通过操控这些对象来调用或修改类里的属性和方法。

        想要解剖一个类，必然要拿到这个类的字节码文件对象。而解剖使用的就是Class类的方法。

Class类：

         Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）

        Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为 一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类。

        Class类没有公共的构造方法，Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

2.用途：

        反射在实际项目中应用的非常的广泛，很多设计和开发都和反射有关，比如通过反射去调用字节码文件、调用系统隐藏 Api、动态代理的设计模式，Android 逆向、著名的 Spring 框架、各类 Hook 框架等等。

3.反射的使用：

我们来试着获取Student类的属性和方法：

package com.MyRefection;

public class Student {
    private String name;
    private int age;
    public int id;

    private Student(String name) {
        this.name = name;
    }

    protected Student(int age) {
        this.age = age;
    }

    public Student(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public void study(int time) {
        System.out.println(this.name + "学习了" + time + "个小时");
    }
    
    private void eat(String food) {
        System.out.println(this.name + "中午吃了" + food);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

3.1获取class文件的三种方式：

第一种，使用 Class.forName("类的全路径名"); 静态方法。 前提：已明确类的全路径名。

 此处，我们有一个Student类，我们要获取它的全路径->

点击这个Copy Reference就可以获取到我们的全路径啦

 tips：这种方式获取的全路径只有复制到双引号""或注释里才会显示完整~~

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        //第一种，使用 Class.forName("类的全路径名"); 静态方法。 前提：已明确类的全路径名。
        Class class1 = Class.forName("com.MyRefection.Student");

        //我们来输出一下
        System.out.println(class1);//运行结果：class com.MyRefection.Student
    }
}

这种方法是最常用，最安全的。

第二种，使用 .class 方法。 说明：仅适合在编译前就已经明确要操作的 Class。

package com.MyRefection;

public class Main {
    public static void main(String[] args){
        //第二种，使用 .class 方法。 说明：仅适合在编译前就已经明确要操作的 Class。
        Class class2 = Student.class;

        //我们来输出一下
        System.out.println(class2);//运行结果：class com.MyRefection.Student
    }
}

第三种，使用类对象的 getClass() 方法。

package com.MyRefection;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        //第三种，使用类对象的 getClass() 方法。
        Student student = new Student("张三", 16, 116);
        Class class3 = student.getClass();

        //我们来输出一下
        System.out.println(class3);//运行结果：class com.MyRefection.Student
    }
}

使用这种方法要先创建该类的实例对象。

那么用这三种方法创建的Class对象是否相等呢？

System.out.println(class1 == class2 && class2 == class3);//运行结果：true

答案是true~~

3.2反射获取构造函数：

方法功能
getConstructor(Class... parameterTypes)获得该类中与参数类型匹配的公有构造方法
getConstructors()获得该类的所有公有构造方法
getDeclaredConstructor(Class... parameterTypes)获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()获得该类所有构造方法
newInstance()创建实例
setAccessible(boolean flag)表示是否取消权限的校验

注意：带有Declared字眼的就代表可以获取所有方法或属性（包括private修饰的）

1.getConstructors()

package com.MyRefection;

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.创建Constructor[]数组来获取构造方法
        Constructor[] constructors1 = clazz.getConstructors();

        //遍历一下看看效果：
        for (Constructor constructor : constructors1) {
            System.out.println(constructor);
        }
        //执行结果：
        //public com.MyRefection.Student(java.lang.String,int,int)
        //只能访问到public修饰的构造函数

    }
}

2.getDeclaredConstructors()

package com.MyRefection;

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.使用getDeclaredConstructors方法来获取全部构造方法
        Constructor[] constructors2 = clazz.getDeclaredConstructors();
        //遍历一下看看效果：
        for (Constructor constructor : constructors2) {
            System.out.println(constructor);
        }
        //执行结果：
        //public com.MyRefection.Student(java.lang.String,int,int)
        //protected com.MyRefection.Student(int)
        //private com.MyRefection.Student(java.lang.String)
        //可以访问其他修饰符（private/protected）修饰的构造函数

    }
}

3.getConstructor(Class... parameterTypes)

package com.MyRefection;

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.获取单个构造函数
        Constructor constructor1 = clazz.getConstructor();
        //输出一下看看效果
        System.out.println(constructor1);
        //执行之后报错了~~
    }
}

 原因是我们Student的构造函数中并没有无参构造函数，我们想要调用哪个函数，就要在getConstructor()中加该函数的参数类型的字节码文件，我们以这个含三个参数的构造方法为例：

想要获取这个构造函数，应该这样写：

package com.MyRefection;

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.获取单个构造函数
        Constructor constructor1 = clazz.getConstructor(String.class, int.class, int.class);
        //输出一下看看效果
        System.out.println(constructor1);
        //执行结果：public com.MyRefection.Student(java.lang.String,int,int)
    }
}

 注意，

 这里传递的是参数类型的字节码文件！！！

4.getDeclaredConstructor(Class... parameterTypes)

        注意getConstructor(Class... parameterTypes)并不能获取私有的构造函数，这时候就要使用getDeclaredConstructor(Class... parameterTypes)：

被private修饰

package com.MyRefection;

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.获取单个构造函数（包含被private/protected修饰的）
        Constructor constructor2 = clazz.getDeclaredConstructor(String.class);
        //输出一下看看效果
        System.out.println(constructor2);
        //执行结果：
        //private com.MyRefection.Student(java.lang.String)
    }
}

OK，现在我们获取到这个构造函数了，那我们可以使用它来做什么事情呢？

1.我们可以使用constructor2这个对象来查看它所指向的构造函数是什么类型的：

        //我们可以使用constructor2这个对象来查看它所指向的构造函数是什么类型的
        System.out.println(constructor2.getModifiers());
        //执行结果：2

为什么执行结果是2呢？

        原因是通过这个函数我们获取到的是常量字段值，是int类型，而不是String类型，下面是反射的常量字段值：

 可以看到private的常量字段值是2~~

2.获取构造方法的参数：

​
package com.MyRefection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Parameter;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.获取单个构造函数
        Constructor constructor1 = clazz.getConstructor(String.class, int.class, int.class);
        //输出一下看看效果
        System.out.println(constructor1);
        //执行结果：
        //public com.MyRefection.Student(java.lang.String,int,int)



        //3.获取三个参数的构造函数的参数
        Parameter[] parameters = constructor1.getParameters();
        //打印一下
        for (Parameter parameter : parameters) {
            System.out.println(parameter);
        }
        //结果：
        //java.lang.String arg0
        //int arg1
        //int arg2

    }
}

​

3.使用反射创建对象：

package com.MyRefection;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Parameter;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.获取单个构造函数（包含被private/protected修饰的）
        Constructor constructor2 = clazz.getDeclaredConstructor(String.class);
        //输出一下看看效果
        System.out.println(constructor2);
        //执行结果：
        //private com.MyRefection.Student(java.lang.String)


        //3.使用反射创建对象,这里我们使用private修饰的构造函数来创建对象
        Student student = (Student) constructor2.newInstance("张三");
        //执行结果：报错了~~
    }
}

原因是这个构造函数被private修饰，不能直接创建，我们需要使用setAccessible(boolean flag)来取消权限的校验：

        //3.使用反射创建对象,这里我们使用private修饰的构造函数来创建对象

        constructor2.setAccessible(true);//设置为true表示取消对权限的校验

        Student student = (Student) constructor2.newInstance("张三");
        //打印一下这个student对象
        System.out.println(student);
        //执行结果：com.MyRefection.Student@1b6d3586

注意如果这个构造函数是public修饰的则可以不用加setAccessible(boolean flag)语句~~

3.3反射获取成员变量：

方法功能
setAccessible(boolean flag)获得某个公有的属性对象
getFields()获得所有公有的属性对象
getDeclaredField(String name)获得某个属性对象
getDeclaredFields()获得所有属性对象
void set(Object obj, Object value)赋值
Object get(Object obj)获取值

        前四个方法与前面反射获取构造函数大相径庭，这里就不过多讲解了(直接上代码)：

package com.MyRefection;

import java.lang.reflect.Field;

public class Main2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.创建Field数组来获取公有的成员变量
        Field[] fields1 = clazz.getFields();
        //遍历一下
        for (Field field : fields1) {
            System.out.println(field);
        }
        //输出结果：
        //public int com.MyRefection.Student.id


        //3.创建Field[]数组来获取所有成员变量
        Field[] fields2 = clazz.getDeclaredFields();
        //遍历一下
        for (Field field : fields2) {
            System.out.println(field);
        }
        //输出结果：
        //private java.lang.String com.MyRefection.Student.name
        //private int com.MyRefection.Student.age
        //public int com.MyRefection.Student.id


        //4.获取单个公有的成员变量
        Field field3 = clazz.getField("id");//传递的参数是想要获取的成员变量的名称
        //输出一下
        System.out.println(field3);
        //输出结果
        //public int com.MyRefection.Student.id


        //5.获取单个私有的成员变量
        Field field4 = clazz.getDeclaredField("name");//传递的参数是想要获取的成员变量的名称
        //输出一下
        System.out.println(field4);
        //输出结果
        //private java.lang.String com.MyRefection.Student.name
    }
}

主要为大家讲解一下get和set方法：

get():

package com.MyRefection;

import java.lang.reflect.Field;

public class Main2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");


        //2.获取单个私有的成员变量
        Field name = clazz.getDeclaredField("name");//传递的参数是想要获取的成员变量的名称

        //3.使用这个name来获取成员变量的值
        //要想获得成员变量的值首先要创建对象
        Student student = new Student("张三", 16, 116);

        Object value = name.get(student);//这里传递的参数是创建的对象
        System.out.println(value);
        //执行结果：出错啦~~
    }
}

出错的原因是这个成员变量被private修饰，不能直接获取，要使用setAccessible(boolean flag)来取消权限的校验：

        //2.获取单个私有的成员变量
        Field name = clazz.getDeclaredField("name");//传递的参数是想要获取的成员变量的名称

        //3.使用这个name来获取成员变量的值
        //要想获得成员变量的值首先要创建对象
        Student student = new Student("张三", 16, 116);

        //4.取消访问权限的校验
        name.setAccessible(true);
        
        //5.获取成员变量的值
        Object value = name.get(student);//这里传递的参数是创建的对象
        System.out.println(value);
        //执行结果：张三

 

set():

package com.MyRefection;

import java.lang.reflect.Field;

public class Main2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.获取单个私有的成员变量
        Field name = clazz.getDeclaredField("name");//传递的参数是想要获取的成员变量的名称

        //3.使用这个name来获取成员变量的值
        //要想获得成员变量的值首先要创建对象
        Student student = new Student("张三", 16, 116);

        //4.同样取消访问权限的校验
        name.setAccessible(true);

        //5.使用这个name来修改成员变量的值：张三 -> 李四
        name.set(student, "李四");
        System.out.println(student.getName());
        //执行结果：李四
    }
}

3.4反射获取成员方法：

方法功能
getMethod(String name, Class... parameterTypes)获得该类某个公有的方法
getMethods()获得该类所有公有的方法
getDeclaredMethod(String name, Class... parameterTypes)获得该类某个方法
getDeclaredMethods()获得该类所有方法
Object invoke(Object obj, 0bject... args)运行方法

 

我们来看一下这个getMethods()可以获取到什么方法

package com.MyRefection;

import java.lang.reflect.Method;

public class Main3 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.创建Method[]数组来获取所有公有成员方法
        Method[] methods1 = clazz.getMethods();
        //遍历一下
        for (Method method : methods1) {
            System.out.println(method);
        }
        
    }
}

执行结果：

  从执行结果可以发现，除了有本身的成员方法外，还有继承自Object类的常用方法~~

同样前四个方法和之前的大相径庭，就不做详细讲解了（直接上代码）~~

package com.MyRefection;

import java.lang.reflect.Method;

public class Main3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //2.创建Method[]数组来获取所有公有成员方法
        Method[] methods1 = clazz.getMethods();

        //3.创建Method[]数组来获取所有成员方法（包括private/protected修饰的）
        Method[] methods2 = clazz.getDeclaredMethods();

        //4.获取单个公有成员方法
        Method method3 = clazz.getMethod("study", int.class);
        //第一个参数是方法名，第二个参数是要传入的参数的类型

        //5.获取单个公有成员方法
        Method method4 = clazz.getDeclaredMethod("eat", String.class);
        //第一个参数是方法名，第二个参数是要传入的参数的类型
    }
}

invoke方法

package com.MyRefection;

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

public class Main3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //1.获取.class字节码文件
        Class clazz = Class.forName("com.MyRefection.Student");

        //以私有方法为例：

        //2.获取单个公有成员方法
        Method method4 = clazz.getDeclaredMethod("eat", String.class);
        //第一个参数是方法名，第二个参数是要传入的参数的类型

        //3.创建Student类的对象
        Student student = new Student("张三", 16, 110);

        //4.取消访问权限的校验
        method4.setAccessible(true);

        //5.调用invoke方法
        method4.invoke(student, "汉堡包");
        //第一个参数为创建的对象，之后的参数是要调用方法的参数
        //执行结果：张三中午吃了汉堡包

    }
}

注意：同样的，如果要调用的方法是private/protected修饰的，也要取消访问权限的校验。

4.反射的利与弊：

反射的好处：

1.对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法。

2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力。

3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。

反射的坏处：

1. 使用反射会有效率问题，会导致程序效率降低。具体参考这里：(6条消息) 反射真的很耗时吗，反射 10 万次，耗时多久。_Q.E.D.的博客-CSDN博客

 2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。

小枫 ~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编程内功心法-编程算法题库
07-14
### 编程内功心法—编程算法题库解析 #### 一、力扣题集概览 **力扣题集**是针对编程面试而设计的一系列算法题目，旨在帮助学习者掌握各种算法技巧和数据结构的应用。这些题目涵盖了广泛的难度级别，从简单到复杂...
java-design-patterns-master.zip
08-08
JAVA设计模式一直是JAVA最考验内功的技术点。有句话说的很好，理解吃透设计模式概念如果是3分的难度，那么自己能写出来就是10分的难度，灵活应用在项目中就是100分的难度。java-design-patterns-master是github上...
JAVA属性无法反射_java - 反射 - 类，属性
weixin_34242698的博客
02-24 569
packagereflect;importjava.lang.reflect.Field;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.HashSet;public classReflectTest {public static voidmain(String[] args){try{System.out.pri...
java中的标记接口_内功心法 -- Java标记接口
weixin_29025911的博客
02-25 209
写在前面的话：读书破万卷，编码如有神--------------------------------------------------------------------这篇博客主要来谈谈"Java标记接口"的相关知识，主要内容包括：1. 概述2. Serializable3. Cloneable4. RandomAccess-----------------------------------...
架构师内功心法-----七大软件设计原则
hx1176406648的博客
03-12 179
七大软件设计原则Open-Closed Principle 开闭原则Dependence Inversion Principle 依赖倒置原则Simple Responsibility Principle 单一职责原则Interface Segregation Principle 接口隔离原则Law Of Demeter 迪米特法则Liskov Substitution Principle 里氏替换原则Composite&Aggregate Reuse Principle 合成复用原则问题作业参考
java内功修炼基础篇之---反射
xiangnan10的博客
05-22 618
引言：说来实在惭愧，工作四年，学的东西比较杂，以至于聊起天时，连很多Java的一些核心知识都说不清道不明，于是决心将Java的一些知识进行巩固一下如果有想在Java这条路上走的更远的朋友，建议看看这篇文章，可能对你会有一点小小的帮助  -- Java成神之路今天要来讲讲的就是Java的一个常用知识点 -- 反射反射在Java这门语言中是非常核心的一个概念，我们学习Java不可避免地就要学习反射这是...
JavaSE成神之路 - 使用IDE开发Java程序
java小白翻身
08-28 371
在上一节的学习中，我们用记事本开发了Java程序。可是实际上，我们不会真的使用记事本来开发的，而是用IDE来编写和运行Java程序。本文介绍用EditPlus来开发的步骤。
【JAVA秘籍心法篇-Spring】Spring XML解析源码详解
b379685397的博客
05-16 1046
【JAVA秘籍心法篇-Spring】Spring XML解析源码详解 所谓天下武功，无坚不摧，唯快不破。但有又太极拳法以快制慢，以柔克刚。武功外式有拳打脚踢，刀剑棍棒，又有内功易筋经九阳神功。所有外功招式配合内功心法才能大成，使其练成钢筋铁骨，无往不前。 大家好，我是王老狮，一个有思想有内涵的架构狮。在茫茫大千的程序宇宙，JAVA可以说是一个层级的位面，需要在这个位面脱颖而出，各种技术框架只是我们的一些外功招式，要想让自己位于不败之地，更要搭配招式的内功心法，了解底层实现原理。融会贯通，收为己用。成为一套完
JVM内功心法-类加载之类加载器
top_OMZ的博客
05-01 298
JVM内功心法-类加载之类加载器 由于类加载器是负责这些和系统运行有关的所有类的加载行为，而针对不同位置的类，JVM提供了三种类加载器： 1.启动类加载器（BootStrap ClassLoader） 最顶层的加载类，主要加载核心类库，也就是我们环境变量下面%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar和class等，还可以通过启动jvm时指定-Xbootclasspath和路径来改变Bootstrap ClassLoader的加载目录。 2.扩展类加载器
JVM内功心法-GC垃圾回收之GC垃圾回收过程
top_OMZ的博客
05-06 1123
JVM内功心法-GC垃圾回收之GC垃圾回收算法 GC 全称garbagecollection，垃圾回收。JAVA 为了屏蔽操作系统和平台之间的差异。选择的是采用 java 虚拟机来运行 java 应用。即 jvm。jvm 既然是一个虚拟机，必然涉及到内存的管理。对于内存中的对象需要进行管理。管理内存的一个很重要的事情就是垃圾回收。即将无用的对象清理掉，释放出内存来给应用继续使用。这个过程就是 GC，为什么要有 gc。因为如果内存只使用不回收的话，很快就会占满，导致应用后续运行出现问题。 Minor GC/
JVM内功心法-JVM内存模型之内存区域
top_OMZ的博客
05-02 759
程序计数器（Program Counter Register）：也叫PC寄存器，是一块较小的内存空间，它可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令、分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。 打开字节码文件可以看到一排排的index加上相应的指令，这个程序计数器就是用来记录这个即将执行的一个流程，当然这个顺序是可
JVM内功心法-JVM内存模型之内存溢出
top_OMZ的博客
05-04 454
JVM内功心法-JVM内存模型之内存溢出 jvm常用参数【想在本地更快复现一些问题就可以调节这些参数】： （1）-Xms20M 表示设置JVM启动内存的最小值为20M，必须以M为单位 （2）-Xmx20M 表示设置JVM启动内存的最大值为20M，必须以M为单位。将-Xmx和-Xms设置为一样可以避免JVM内存自动扩展。大的项目-Xmx和-Xms一般都要设置到10G、20G甚至还要高 （3）-verbose:gc 表示输出虚拟机中GC的详细情况 （4）-Xss128k 表示可以设置虚拟机栈的大小为12
JVM知识点总览-高级Java工程师面试必备
02-25
对于Java程序员来讲，spring全家桶几乎可以搞定一切，spring全家桶便是精妙的招式，jvm就是内功心法很重要的一块，线上出现性能问题，jvm调优更是不可回避的问题。因此JVM基础知识对于高级程序员的重要性不必言语，...
spring事务详细讲解-深入浅出
小电玩
09-08 431
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1429
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1358
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 456
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 695
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
"Java类的特性详解及this引用的使用
本文主要总结了《第讲-Java类的特性优秀文档.ppt》中的内容。该文档介绍了Java类和对象的概念，包括类的结构、对象生成方法、类的三大特性（封装、继承、多态）、打包的使用以及常用方法等。其中重点讲解了this引用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值