备案控制台
开发者社区 开发与运维 文章 正文

用Java实现JVM第六章《类和对象》

2022-01-12 104
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java虚拟机顾名思义，就是一台虚拟的机器，而字节码（bytecode）就是运行在这台虚拟机器上的机器码。我们已经知道，每一个类或者接口都会被Java编译器编译成一个class文件，类或接口的方法信息就放在class文件的method_info结构中。如果方法不是抽象的，也不是本地方法，方法的Java代码就会被编译器编译成字节码（即使方法是空的，编译器也会生成一条return语句），存在method_info结构的Code属性中。

1.jpg

案例介绍

本案例通过java代码实现jvm规范中指令集和解释器，完成后就可以开始执行1到100的加和计算。

Java虚拟机顾名思义，就是一台虚拟的机器，而字节码（bytecode）就是运行在这台虚拟机器上的机器码。我们已经知道，每一个类或者接口都会被Java编译器编译成一个class文件，类或接口的方法信息就放在class文件的method_info结构中。如果方法不是抽象的，也不是本地方法，方法的Java代码就会被编译器编译成字节码（即使方法是空的，编译器也会生成一条return语句），存在method_info结构的Code属性中。

环境准备

1、jdk 1.8.0

2、IntelliJ IDEA Community Edition 2018.3.1 x64

配置信息

1、调试配置

2.1、配置位置：Run/Debug Configurations -> program arguments

2.2、配置内容：-Xjre "C:\Program Files\Java\jdk1.8.0_161\jre" E:\itstack\git\istack-demo\itstack-demo-jvm\itstack-demo-jvm-06\target\test-classes\org\itstack\demo\test\HelloWorld

代码示例

itstack-demo-jvm-06
├── pom.xml
└── src
    └── main
    │    └── java
    │        └── org.itstack.demo.jvm
    │             ├── classfile
    │             │   ├── attributes   {BootstrapMethods/Code/ConstantValue...}
    │             │   ├── constantpool {CONSTANT_TAG_CLASS/CONSTANT_TAG_FIELDREF/CONSTANT_TAG_METHODREF...}
    │             │   ├── ClassFile.java
    │             │   ├── ClassReader.java
    │             │   └── MemberInfo.java
    │             ├── classpath
    │             │   ├── impl
    │             │   │   ├── CompositeEntry.java
    │             │   │   ├── DirEntry.java
    │             │   │   ├── WildcardEntry.java
    │             │   │   └── ZipEntry.java
    │             │   ├── Classpath.java
    │             │   └── Entry.java
    │             ├── classpath
    │             │   ├── base
    │             │   ├── comparisons
    │             │   ├── constants
    │             │   ├── control
    │             │   ├── conversions
    │             │   ├── extended
    │             │   ├── loads
    │             │   ├── math
    │             │   │   ├── add
    │             │   │   ├── and
    │             │   │   ├── div
    │             │   │   ├── iinc
    │             │   │   ├── mul
    │             │   │   ├── neg
    │             │   │   ├── or
    │             │   │   ├── rem
    │             │   │   ├── sh
    │             │   │   ├── sub
    │             │   │   └── xor
    │             │   ├── stack
    │             │   ├── store
    │             │   └── Factory
    │             ├── rtda
    │             │   ├── heap
    │             │   │   ├── constantpool
    │             │   │   ├── methodarea
    │             │   │   │   ├── Class.java    
    │             │   │   │   ├── ClassMember.java  
    │             │   │   │   ├── Field.java    
    │             │   │   │   ├── Method.java   
    │             │   │   │   ├── Object.java   
    │             │   │   │   └── Slots.java        
    │             │   │   └── ClassLoader.java  
    │             │   ├── Frame.java
    │             │   ├── JvmStack.java
    │             │   ├── LocalVars.java
    │             │   ├── OperandStack.java
    │             │   ├── Slot.java 
    │             │   └── Thread.java
    │             ├── Cmd.java
    │             ├── Interpret.java    
    │             └── Main.java
    └── test
         └── java
             └── org.itstack.demo.test
                 └── HelloWorld.java

