1.1Java-JDK、JVM、数据类型等基础理论

怼烎@ 2024-04-03 12:34 65阅读 0赞

**目录**

1.1.1JDK与JRE

1.1.2JVM概述

1.1.2.1JVM执行程序的过程

1.1.2.2JVM的生命周期

1.1.2.3守护线程和非守护线程

1.1.2.4JVM内存模型

1.1.3 new关键字

1.1.4 数据类型

1.1.4.1基本数据类型

1.1.4.1.1分类

1.1.4.1.2基本数据类型的底层原理

1.1.4.1.3包装类

1.1.4.2引用数据类型

1.1.4.3 两种数据类型底层原理

1.1.4.3.1 两个问题

1.1.4.3.2 两种类型的底层实现

1.1.4.4 类型转换

1.1.5 标识符

1.1.6像素与分辨率

--------------------

## 1.1.1JDK与JRE ##

JDK：java开发工具

JDK包含Java运行环境，Java基础类，Java开发工具

JRE：java运行环境 (Java Runtime Environment)

包含了java虚拟机，java基础类库。java运行软件环境，还有所有的Java类库的class文件，都在lib目录下，并且都打包成了jar。

位置：Windows上的虚拟机：<JRE安装目录>/bin/client中的jvm.dll。

JVM：java虚拟机

## 1.1.2JVM概述 ##

由于JVM涉及底层，属于高级范畴，深入探讨JVM在本章节的最后详细讲解。

JVM包含一套字节码指令集，一组寄存器，一个栈，一个垃圾回收堆和一个存储方法域。

### 1.1.2.1JVM执行程序的过程 ###

1.  加载.class文件
2.  管理并分配内存
3.  执行垃圾收集 JRE（java运行时环境）由JVM构造的java程序的运行环，也是Java程序运行的环境，但是他同时一个操作系统的一个应用程序一个进程

操作系统装入JVM是通过jdk中Java.exe来完成， 通过下面4步来完成JVM环境：

1.  创建JVM装载环境和配置
2.  装载JVM.dll
3.  初始化JVM.dll并挂接到JNIENV(JNI调用接口)实例
4.  调用JNIEnv实例装载并处理class类。

### 1.1.2.2JVM的生命周期 ###

JVM实例对应了一个独立运行的java程序，它是进程级别

1.  启动。启动一个Java程序时，一个JVM实例就产生了，任何一个拥有public static void
2.  main(String\[\] args)函数的class都可以作为JVM实例运行的起点。
3.  运行。main()作为该程序初始线程的起点，任何其他线程均由该线程启动。JVM内部有两种线程：守护线程和非守护线程，main()属于非守护线程，守护线程通常由JVM自己使用，java程序也可以表明自己创建的线程是守护线程
4.  消亡。当程序中的所有非守护线程都终止时，JVM才退出；若安全管理器允许，程序也可以使用Runtime类或者System.exit()来退出

JVM执行引擎实例则对应了属于用户运行程序的线程它是线程级别的

### 1.1.2.3守护线程和非守护线程 ###

java中两类线程：User Thread（用户线程/非守护线程）和Daemon Thread（守护线程）。

任何一个守护线程都会守护整个JVM中所有的非守护线程，只要当前JVM中还有任何一个非守护线程没有结束，守护线程就全部工作，当所有的非守护线程全部结束后，守护线程也会随着JVM一同结束。守护线程最典型的应用就是GC（垃圾回收器）。

需要注意的地方：

thread.setDaemon(true)方法必须在thread.start()之前设置，否则会报IllegalThreadStateException异常，不能把正在运行的常规线程设置为守护线程。  
在守护线程中产生的新线程也是守护线程。  
不是所有应用都可以分配守护线程来进行服务，比如读写操作或是计算逻辑等。因为如果非守护线程都结束了，但是读写或计算逻辑没有完成，守护线程也会停止。  
判断线程是否为守护线程的方法是：isDaemon()，返回true为守护线程，返回false为非守护线程

### 1.1.2.4JVM内存模型 ###

（1）java代码具体执行过程如下图

![32086218d2b24fcebbca470667a870aa.png][]

（2）运行时数据区，即jvm内存结构图如下图

JVM为每个线程都分配一个堆栈。堆栈以帧为单位保存线程的状态。jvm对堆栈只进行两种操作：以帧为单位的压栈和出栈操作。

栈帧(Stack Frame)是用于支持虚拟机进行方法调用和方法执行的数据结构。栈帧存储了方法的局部变量表，操作数栈，动态连接和方法返回地址等信息。第一个方法从调用开始到执行完成，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

每一个栈帧都包括了局部变量表，操作数栈，动态连接，方法返回地址和一些额外的附加信息。

