1 JRE和JDK

1.1 JRE(==J==ava ==R==untime ==E==nvironment)

是Java程序运行时的环境，==包含JVM==和运行时所需要的核心类库。

我们想要运行一个已有的Java程序，那么只需要安装JRE即可。

1.2 JDK(==J==ava ==D==evelopment ==K==it)

是Java程序开发工具包，==包含JRE==和开发人员所需要使用的工具。

其中的开发工具：编译工具(==javac.exe==)和运行工具(==java.exe==)。

1.3 JDK、JRE和JVM的关系

1.4 JDK的安装目录

其余文件为说明性文档。

2 基础语法

2.1 注释

2.1.1 注释概述

1. 注释是在程序指定位置添加的说明性问题。
2. 注释不参与程序运行，仅起到说明作用。

2.1.2 注释分类

1. 单行注释
   • 格式：// 注释信息
2. 多行注释
   • 格式：/ 注释信息 /
3. 文档注释
   • 格式：/* 注释信息 /

2.2 关键字

2.2.1 关键字概述

关键字：就是被Java语言赋予了特定含义的单词。

2.2.2 关键字的特点

• 关键字的字母全部小写。
• 常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观。

2.3 常量

2.3.1 常量概述

常量：在程序运行过程中，其值不可以发生改变的量。

2.3.2 常量分类

2.4 数据类型

2.4.1 计算机存储单元

我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫"位(bit)"，我们又称之为"比特位"，通常用小写的字母"b"表示。而计算机中最小的存储单元叫"字节(byte)"，通常用大写字母"B"表示，字节是由连续的8个位组成。

2.4.2 数据类型

Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的==内存空间==，所以他们表示的==数据大小==也是不一样的。

![image-20200920142842809]

2.4.3 数据类型内存占用和取值范围

2.5 变量

2.5.1 变量概述

变量：在程序运行过程中，其值可以发生改变的量。从本质上讲，变量是内存中一小块区域。

2.5.2 变量的定义

格式：数据类型 变量名 = 变量值;

2.5.3 变量的使用

取值和修改值

• 取值格式：变量名

• 修改值格式：变量名 = 变量值;

2.5.4 变量的注意事项

1. 在同一个方法中，不可重复定义变量
2. 变量未赋值不可使用

3. 定义long类型，为防止整数过大，变量值最后面加上L，例如: long a = 100000000L;

4. 浮点数默认是double类型，为了防止类型不兼容，定义float类型，在变量值最后面加上F，例如: float a = 13.14F;

2.6 标识符

2.6.1 标识符概述

标识符：就是给类、方法、变量等起名字的符号。

2.6.2 标识符定义的规则

• 由数字、字母、下划线、和美元符组成
• 不能以数字开头
• 不能是关键字
• 区分大小写

2.6.3 常见命名约定

小驼峰命名法：==方法、变量==

• 约定1：标识符是一个单词的时候，首字母小写
• 约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其余单词首字母大写

大驼峰命名法：==类==

• 约定1：标识符是一个单词的时候，首字母大写

• 约定2：标识符由多个单词组成的时候，每个单词首字母大写

2.7 类型转换

2.7.1 类型转换分类

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

2.7.2 自动类型转换

把一个表示数据==范围小的数值==或者==变量==赋值给另一个表示数据==范围大的变量==

2.7.3 强制类型转换

把一个表示==范围大的数值==或者==变量==赋值给另外一个表示数据==范围小的变量==

• 格式：目标数据类型 变量名 = (目标数据类型)值或者变量;

3 运算符

3.1 算术运算符

3.1.1 运算符和表达式

• 运算符：对常量或者变量进行操作的==符号==

• 表达式：用==运算符==把常量或者变量连接起来==符合java语法的式子==就可以成为表达式。

  不同运算符连接起来的表达式体现的是不同类型的表达式。

算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则:

• byte类型、short类型和char类型将被提升到int类型。
• 整个表达式的类型自动提升到表达式中最高等级操作数同样的类型。
• 等级顺序: byte, short, char -> int -> long -> float -> double

3.2 赋值运算符

• 符号：=

• 作用：赋值

• 扩展赋值运算符：+=、*=、-=、/=、%=

注意：扩展的赋值运算符==隐含==了强制类型转换

3.3 自增自减运算符

3.4 关系运算符

3.5 逻辑运算符

3.5.1 逻辑运算符概述

逻辑运算符，是用来==连接关系表达式==的运算符，当然逻辑运算符也可以直接==连接布尔类型的变量或常量==

3.5.2 逻辑运算符

3.5.3 短路逻辑运算符

==注意事项:==

• 逻辑与&，无论左边真假，右边都要执行。
  短路与&&，如果左边为真，右边执行，如果左边为假，右边不执行。

• 逻辑或|，无论左边真假，右边都要执行。
  短路或||，如果左边为假，右边执行，如果左边为真，右边不执行。

3.6 三元运算符

3.6.1 三元运算符

• 格式：关系表达式 ? 表达式1 : 表达式2;
• 计算规则:
  • 首先计算关系表达式的值
  • 如果值为true，表达式1的值就是运算结果
  • 如果值为false，表达式2的值就是运算结果

4 数据输入

1.1 Scanner使用的基本步骤

1. 导包

import java.util.Scanner;
// 导包的动作必须出现在类定义的上边

2. 创建对象

Scanner sc = new Scanner(System.in);
// 上面这个格式里面，只有sc是变量名，可以变，其它的都不允许变

3. 接收参数

int i = sc.next();
// 上面这个格式里面，只有i是变量名，可以变，其它的都不允许变

5 分支语句

5.1 流程控制

5.1.1 流程控制语句分类

• 顺序结构
• 分支结构(if,switch)
• 循环结构(for,while,do...while)

5.1.2 顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

5.2 if语句

5.2.1 if语句格式1

if (关系表达式) {
    语句体;
}

执行流程：

1. 首先计算关系表达式的值
2. 如果关系表达式的值为true就执行语句体
3. 如果关系表达式的值为false就不执行语句体
4. 继续执行后面的语句内容

5.2.2 if语句格式2

if (关系表达式) {
    语句体1;
} else {
    语句体2;
}

执行流程：

1. 首先计算关系表达式的值
2. 如果关系表达式的值为true就执行语句体1
3. 如果关系表达式的值为false就执行语句体2
4. 继续执行后面的语句内容

5.2.3 if语句格式3

if (关系表达式1) {
    语句体1;
} else if (关系表达式2) {
    语句体2;
}
...
else {
    语句体n+1;
}

执行流程:

1. 首先计算关系表达式1的值
2. 如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
3. 如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
4. ...
5. 如果没有任何关系表达式为true，就执行语句体n+1。

5.3 switch语句

5.3.1 switch语句格式

switch (表达式) {
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        [break;]
}

格式说明:

• 表达式: 取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String.
• case: 后面跟的是要和表达式进行比较的值。
• break: 表示中断，结束的意思，用来结束switch语句。
• default: 表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

6 循环语句

6.1 for循环语句

6.1.1 循环结构

1. 特征：

• 重复做某件事情

• 具有明确的开始和停止标志

2. 循环结构的组成:

   1. 初始化语句: 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
   2. 条件判断语句: 用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
   3. 循环体语句: 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
   4. 条件控制语句: 用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
3. 循环结构对应的语法:
   1. 初始化语句: 这里可以是一条或者多条语句，这些语句可以完成一些初始化操作
   2. 条件判断语句: 这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体。例如: a<3
   3. 循环体语句: 这里可以是任意语句，这些语句将反复执行
   4. 条件控制语句:这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果。常见i++,i--这样的操作

6.1.2 for循环语句格式

for (初始化语句; 条件判断语句; 条件控制语句) {
    循环体语句;
}

执行流程:

1. 执行初始化语句
2. 执行条件判断语句，看其结果是true还是false

• 如果是false，循环结束

• 如果是true，继续执行

3. 执行循环体语句

4. 执行条件控制语句

5. 回到2继续

6.2 while循环语句

6.2.1 while循环语句格式

// 基本格式
while (条件判断语句) {
    循环体语句;
}

// 完整格式
初始化语句;
while (条件判断语句) {
    循环体语句;
    条件控制语句;
}

执行流程:

1. 执行初始化语句

2. 执行条件判断语句，看其结果是true还是false

• 如果是false，循环结束
• 如果是true，继续执行

3. 执行循环体语句
4. 执行条件控制语句
5. 回到2继续

6.3 do...while循环语句

6.3.1 do...while循环语句格式

// 基本格式
do {
    循环体语句;
} while (条件判断语句);

// 完整格式
初始化语句;
do {
    循环体语句;
    条件控制语句;
} while (条件判断语句);

执行流程:

1. 执行初始化语句

2. 执行循环体语句
3. 执行条件控制语句
4. 执行条件判断语句，看其结果是true还是false

• 如果是false，循环结束
• 如果是true，继续执行

5. 回到2继续

6.3.2 三种循环的区别

1. 三种循环的区别

• for循环和while循环先判断条件是否成立，然后决定是否执行循环体(先判断后执行)
• do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体(先执行后判断)

2. for和while的区别

• 条件控制语句所控制的自增变量，因为属于for循环的语法结构，在for循环结束后，就不能再次访问到了
• 条件控制语句所控制的自增变量，对于while循环来说不归属于其语法结构中，在while循环结束后，该变量还可以继续使用

==死循环格式:==

for (;;) { }
while (true) { }
do { } while (true);

while的死循环格式是最常用的

命令提示符窗口中<kbd>Ctrl+C</kbd>可以结束死循环

6.4 跳转控制语句

6.4.1 跳转控制语句概述

• continue: 用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
• break: 用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环

6.5 循环嵌套

6.5.1 循环嵌套概述

语句结构:

• 顺序语句: 以分号结尾，表示一句话的结束

• 分支语句: 一对大括号表示if的整体结构，整体描述一个完整的if语句

  ? 一对大括号表示switch的整体结构，整体描述一个完整的switch语句

• 循环语句: 一对大括号表示for的整体结构，整体描述一个完整的for语句

  ? 一对大括号表示while的整体结构，整体描述一个完整的while语句

  ? do...while以分号结尾，整体描述一个完整的do...while语句

任何语句对外都可以看成一句话，一句代码

分支语句中包含分支语句称为分支嵌套

循环语句中包含循环语句称为循环嵌套

6.6 Random

6.6.1 Random的作用和使用步骤

作用: 用于产生一个随机数

使用步骤:

1. 导包

import java.util.Random;
// 导包的动作必须出现在类定义的上边

2. 创建对象

Random r = new Random();
// 上面这个格式里面，只有r是变量名，可以变，其它的都不允许变

3. 获取随机数

int number = r.nextInt(10); // 获取数据的范围: [0, 10) 包括0，不包括10
// 上面这个格式里面，number是变量名，可以变，10可以变，其它的都不允许变

7 数组

7.1 数组定义格式

7.1.1 数组概述

数组(array)是一种用于存储多个相同类型数据的存储模型。

7.1.2 数组的定义格式

• 格式一: 数组类型[] 变量名

  范例: int[] arr

  定义一个int类型的数组，数组名是arr

• 格式二: 数组类型 变量名[]

  范例: int arr[]

  定义一个int类型的变量，变量名是arr数组

7.2 数组初始化之动态初始化

7.2.1 数组初始化概述

Java中的数组必须先初始化才能使用。

所谓初始化：就是将数组中的数组元素分配内存空间，并为每个数组元素赋值。

7.2.2 数组初始化方式

• 动态初始化
• 静态初始化

7.2.3 动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

• 格式: 数据类型[] 变量名 = new 数据类型[数组长度];
• new: 为数组申请内存空间;

7.3 数组元素访问

1. 数组变量访问方式

• 格式: 数组名

2. 数组内部保存的数据的访问方式

• 格式: 数组名[==索引==]

3. 索引是数组中数据的编号方式

• 作用: 索引用于访问数组中的数据使用，数组名[==索引==]等同于变量名，是一种特殊的变量名
• 特征:
  1. 索引从0开始
  2. 索引是连续的
  3. 索引逐一增加，每次加1

7.4 内存分配

7.4.1 Java中内存分配

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分。因为每一片区域都有特定的处理数据方式和内存管理。

• 栈内存: 存储局部变量
  • 定义在方法中的变量，使用完毕，立即消失
• 堆内存: 存储 new 出来的内容(实体，对象)
  • 数组在初始化时，会为存储空间添加默认值
  • 每一个new出来的东西都有一个地址值，使用完毕，会在垃圾回收器空闲时被回收

7.5 数组初始化之静态初始化

7.5.1 数组初始化之静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度

• 格式: 数据类型[] 变量名 = new 数据类型[]{数据1, 数据2, 数据3, ......};
• 范例: int[] arr = new int[]{1, 2, 3};
• 简化格式: 数据类型[] 变量名 = {数据1, 数据2, 数据3, ......};
• 范例: int[] arr = {1, 2, 3};

7.6 数组操作的两个常见小问题

• 索引越界: 访问了数组中不存在的索引对应的元素，造成索引越界
• 空指针异常: 访问的数组已经不再指向堆内存的数据，造成空指针异常
  • null: 空值，引用数据类型的默认值，表示不再指向任何有效对象