Class.java

public class Class {
    public int accessFlags;
    public String name;
    public String superClassName;
    public String[] interfaceNames;
    public RunTimeConstantPool runTimeConstantPool;
    public Field[] fields;
    public Method[] methods;
    public ClassLoader loader;
    public Class superClass;
    public Class[] interfaces;
    public int instanceSlotCount;
    public int staticSlotCount;
    public Slots staticVars;
    public Class(ClassFile classFile) {
        this.accessFlags = classFile.accessFlags();
        this.name = classFile.className();
        this.superClassName = classFile.superClassName();
        this.interfaceNames = classFile.interfaceNames();
        this.runTimeConstantPool = new RunTimeConstantPool(this, classFile.constantPool());
        this.fields = new Field().newFields(this, classFile.fields());
        this.methods = new Method().newMethods(this, classFile.methods());
    }
    public boolean isPublic() {
        return 0 != (this.accessFlags & AccessFlags.ACC_PUBLIC);
    }
    public boolean isFinal() {
        return 0 != (this.accessFlags & AccessFlags.ACC_FINAL);
    }
    public boolean isSuper() {
        return 0 != (this.accessFlags & AccessFlags.ACC_SUPER);
    }
    public boolean isInterface() {
        return 0 != (this.accessFlags & AccessFlags.ACC_INTERFACE);
    }
    public boolean isAbstract() {
        return 0 != (this.accessFlags & AccessFlags.ACC_ABSTRACT);
    }
    public boolean isSynthetic() {
        return 0 != (this.accessFlags & AccessFlags.ACC_SYNTHETIC);
    }
    public boolean isAnnotation() {
        return 0 != (this.accessFlags & AccessFlags.ACC_ANNOTATION);
    }
    public boolean isEnum() {
        return 0 != (this.accessFlags & AccessFlags.ACC_ENUM);
    }
    public RunTimeConstantPool constantPool() {
        return this.runTimeConstantPool;
    }
    public Slots staticVars() {
        return this.staticVars;
    }
    public boolean isAccessibleTo(Class other) {
        return this.isPublic() || this.getPackageName().equals(other.getPackageName());
    }
    public String getPackageName() {
        int i = this.name.lastIndexOf("/");
        if (i >= 0) return this.name;
        return "";
    }
    public Method getMainMethod() {
        return this.getStaticMethod("main", "([Ljava/lang/String;)V");
    }
    private Method getStaticMethod(String name, String descriptor) {
        for (Method method : this.methods) {
            if (method.name.equals(name) && method.descriptor.equals(descriptor)) {
                return method;
            }
        }
        return null;
    }
    public Object newObject() {
        return new Object(this);
    }
    public boolean isAssignableFrom(Class other) {
        if (this == other) return true;
        if (!other.isInterface()) {
            return this.isSubClassOf(other);
        } else {
            return this.isImplements(other);
        }
    }
    public boolean isSubClassOf(Class other) {
        for (Class c = this.superClass; c != null; c = c.superClass) {
            if (c == other) {
                return true;
            }
        }
        return false;
    }
    private boolean isImplements(Class other) {
        for (Class c = this; c != null; c = c.superClass) {
            for (Class clazz : c.interfaces) {
                if (clazz == other || clazz.isSubInterfaceOf(other)) {
                    return true;
                }
            }
        }
        return false;
    }
    public boolean isSubInterfaceOf(Class iface) {
        for (Class superInterface : this.interfaces) {
            if (superInterface == iface || superInterface.isSubInterfaceOf(iface)) {
                return true;
            }
        }
        return false;
    }
}

ClassMember.java