一个线程中的方法调用链可能会很长，很多方法都同时处理执行状态。对于执行引擎来讲，活动线程中，只有虚拟机栈顶的栈帧才是有效的，称为当前栈帧 (Current Stack Frame)，这个栈帧所关联的方法称为当前方法(Current Method)。执行引用所运行的所有字节码指令都只针对当前栈帧进行操作。栈帧的概念结构如下图所示：

![4899313a94d84d51b9e8ae8b0756d9cd.png][]

（3）运行时数据区存储了哪些数据？

**a) 程序计数器(PC寄存器)**

由于在JVM中，多线程是通过线程轮流切换来获得CPU执行时间的，因此，在任一具体时刻，一个CPU的内核只会执行一条线程中的指令，

因此，为了能够使得每个线程都在线程切换后能够恢复在切换之前的程序执行位置，每个线程都需要有自己独立的程序计数器，并且不能互相被干扰，

否则就会影响到程序的正常执行次序。因此，可以这么说，程序计数器是每个线程所私有的。由于程序计数器中存储的数据所占空间的大小不会随程序的执行而发生改变，

因此，对于程序计数器是不会发生内存溢出现象(OutOfMemory)的。

**b) java栈**

Java栈中存放的是一个个的栈帧，每个栈帧对应一个被调用的方法，在栈帧中包括局部变量表(Local Variables)、操作数栈(Operand Stack)、

指向当前方法所属的类的运行时常量池（运行时常量池的概念在方法区部分会谈到）的引用(Reference to runtime constant pool)、方法返回地址(Return Address)和一些额外的附加信息。当线程执行一个方法时，就会随之创建一个对应的栈帧，并将建立的栈帧压栈。当方法执行完毕之后，便会将栈帧出栈。

**c）本地方法栈**

本地方法栈与Java栈的作用和原理非常相似。区别只不过是Java栈是为执行Java方法服务的，而本地方法栈则是为执行本地方法（Native Method）服务的

**d）堆**

Java中的堆是用来存储对象本身的以及数组（数组引用是存放在Java栈中的）。堆是被所有线程共享的，在JVM中只有一个堆。

**e）方法区**

与堆一样，是被线程共享的区域。在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

在Class文件中除了类的字段、方法、接口等描述信息外，还有一项信息是常量池，用来存储编译期间生成的字面量和符号引用。

在方法区中有一个非常重要的部分就是运行时常量池，它是每一个类或接口的常量池的运行时表示形式，在类和接口被加载到JVM后，对应的运行时常量池就被创建出来。当然并非Class文件常量池中的内容才能进入运行时常量池，在运行期间也可将新的常量放入运行时常量池中。

### 1.1.3 new关键字 ###

Java 中 new 操作会在内存中开辟新的空间，这个内存空间分配在内存的堆区。

堆是用来存放由 new 创建的对象和数组，即动态申请的内存都存放在堆区。

栈是用来存放在方法中定义的一些基本类型的变量和对象的引用变量。

### 1.1.4 数据类型 ###

Java语言中的数据类型分为两大类，分别是基本类型和引用类型。

// 1个字节=8位/bit(比特)

### 1.1.4.1**基本数据类型** ###

#### 1.1.4.1.1分类 ####

四类、八种

<table style="width:644px;"> 
 <tbody> 
  <tr> 
   <td></td> 
   <td></td> 
   <td>数据范围</td> 
   <td>内存空间</td> 
   <td style="width:174px;"></td> 
  </tr> 
  <tr> 
   <td colspan="1">整数</td> 
   <td>byte</td> 
   <td>-128~127</td> 
   <td>1字节</td> 
   <td style="width:174px;"></td> 
  </tr> 
  <tr> 
   <td>Short</td> 
   <td> <p>-32768~32767</p> </td> 
   <td>2字节</td> 
   <td style="width:174px;"></td> 
  </tr> 
  <tr> 
   <td>Int</td> 
   <td>-2^31~2^31-1</td> 
   <td>4字节</td> 
   <td style="width:174px;"></td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>-2^63~2^63-1</td> 
   <td>8字节</td> 
   <td style="width:174px;"></td> 
  </tr> 
  <tr> 
   <td colspan="1">浮点数</td> 
   <td>Float</td> 
   <td>-3.4* 10^38~ 3.4*10^38</td> 
   <td>4字节</td> 
   <td style="width:174px;"></td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>-1.79*10^308 ~ 1.79 * 10^308</td> 
   <td>8字节</td> 
   <td style="width:174px;"></td> 
  </tr> 
  <tr> 
   <td>字符</td> 
   <td>char</td> 
   <td>除了\ 都可以当成一个字符</td> 
   <td>不确定</td> 
   <td style="width:174px;"></td> 
  </tr> 
  <tr> 
   <td>布尔</td> 
   <td>boolean</td> 
   <td>true或者false</td> 
   <td>1字节</td> 
   <td style="width:174px;"></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td style="width:174px;"></td> 
  </tr> 
 </tbody> 