public class ClassMember {
    public int accessFlags;
    public String name;
    public String descriptor;
    public Class clazz;
    public void copyMemberInfo(MemberInfo memberInfo) {
        this.accessFlags = memberInfo.accessFlags();
        this.name = memberInfo.name();
        this.descriptor = memberInfo.descriptor();
    }
    public boolean isPublic() {
        return 0 != (this.accessFlags & AccessFlags.ACC_PUBLIC);
    }
    public boolean isPrivate() {
        return 0 != (this.accessFlags & AccessFlags.ACC_PRIVATE);
    }
    public boolean isProtected() {
        return 0 != (this.accessFlags & AccessFlags.ACC_PROTECTED);
    }
    public boolean isStatic() {
        return 0 != (this.accessFlags & AccessFlags.ACC_STATIC);
    }
    public boolean isFinal() {
        return 0 != (this.accessFlags & AccessFlags.ACC_FINAL);
    }
    public boolean isSynthetic() {
        return 0 != (this.accessFlags & AccessFlags.ACC_SYNTHETIC);
    }
    public String name() {
        return this.name;
    }
    public String descriptor() {
        return this.descriptor;
    }
    public Class clazz() {
        return this.clazz;
    }
    public boolean isAccessibleTo(Class d) {
        if (this.isPublic()) {
            return true;
        }
        Class c = this.clazz;
        if (this.isProtected()) {
            return d == c || c.getPackageName().equals(d.getPackageName());
        }
        if (!this.isPrivate()) {
            return c.getPackageName().equals(d.getPackageName());
        }
        return d == c;
    }
}

Field.java

package org.itstack.demo.jvm.rtda.heap.methodarea;
import org.itstack.demo.jvm.classfile.MemberInfo;
import org.itstack.demo.jvm.classfile.attributes.impl.ConstantValueAttribute;
import org.itstack.demo.jvm.rtda.heap.constantpool.AccessFlags;
public class Field extends ClassMember {
    public int constValueIndex;
    public int slotId;
    public Field[] newFields(Class clazz, MemberInfo[] cfFields) {
        Field[] fields = new Field[cfFields.length];
        for (int i = 0; i < cfFields.length; i++) {
            fields[i] = new Field();
            fields[i].clazz = clazz;
            fields[i].copyMemberInfo(cfFields[i]);
            fields[i].copyAttributes(cfFields[i]);
        }
        return fields;
    }
    public void copyAttributes(MemberInfo cfField) {
        ConstantValueAttribute valAttr = cfField.ConstantValueAttribute();
        if (null != valAttr) {
            this.constValueIndex = valAttr.constantValueIdx();
        }
    }
    public boolean isVolatile() {
        return 0 != (this.accessFlags & AccessFlags.ACC_VOLATILE);
    }
    public boolean isTransient() {
        return 0 != (this.accessFlags & AccessFlags.ACC_TRANSIENT);
    }
    public boolean isEnum() {
        return 0 != (this.accessFlags & AccessFlags.ACC_ENUM);
    }
    public int constValueIndex() {
        return this.constValueIndex;
    }
    public int slotId() {
        return this.slotId;
    }
    public boolean isLongOrDouble() {
        return this.descriptor.equals("J") || this.descriptor.equals("D");
    }
}

Method.java

package org.itstack.demo.jvm.rtda.heap.methodarea;
import org.itstack.demo.jvm.classfile.MemberInfo;
import org.itstack.demo.jvm.classfile.attributes.impl.CodeAttribute;
import org.itstack.demo.jvm.rtda.heap.constantpool.AccessFlags;
public class Method extends ClassMember {
    public int maxStack;
    public int maxLocals;
    public byte[] code;
    public Method[] newMethods(Class clazz, MemberInfo[] cfMethods) {
        Method[] methods = new Method[cfMethods.length];
        for (int i = 0; i < cfMethods.length; i++) {
            methods[i] = new Method();
            methods[i].clazz = clazz;
            methods[i].copyMemberInfo(cfMethods[i]);
            methods[i].copyAttributes(cfMethods[i]);
        }
        return methods;
    }
    public void copyAttributes(MemberInfo cfMethod) {
        CodeAttribute codeAttr = cfMethod.codeAttribute();
        if (null != codeAttr) {
            this.maxStack = codeAttr.maxStack();
            this.maxLocals = codeAttr.maxLocals();
            this.code = codeAttr.data();
        }
    }
    public boolean isSynchronized() {
        return 0 != (this.accessFlags & AccessFlags.ACC_SYNCHRONIZED);
    }
    public boolean isBridge() {
        return 0 != (this.accessFlags & AccessFlags.ACC_BRIDGE);
    }
    public boolean isVarargs() {
        return 0 != (this.accessFlags & AccessFlags.ACC_VARARGS);
    }
    public boolean isNative() {
        return 0 != (this.accessFlags & AccessFlags.ACC_NATIVE);
    }
    public boolean isAbstract() {
        return 0 != (this.accessFlags & AccessFlags.ACC_ABSTRACT);
    }
    public boolean isStrict() {
        return 0 != (this.accessFlags & AccessFlags.ACC_STRICT);
    }
    public int maxStack() {
        return this.maxStack;
    }
    public int maxLocals() {
        return this.maxLocals;
    }
    public byte[] code() {
        return this.code;
    }
}

Object.java

package org.itstack.demo.jvm.rtda.heap.methodarea;
public class Object {
    Class clazz;
    Slots fields;
    public Object(Class clazz){
        this.clazz = clazz;
        this.fields = new Slots(clazz.instanceSlotCount);
    }
    public Class clazz(){
        return this.clazz;
    }
    public Slots fields(){
        return this.fields;
    }
    public boolean isInstanceOf(Class clazz){
        return clazz.isAssignableFrom(this.clazz);
    }
}

Slots.java

package org.itstack.demo.jvm.rtda.heap.methodarea;
import org.itstack.demo.jvm.rtda.Slot;
public class Slots {
    private Slot[] slots;
    public Slots(int slotCount) {
        if (slotCount > 0) {
            slots = new Slot[slotCount];
            for (int i = 0; i < slotCount; i++) {
                slots[i] = new Slot();
            }
        }
    }
    public void setInt(int idx, int val) {
        this.slots[idx].num = val;
    }
    public int getInt(int idx) {
        return this.slots[idx].num;
    }
    public void setFloat(int idx, float val) {
        this.slots[idx].num = (int) val;
    }
    public float getFloat(int idx) {
        return this.slots[idx].num;
    }
    public void setLong(int idx, long val) {
        this.slots[idx].num = (int) val;
        this.slots[idx + 1].num = (int) (val >> 32);
    }
    public long getLong(int idx) {
        int low = this.slots[idx].num;
        int high = this.slots[idx + 1].num;
        return (long) high << 32 | (long) low;
    }
    public void setDouble(int idx, double val) {
        this.setLong(idx, (long) val);
    }
    public Double getDouble(int idx) {
        return (double) this.getLong(idx);
    }
    public void setRef(int idx, Object ref) {
        this.slots[idx].ref = ref;
    }
    public Object getRef(int idx){
        return this.slots[idx].ref;
    }
}

测试结果

{可以看到已经输出；5050}