</table>

#### 1.1.4.1.2基本数据类型的底层原理 ####

![0778b727b9fb40ac925976186a19f8ff.png][]

**常量池**是为了避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。

1.  节省内存空间：常量池中所有相同的字符串常量被合并，只占用一个空间。
2.  节省运行时间：比较字符串时，== 比equals()快。对于两个引用变量，只用==判断引用是否相等，也就可以判断实际值是否相等

> JDK1.6及以前，常量池在方法区，这时的方法区也叫做永久代；  
> JDK1.7的时候，方法区合并到了堆内存中，这时的常量池也可以说是在堆内存中；  
> JDK1.8及以后，方法区又从堆内存中剥离出来了，但实现方式与之前的永久代不同，这时的方法区被叫做元空间，常量池就存储在元空间。

#### 1.1.4.1.3包装类 ####

由于八种基本数据类型不是面向对象的，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八种基本数据类型对应的类统称为包装类(Wrapper Class)，包装类均位于java.lang包。

**包装类和基本数据类型的转换**

<table style="width:400px;"> 
 <tbody> 
  <tr> 
   <td style="width:239px;">基本数据类型</td> 
   <td style="width:259px;">包装类</td> 
  </tr> 
  <tr> 
   <td style="width:239px;">boolean</td> 
   <td style="width:259px;">Boolean</td> 
  </tr> 
  <tr> 
   <td style="width:239px;">char</td> 
   <td style="width:259px;">Character</td> 
  </tr> 
  <tr> 
   <td style="width:239px;">byte</td> 
   <td style="width:259px;">Byte</td> 
  </tr> 
  <tr> 
   <td style="width:239px;">short</td> 
   <td style="width:259px;">Short</td> 
  </tr> 
  <tr> 
   <td style="width:239px;">long</td> 
   <td style="width:259px;">Long</td> 
  </tr> 
  <tr> 
   <td style="width:239px;">int</td> 
   <td style="width:259px;">Integer</td> 
  </tr> 
  <tr> 
   <td style="width:239px;">float</td> 
   <td style="width:259px;">Float</td> 
  </tr> 
  <tr> 
   <td style="width:239px;">double</td> 
   <td style="width:259px;">Double</td> 
  </tr> 
 </tbody> 
</table>

**自动拆装箱**

JDK1.5后，引入了自动拆装箱，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行  
自动装箱：将 基本数据类型 封装为对象类型。  
自动拆箱：将对象重新转化为基本数据类型。

Integer i=5;  //编译器执行了Integer i = Integer.valueOf(5)
        int i2=i;  //自动拆箱，实际上执行了 int i2 = i.intValue()
        System.out.println(i2);

### 1.1.4.2**引用数据类型** ###

1.  类class
2.  接口类型 interface
3.  数组类型 list
4.  枚举类型
5.  注解类型
6.  字符串型（String，String的衍生类，如StringBuilder等）

该数据类型在创建的时候，会先在堆内存中分配一块空间，存储对象的具体信息，然后在栈中存储该对象的地址信息。

==：表示地址值的比较  
.equals：表示内容的比较

引用数据类型的底层原理

![c9de3e96e5d34970b90703bf4cea7545.png][]

### 1.1.4.3 两种数据类型底层原理 ###

#### 1.1.4.3.1 两个问题 ####

首先先思考几个问题，

（这里涉及到JVM底层结构，建议初学者或对JVM底层不熟悉的，暂时不用深究，跟随本系列慢慢学，到1.23章节结束，那时对JVM有了很深刻的了解后再回过头看就会很容易理解）

**1.为什么java有基本数据类型和引用数据类型之分？**

所有的一切离不开一个要求——性能。我们从性能入手分析这个问题。

我们先做个实验：

定义一个类

public class MyClass {
       private int i=1;
    
        public int getI() {
            return i;
        }
    
        public void setI(int i) {
            this.i = i;
        }
    }

定义主函数