"C:\Program Files\Java\jdk1.8.0_161\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2018.3.1\lib\idea_rt.jar=61887:D:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2018.3.1\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_161\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\rt.jar;E:\itstack\git\istack-demo\itstack-demo-jvm\itstack-demo-jvm-05\target\classes;D:\Program Files (x86)\apache-maven-2.2.1\repository\com\beust\jcommander\1.72\jcommander-1.72.jar;D:\Program Files (x86)\apache-maven-2.2.1\repository\org\projectlombok\lombok\1.18.0\lombok-1.18.0.jar;D:\Program Files (x86)\apache-maven-2.2.1\repository\com\alibaba\fastjson\1.2.40\fastjson-1.2.40.jar" org.itstack.demo.jvm.Main -Xjre "C:\Program Files\Java\jdk1.8.0_161\jre" E:\itstack\git\istack-demo\itstack-demo-jvm\itstack-demo-jvm-05\target\test-classes\org\itstack\demo\test\HelloWorld
classpath:org.itstack.demo.jvm.classpath.Classpath@4bf558aa class:E:\itstack\git\istack-demo\itstack-demo-jvm\itstack-demo-jvm-05\target\test-classes\org\itstack\demo\test\HelloWorld args:null
寄存器(指令)：0x03 -> ICONST_0 => 局部变量表：[{"num":0},{"num":0}] 操作数栈：[{"num":0},{"num":0}]
寄存器(指令)：0x3c -> ISTORE_1 => 局部变量表：[{"num":0},{"num":0}] 操作数栈：[{"num":0},{"num":0}]
寄存器(指令)：0x04 -> ICONST_1 => 局部变量表：[{"num":0},{"num":0}] 操作数栈：[{"num":0},{"num":0}]
寄存器(指令)：0x3d -> ISTORE_2 => 局部变量表：[{"num":1},{"num":0}] 操作数栈：[{"num":1},{"num":0}]
寄存器(指令)：0x1c -> ILOAD_2 => 局部变量表：[{"num":1},{"num":0}] 操作数栈：[{"num":1},{"num":0}]
寄存器(指令)：0x10 -> BIPUSH => 局部变量表：[{"num":1},{"num":0}] 操作数栈：[{"num":1},{"num":0}]
寄存器(指令)：0xa3 -> IF_ICMPGT => 局部变量表：[{"num":1},{"num":100}] 操作数栈：[{"num":1},{"num":100}]
寄存器(指令)：0x1b -> ILOAD_1 => 局部变量表：[{"num":1},{"num":100}] 操作数栈：[{"num":1},{"num":100}]
寄存器(指令)：0x1c -> ILOAD_2 => 局部变量表：[{"num":0},{"num":100}] 操作数栈：[{"num":0},{"num":100}]
... ...
寄存器(指令)：0x60 -> IADD => 局部变量表：[{"num":4950},{"num":100}] 操作数栈：[{"num":4950},{"num":100}]
寄存器(指令)：0x3c -> ISTORE_1 => 局部变量表：[{"num":5050},{"num":100}] 操作数栈：[{"num":5050},{"num":100}]
寄存器(指令)：0x84 -> IINC => 局部变量表：[{"num":5050},{"num":100}] 操作数栈：[{"num":5050},{"num":100}]
寄存器(指令)：0xa7 -> GOTO => 局部变量表：[{"num":5050},{"num":100}] 操作数栈：[{"num":5050},{"num":100}]
寄存器(指令)：0x1c -> ILOAD_2 => 局部变量表：[{"num":5050},{"num":100}] 操作数栈：[{"num":5050},{"num":100}]
寄存器(指令)：0x10 -> BIPUSH => 局部变量表：[{"num":101},{"num":100}] 操作数栈：[{"num":101},{"num":100}]
寄存器(指令)：0xa3 -> IF_ICMPGT => 局部变量表：[{"num":101},{"num":100}] 操作数栈：[{"num":101},{"num":100}]
5050
寄存器(指令)：0xb1 -> RETURN => 局部变量表：[{"num":101},{"num":5050}] 操作数栈：[{"num":101},{"num":5050}]
Exception in thread "main" java.lang.RuntimeException: jvm stack is empty!
    at org.itstack.demo.jvm.rtda.JvmStack.pop(JvmStack.java:33)
文章标签：
Java
开发工具
git
编译器
关键词：
JVM java
Java JVM
Java类和对象
Java实现
Java实现JVM
小傅哥
目录
相关文章
请看我回答~
|
12天前
|
存储 Java
深入理解Java虚拟机：JVM内存模型
【4月更文挑战第30天】本文将详细解析Java虚拟机（JVM）的内存模型，包括堆、栈、方法区等部分，并探讨它们在Java程序运行过程中的作用。通过对JVM内存模型的深入理解，可以帮助我们更好地编写高效的Java代码，避免内存溢出等问题。
请看我回答~
30 0
菜菜的后端私房菜
|
3天前
|
Java 索引
深入浅出JVM（五）之Java中方法调用
深入浅出JVM（五）之Java中方法调用
菜菜的后端私房菜
5 0
长梦
|
5天前
|
Java 编译器 对象存储
java一分钟之Java入门：认识JDK与JVM
【5月更文挑战第7天】本文介绍了Java编程的基础——JDK和JVM。JDK是包含编译器、运行时环境、类库等的开发工具包，而JVM是Java平台的核心，负责执行字节码并实现跨平台运行。常见问题包括版本不匹配、环境变量配置错误、内存溢出和线程死锁。解决办法包括选择合适JDK版本、正确配置环境变量、调整JVM内存参数和避免线程死锁。通过代码示例展示了JVM内存管理和基本Java程序结构，帮助初学者更好地理解JDK和JVM在Java编程中的作用。
长梦
18 0
橘子-青衫
|
5天前
|
存储 监控 安全
JVM工作原理与实战(十六)：运行时数据区-Java虚拟机栈
JVM作为Java程序的运行环境，其负责解释和执行字节码，管理内存，确保安全，支持多线程和提供性能监控工具，以及确保程序的跨平台运行。本文主要介绍了运行时数据区、Java虚拟机栈等内容。
橘子-青衫
11 0
码农烧烤
|
6天前
|
存储 缓存 安全
【 Java中String源码分析（JVM视角你不来看看？】
【 Java中String源码分析（JVM视角你不来看看？】
码农烧烤
13 0
屿小夏
|
13天前
|
存储 机器学习/深度学习 Java
【Java探索之旅】数组使用 初探JVM内存布局
【Java探索之旅】数组使用 初探JVM内存布局
屿小夏
26 0
屿小夏
|
13天前
|
小程序 Java 程序员
【Java探索之旅】我与Java的初相识(二)：程序结构与运行关系和JDK,JRE,JVM的关系
【Java探索之旅】我与Java的初相识(二)：程序结构与运行关系和JDK,JRE,JVM的关系
屿小夏
28 0
程序员三木
|
18天前
|
Java
[JVM] Java类的加载过程
[JVM] Java类的加载过程
程序员三木
8 0
[JVM] Java类的加载过程
程序员三木
|
18天前
|
存储 缓存 Java
[JVM] 浅谈JMM（Java 内存模型）
[JVM] 浅谈JMM（Java 内存模型）
程序员三木
26 0
L&ecirc;v&iuml;
|
18天前
|
缓存 监控 Java
Java从入门到精通：3.3.1性能优化与调优——学习Java的性能优化技巧，如JVM调优
Java从入门到精通：3.3.1性能优化与调优——学习Java的性能优化技巧，如JVM调优
L&ecirc;v&iuml;
20 0

热门文章

最新文章

  • 1
    JVM Profiler IOProfiler
  • 2
    JVM加载对象时内存加载顺序
  • 3
    全面认识Eclipse中JVM内存设置(转)
  • 4
    《深入解析Android 虚拟机》——第2章，第2.2节Java虚拟机概述
  • 5
    jvm优化
  • 6
    感觉JVM的默认异常处理不够好，既然不好那我们就自己来处理异常呗！那么如何自己处理异常呢？
  • 7
    深入理解JVM(七)——Class文件结构
  • 8
    JVM 语言的兴衰 【The Rise and Fall of JVM Languages】
  • 9
    JVM、JRE、JDK 原来是这种关系
  • 10
    JVM11_System.gc、内存溢出、内存泄漏、STW、安全点、安全区域、强软弱虚引用（二）
  • 1
    [Java基础]——类的生命周期
    16
  • 2
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    28
  • 3
    【java进阶】Java中线程的实现方式
    23
  • 4
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    20
  • 5
    [java进阶]——方法引用改写Lambda表达式
    35
  • 6
    深入理解 Java 多线程、Lambda 表达式及线程安全最佳实践
    127
  • 7
    java base64转doc文件
    36
  • 8
    [JavaWeb]——过滤器filter与拦截器Interceptor的使用、执行过程、区别
    47
  • 9
    Java中的异常语法知识居然这么好玩！后悔没有早点学习
    38
  • 10
    Java必刷入门递归题×5（内附详细递归解析图）
    26

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 面向对象-1：类的定义
  • 语言入门-2：基本类型
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Elasticsearch Java API Client 开发
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）