public class Test {
        public static void main(String[] args) {
            long start = System.nanoTime();
            int i=1;
         //     MyClass myClass = new MyClass();
            long end = System.nanoTime();
           System.out.println(i+"运行时间："+(end-start));
         //   System.out.println(myClass.getI()+"运行时间："+(end-start));

我们分别打印出通过基本类型获取i和通过引用类型获取i的时间，注意时间单位是纳秒。

（1ns=10负9次方s）

输出结果

基本数据类型所需时间：200ns

![61d52d3328364b1a9049e71bff9dc9be.png][]

引用类型所需时间 :871900ns

![14ac5053a98d4f32aed7a4f1e1dd2b02.png][]

这里相差了1000倍，而且我们的MyClass里面只定义了一个简单的int i。

如果java没有分基本数据类型和引用数据类型之分，全把数据类型设为引用的话，那简直"卡成ppt"。

如果全是基本数据类型，这个更不可能，为什么？

**1.**有些对象的大小是动态的，不是你想指定就能指定，比如刚开始定义好的类，我后续想要增加或删除一些代码，那么你需要手动指定内存，内存的回收也是需要自己手动的。java的设定之一就是为了消除C++的指针。而且把内存暴露是很危险的，可以参考c++。

**2.**不符合Java 的设计思想。

1.  首先堆栈之间内存大小的原因。
2.  其次也是最关键的一点，就是引用指向问题。把对象放入一个每个线程自己单独持有的栈中，原来只需要在堆空间上new一次，然后通过引用来指向，可以实现一次new 多次引用。现在却变成了每个栈如果要用必须单独去new的设计。对内存空间造成极大的浪费。

> **补充**：编程之中，线程之间的通信机制有两种，共享内存(Java)和消息传递(Go)。
> 
> 栈是线程私有的内存区域，如果对象放在栈上就线程之间就无法共享数据从而达到线程之间的消息传递，因此对象要放在线程共享的堆上。

**简单总结**

1.  栈空间小且连续，往往会被放在缓存,存取速度比较快；
2.  在堆中则需要new，对基本数据类型来说空间浪费率太高；
3.  程序中需要处理许多数据，对于不同数据都有其对应的数据类型，其实就是在内存中开辟一个存储空间来存放数据，不同数据所开辟的内存大小也会不一样。

**2.为什么选这八种类型为基本数据类型，而不选择其他的类型作为基本数据类型**？

CPU可以直接进行运算的类型

#### 1.1.4.3.2 两种类型的底层实现 ####

**基本数据类型**

由于栈的特性是先进后出（First-In-Last-Out）。所以当程序执行到int a=1;时，先在栈中开辟出空间存入1，执行完int b=2;后，也在栈中开辟出空间存入2，当执行到a=b，(把b赋值给a)，a的内存空间里的数据修改为2。

![5a5ad5803e0f45e9a0a6a355d75fb44a.png][]

**引用数据类型**

![18ac57e9b14544af8b1456f2c1c30f75.png][]

> Student stu =new Student(1,3);
> 
> 等号左边是变量，类型是Student
> 
> 等号右边是真正的对象。

引用类型，堆中存放的真正的对象本身，左边栈中存放的变量,变量里面存的是对象在堆中的首地址（开始地址）

### 1.1.4.4 类型转换 ###

类型从小到大：

![1fb95417fa7649a78e36807ac43629c9.png][]

JAVA基本类型之间转换的两种方式：

自动类型转换和强制类型转换

自动（隐式）类型转换：从小类型到大类型，不需要强制转换符。

强制转换：数据类型相对较高的数据或变量赋值给数据类型相对较低的转换。

## 1.1.5 标识符 ##

标识符：就是给类，方法，变量等取的名字

**规则：**

**硬性要求：**

*  由数字、字母、下划线（\_）和美元符（$）组成
 *  不能以数字开头
 *  不能关键字
 *  区分大小写

**软性要求：**

*  方法，变量：
    
     *  一个就小写：name
     *  多个就第一个小写:firstName
 *  类名：
    
     *  标识符是一个单词，首字母大写 Student
     *  标识符是多个单词，每个单词的首字母大写 GoodStudet

### 1.1.6像素与分辨率 ###

**分辨率：**

2k屏的最大分辨率有1920 x1080 1998x1080 2048x1080 2048x858

4k屏的最大分辨率有 3840x2160 3996x2160 4096x2160 4096x1716

**像素：**

1920x1080，宽1920个像素，高1080个像素

[32086218d2b24fcebbca470667a870aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/54ccbdb400bf4238ad03131b2b4a3471.png
[4899313a94d84d51b9e8ae8b0756d9cd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/4cedf4653fc842c98eacef091f0cdaba.png
[0778b727b9fb40ac925976186a19f8ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/b29f3bdad5ff4e7b9f9871f59069d804.png
[c9de3e96e5d34970b90703bf4cea7545.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/af63a5eba17e4f3c9cab4167114037b6.png
[61d52d3328364b1a9049e71bff9dc9be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/b7ea0fc121e54f779651267910bff12e.png
[14ac5053a98d4f32aed7a4f1e1dd2b02.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/e7d1a29808ca4f119ce783d768f0bc26.png
[5a5ad5803e0f45e9a0a6a355d75fb44a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/9f0bdfeed9834aa18e51ff3dc71bf413.png
[18ac57e9b14544af8b1456f2c1c30f75.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/ce025fe4c4ac49e793f2f30a696b8d71.png
[1fb95417fa7649a78e36807ac43629c9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/f8f508e81d264510aa2f2e94ee64376d.png