写在前面：
此文是笔者在学习Java系列课程的过程中，参考相关课件、视频讲解、课程代码，并结合一些文档、思维导图及个人理解，对所学内容做的阶段性梳理与总结。

写于：2021年1月17日~24日
内容：Java后端系列笔记001（Java基础）
全文：15619字；读完需要：20分钟

一、开发前言

1. 1 Java语言概述 [ 导图 ]

1. 2 计算机基础知识

二进制

存储：数据在计算机中是以 二进制形式 存储的
特点：“逢二进一”、“只含0和1”
转换：
- 十进制整数转成二进制整数：使用除2取余-逆序排列的方式
- 二进制数据转成十进制数据：使用 8421编码的方式（按权相加法）

tips：二进制数系统中，每个0或1就是一个位，叫做bit（比特）

问：什么是 8421编码？
答：8421码又称为BCD码，是十进制代码中最常用的一种，每一位二值代码的“1”都代表一个固定数值2^(n-1) [右→左] 。
将每位“1”所代表的二进制数加起来，就可以得到它所代表的十进制数字。因为代码中从左至右看每一位“1”分别代表数字“8”“4”“2”“1”，故得名8421码。

字节

位（bit）：二进制数据；一个数字0或一个数字1，代表一位
字节（Byte）：是我们常见的计算机中最小存储单元
- 1 Byte = 8 bit （每逢8位是一个字节）
- 1 KB = 1024 Byte
- 1 MB = 1024 KB
- 1 GB = 1024 MB
- 1 TB = 1024 GB
- 1 PB = 1024 TB
- 1 EB = 1024 PB
- 1 ZB = 1024 EB

tips：在计算机数据存储中，存储数据的最小单位 → 位(bit)，基本单位 → 字节(Byte 简称B)

常用DOS命令

DOS：磁盘操作系统（Disk Operating System）
进入DOS操作窗口：
Windows+R → 打开运行窗口 → 输入cmd（命令提示符）回车 → 进入DOS的操作窗口
常用命令

命令	操作符号
盘符切换	盘符名:
进入文件夹	cd 文件夹名
进入多级文件夹	cd 文件夹1\文件夹2\文件夹3
退出文件夹	cd …
直接回根路径	cd \
查看当前内容	dir
清屏	cls
退出	exit

二、Java语言开发环境

2. 1 JVM、JRE、JDK

概念：

JVM（Java Virtual Machine ）
- Java虚拟机，是运行所有Java程序的假想计算机
- 是实现Java语言跨平台性的关键
JRE (Java Runtime Environment)
- Java程序的运行环境
- 包含：JVM + 运行时所需的核心类库
JDK (Java Development Kit)
- Java程序开发工具包
- 包含：JRE + 开发工具

关系：JDK ＞ JRE ＞ JVM

说明：

运行一个已有的Java程序 —— 只需安装JRE
开发一个全新的Java程序 —— 必须安装JDK

tips：
Java语言具有跨平台性：同一段程序可运行在不同操作系统上
但 Java的虚拟机-JVM：本身不具有跨平台功能（每个操作系统配有不同版本的虚拟机）

2. 2 配置Java环境变量

目的：

方便开发 —— 在任意的目录下都可以使用JDK的开发工具

意义：

告诉操作系统 —— 使用的JDK开发工具所在的目录

步骤：

计算机/此电脑 → 右键选属性 → 高级系统设置 → 高级-环境变量 → 新建系统变量
- JAVA_HOME：jdk的安装目录
- Path： %JAVA_HOME%\bin;
配置完成后：打开cmd（DOS命令行），任意目录输入 javac，可看到内容

三、HelloWorld入门程序

3. 1 程序开发步骤

Java程序开发三步骤：编写、编译、运行

编写Java源程序
- 记事本中写入代码 → 保存 → 命名为 HelloWorld.java
- 文件命名：和类的名字一致 HelloWorld，后缀 .java
- .java文件：JVM看不懂，不能运行，需对文件进行编译 → JVM看得懂的 .class文件（字节码文件）

public class HelloWorld {public static void main(String[] args) {System.out.println("Hello, World!");  // 输出 Hello, World!}
}

编译Java源文件
- 命令：javac Java源文件名.后缀名，如：javac HelloWorld.java
- .class文件：编译后会在目录下会产生一个HelloWorld.class的新文件（字节码文件）
- 若遇到编码问题，我们可在cmd中使用 -encoding 选项设置 utf-8 来编译

javac -encoding UTF-8 HelloWorld.java
java HelloWorld

运行Java程序
- 命令：java 类名字，如：java HelloWorld
- 注意：运行Java程序时，不要写 .class

tips：

程序的文件名：需和类的名字一致，注意大小写，每个字母和符号必须与示例代码一模一样。eg：HelloWorld

工具：（1）.java文件的编译工具：javac.exe [ 编译器 ] （2）.class文件的运行工具：java.exe [ 解释器 ]

3. 2 入门程序说明

编译和运行是两个不同概念

编译：将编写的Java源文件翻译成JVM认识的class文件（此过程中，编译器会检查所写程序是否错误——若有错误则会有提示，否则编译成功）

运行：将class文件通过解释器交给JVM运行（此时JVM就会去执行我们编写的程序）

3. 3 注释、关键字、标识符 [ 导图 ]

四、常量与变量

4. 1 常量

概念：在程序运行期间，固定不变的量
分类

类型	含义	举例
整数常量	所有的整数	4、200、0、-250
小数常量	所有的小数	0.0、 -0.1、2.55
字符常量	单引号引起来,只能写一个字符,必须有内容	‘A’、‘b’、‘9’、‘中’
字符串常量	双引号引起来,可写多个字符,也可不写	“A” 、“Hello” 、“你好” 、""
布尔常量	只有两个取值	true 、false
空常量	只有一个取值，代表没有任何数据	null

注意
- 字符常量：两个单引号中间必须有且仅有一个字符
- 空常量：不能直接用来打印输出

public class Demo01Const {public static void main(String[] args) {// 字符串常量System.out.println(""); // 字符串两个双引号中间的内容为空 √// 字符常量 —— 两个单引号中间必须有且仅有一个字符System.out.println('A');// √//System.out.println(''); // 没有字符不行 ×//System.out.println('AB'); // 有两个字符不行 ×// 空常量 —— 空常量不能直接用来打印输出 //System.out.println(null); // ×}

4. 2 数据类型与变量

数据类型

Java的数据类型分为两大类
- 基本数据类型：整数、浮点数、字符、布尔
- 引用数据类型：类、数组、接口
基本数据类型（四类八种）

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128~127
短整型	short	2个字节	-32768~32767
整型	int（默认）	4个字节	-231次方~2的31次方-1
长整型	long	8个字节	-2的63次方~2的63次方-1
单精度浮点数	float	4个字节	1.4013E-45~3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324~1.7977E+308
字符型	char	2个字节	0-65535
布尔类型	boolean	1个字节	true、false

变量

概念：程序运行期间，内容可以发生改变的量
变量定义的格式
- 三要素： 数据类型 、 变量名 、 数据值
- 创建一个变量并且使用的格式：

1. 格式1_先创建后赋值
数据类型 变量名称; // 创建了一个变量
变量名称 = 数据值; // 赋值，将右边的数据值，赋值交给左边的变量
eg: int num1; num1 = 10;2. 格式2_一步到位
数据类型 变量名称 = 数据值; // 在创建一个变量的同时，立刻放入指定的数据值
eg: int num2 = 10;

注意事项
- 变量名称：若创建多个变量，则变量间的名称不可重复
- 取值范围：若使用byte或short类型的变量，则右侧的数据值不能超过左侧类型的范围
- 变量赋值：定义的变量，不赋值不能使用
- 作用范围：变量使用不能超过作用域的范围
  - 【作用域】- 从定义变量的一行开始，一直到直接所属的大括号结束为止
- 创建变量：可通过一个语句来创建多个变量，但一般情况不推荐这么写

public class VariableNotice {public static void main(String[] args) {int num1 = 10; // 创建了一个新的变量，名叫num1// int num1 = 20; // [1] 又创建了另一个新的变量，名字也叫num1，错误！byte num2 = 30; // 注意：右侧数值的范围不能超过左侧数据类型的取值范围System.out.println(num2); // 30// byte num3 = 400; // [2] 右侧超出了byte数据范围，错误！int num4; // 定义了一个变量，但是没有进行赋值// System.out.println(num4); // [3]直接使用打印输出就是错误的！// System.out.println(num5); // 在创建变量之前，不能使用这个变量int num5 = 500;System.out.println(num5); // 500{int num6 = 60;System.out.println(num6); // 60}// int num6;// System.out.println(num6); //[4] 已经超出了大括号的范围，超出了作用域，变量不能再使用了//[5] 同时创建了三个全都是int类型的变量int a, b, c;// 各自分别赋值a = 10;b = 20;c = 30;System.out.println(a); // 10System.out.println(b); // 20System.out.println(c); // 30//[5] 同时创建三个int变量，并且同时各自赋值int x = 100, y = 200, z = 300;System.out.println(x); // 100System.out.println(y); // 200System.out.println(z); // 300}
}

tips：

Java中的默认类型：整数类型是 int 、浮点类型是 double

变量的定义：long类型 — 数据后加L表示、float类型 — 数据后加F表示（字母后缀F和L不要丢掉）

五、数据类型转换

当数据类型不一样时，将会发生数据类型转换

5. 1 自动转换-隐式

概念：将取值范围小的类型自动提升为取值范围大的类型
特点：代码不需要进行特殊处理，自动完成
规则：数据范围从小到大（byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double）

public static void main(String[] args) {int i = 1;byte b = 2;// byte x = b + i; // 报错//int类型和byte类型运算，结果是int类型int j = b + i;System.out.println(j); //3/* 左边是long类型，右边是默认的int类型，左右不一样一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储int --> long，符合了数据范围从小到大的要求(自动类型转换) */long num1 = 100;System.out.println(num1); // 100
}

5. 2 强制转换-显式

概念：将取值范围大的类型强制转换为取值范围小的类型
特点：代码需要进行特殊的格式处理，不能自动完成
格式：范围小的类型变量名 = (范围小的类型) 原本范围大的数据;

int i =  1. 5 ; // 错误（将 double类型数据 赋值到 int类型变量，会产生编译失败，所以无法赋值）int i = (int)1.5;//编译成功（double类型数据 强制转成 int类型，直接去掉小数点）

注意：强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出

public static void main(String[] args) {//1. double --> int，强制类型转换int num1 = (int) 3.99;System.out.println(num1); // 3，这并不是四舍五入，所有的小数位都会被舍弃掉（精度损失）//2. long强制转换成为int类型int num2 = (int) 6000000000L;System.out.println(num2); // 1705032704（发生数据溢出，即：数据丢失）//3. 定义num3为short范围内最大值short num3 = 32767;// short + int --> int + int --> int --> short // 运算后，4字节int强制转换为2字节short，砍掉2个字节后会出现不确定的结果(数据丢失)num3 = (short)(num3 + 10);
}

tips：

byte/short/char这三种类型：
（1）都可以发生数学运算，例如加法“+”；（2）在运算的时候，都会被首先提升成为int类型，然后再计算

boolean类型：不能发生数据类型转换

5. 3 ASCII编码表

数字和字符的对照关系表（编码表）
- ASCII码表：美国信息交换标准代码（American Standard Code for Information Interchange）
- Unicode码表：万国码（开头0-127部分和ASCII完全一样，但是从128开始包含有更多字符）

public static void main(String[] args) {char c1 = '1';// char字符类型和int类型计算// char类型的字符先查询编码表，得到49，再与1求和，结果为50System.out.println(c1 + 1); // 50char c2 = 'A'; // 其实底层保存的是65数字char c3 = 'c';// 左侧是int类型，右边是char类型，// char --> int，范围从小到大（自动类型转换）int num = c3;System.out.println(num); // 99char c4 = '中'; // 正确写法 （Unicode码）System.out.println(c4 + 0); // 20013
}

常见ASCII

字符	数值
0	48
9	57
A	65
Z	90
a	97
z	122

六、运算符 [ 导图 ]

思维导图

代码分析

自增运算符 ++、自减运算符 --

public static void main(String[] args) {//1. 与打印操作混合的时候int num1 = 20;// 混合使用，先++（先加后用），变量立刻马上变成21，然后打印结果21System.out.println(++num1); // 21System.out.println(num1); // 21int num2 = 30;// 混合使用，后++（先用后加），首先使用变量本来的30，然后再让变量+1得到31System.out.println(num2++); // 30System.out.println(num2); // 31System.out.println("=================");//2. 和赋值操作混合int num3 = 40;int result1 = --num3; // 混合使用，前--，变量立刻马上-1变成39，然后将结果39交给result1变量System.out.println(result1); // 39System.out.println(num3); // 39int num4 = 50;int result2 = num4--;// 混合使用，后--，首先把本来的数字50交给result2，然后我自己再-1变成49System.out.println(result2); // 50System.out.println(num4); // 49System.out.println("=================");//3. 综合int x = 10;int y = 20;int result3 = ++x + y--;// 11 + 20 = 31System.out.println(result3); // 31System.out.println(x); // 11System.out.println(y); // 19// 30++; // 错误写法！常量不可以使用++或者--
}

三元运算符 数据类型变量名称 = 条件判断 ? 表达式A : 表达式B;

public static void main(String[] args) {int a = 10;int b = 20;// 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一int max = a > b ? a : b; // 最大值的变量System.out.println("最大值：" + max); // 20// int result = 3 > 4 ? 2.5 : 10; // 错误写法！（ 2.5不符合int类型）System.out.println(a > b ? a : b); // 正确写法！// a > b ? a : b; // 错误写法！（三元运算符的结果必须被使用）
}

注意：关于 “隐含强制类型转换” 的内容

/*
对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围，
那么javac编译器将会自动隐含地为我们补上一个(byte)(short)(char)。1. 如果没有超过左侧的范围，编译器补上强转。
2. 如果右侧超过了左侧范围，那么直接编译器报错。
*/
public static void main(String[] args) {// int --> byte，不是自动类型转换byte num1 = /*(byte)*/ 30; // 右侧int数字没有超过左侧的范围，是正确的！System.out.println(num1); // 30// byte num2 = 128; // 右侧超过了左侧的范围，错误！// int --> char，没有超过范围// 编译器将会自动补上一个隐含的(char)char zifu = /*(char)*/ 65;System.out.println(zifu); // A}

扩展：常量和变量的运算 “编译器的常量优化”

/*
在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量，
那么编译器javac将会直接将若干个常量表达式计算得到结果。
short result = 5 + 8; // 等号右边全都是常量，没有任何变量参与运算
编译之后，得到的.class字节码文件当中相当于【直接就是】：
short result = 13;
右侧的常量结果数值，没有超过左侧范围，所以正确。这称为“编译器的常量优化”。但是注意：一旦表达式当中有变量参与，那么就不能进行这种优化了。
*/
public static void main(String[] args) {short num1 = 10; // 正确写法，右侧没有超过左侧的范围short a = 5;short b = 8;/* 右侧只有两个常量，没有任何变量在编译的时候（编译器javac），已经确定了 5+8 的结果并没有超过short类型的取值范围，可以赋值给变量 result ，因此result = 5 + 8 正确*/short result = 5 + 8;System.out.println(result);//13/* 右侧存在变量的情况short + short --> int + int --> int*/short result1 = a + b; // 错误写法！左侧需要是int类型short result2 = 5 + a + 8; // 编译报错！不兼容的类型：从int转换到short可能会有损失
}

七、流程控制语句

流程控制：通过控制语句的执行顺序来实现所需功能

7. 1 判断语句

判断语句 1：if

if(关系表达式)｛//如果关系表达式为 true，则执行语句体；否则不执行语句体;
｝

判断语句 2：if…else

if(关系表达式) {//如果关系表达式为 true，则执行语句体1语句体 1 ;
}else {//如果关系表达式为 false，则执行语句体2语句体 2 ;
}

判断语句 3：if…else if…else

if (判断条件1) {//如果判断条件1的值为true，执行代码执行语句1;
} else if (判断条件2) {//如果判断条件2的值为true，执行代码执行语句2;
}
...
} else if (判断条件n) {执行语句n;
} else {//如果以上判断条件都不为true，执行代码执行语句n+1;
}

7. 2 选择语句

选择语句：switch

switch(表达式) {case 常量值1:语句体1;break; //可选case 常量值2:语句体2;break; //可选...default:   //可选语句体n+1;break; // 最后一个break语句可以省略，但是强烈推荐不要省略
}

执行流程
- 计算出表达式的值，并与case的值依次比较
- 相等时，开始执行case之后的语句，直到break语句出现，才会跳出switch语句
- 若与case都不匹配，则执行default语句体部分，然后程序结束
注意事项
- a. 多个case后面的数值不可以重复
- b. switch后面小括号当中只能是下列数据类型：
  - 基本数据类型：byte/short/char/int；
  - 引用数据类型：String字符串、enum枚举
- c. switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略

case的穿透性

在switch语句中，如果case的后面不写break，将出现穿透现象

即：匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止

7. 3 循环语句

循环结构的基本组成部分，一般可以分成四部分：

初始化语句：在循环开始最初执行，而且只做唯一一次
条件判断（布尔表达式）：如果成立，则循环继续；如果不成立，则循环退出
循环体：重复要做的事情内容，若干行语句
步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次

循环语句 1：for

for(初始化语句; 布尔表达式; 步进语句){循环体    //代码语句
}

循环语句 2：while

//格式 1：标准格式
while (条件判断) {循环体
}//格式 2：扩展格式
初始化语句;
while (条件判断) {循环体;步进语句;
}

循环语句 3：do…while

//格式 1：标准格式
do {循环体
} while (条件判断);//格式 2：扩展格式
初始化语句
do {循环体步进语句
} while (条件判断);

do…while循环的特点：无条件执行一次循环体，即使我们将循环条件直接写成false，也依然会循环一次。

三种循环语句的区别

如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
for循环的变量在小括号当中定义（局部变量），只有循环内部才可以使用。while循环和do-while循环初始化语句本来就在外面（全局变量），所以出了循环之后还可以继续使用。
循环的选择：在已知循环次数的时候推荐使用for，次数未知时推荐使用while。

扩展 - 死循环

死循环：永远停不下来的循环

//死循环的标准格式：
while (true) {循环体
}//如何结束一个死循环:使用跳出语句

扩展 - 嵌套循环

嵌套循环：是指一个循环的循环体是另一个循环

// 格式：
for(初始化语句; 循环条件; 步进语句){for(初始化语句; 循环条件; 步进语句){执行语句}
}//总共的循环次数 = 外循环次数 * 内循环次数

7. 4 跳出语句

break关键字

常见用法（终止switch或循环）
- 用在switch语句中：一旦执行，整个switch语句立刻结束
- 用在循环语句当中：一旦执行，整个循环语句立刻结束，打断循环

public static void main(String[] args) {for (int i = 1; i <= 10; i++) {// 如果希望从第4次开始，后续全都不要了，就要打断循环if (i == 4) { // 如果当前是第4次break; // 那么就打断整个循环}System.out.println("Hello" + i);}
}

continue关键字

用法：一旦执行，立刻跳过本次循环剩余内容，继续下一次循环

public static void main(String[] args) {for (int i = 1; i <= 10; i++) {if (i == 4) { // 如果当前是第4层continue; // 那么跳过本次循环，马上开始下一次（第5层）}System.out.println(i + "层到了。");}
}

八、开发工具IntelliJ IDEA

概述：IDEA是一个专门针对Java的集成开发工具(IDE)，由Java语言编写。所以，需要有JRE运行环境并配置好环境变量。
优点：它可以极大地提升我们的开发效率。可以自动编译，检查错误。
常见快捷键

快捷键	功能
Alt+Enter	导入包，自动修正代码
Ctrl+Y	删除光标所在行
Ctrl+D	复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L	格式化代码
Ctrl+/	单行注释
Ctrl+Shift+/	选中代码注释，多行注释，再按取消注释
Alt+Insert	自动生成代码，toString，get，set等方法
Alt+Shift+上下箭头	移动当前代码行

九、方法

9. 1 方法的定义和调用

什么是方法？方法就是一段可以重复调用的代码

定义方法的格式:

修饰符 返回值类型 方法名 （参数列表）｛代码...return ;
｝

调用方法的三种格式：

单独调用：方法名称(参数);
打印调用：System.out.println(方法名称(参数));
赋值调用：数据类型变量名称 = 方法名称(参数);

public class MethodDefine {public static void main(String[] args) {// 单独调用sum(10, 20);System.out.println("===========");// 打印调用System.out.println(sum(10, 20)); // 30System.out.println("===========");// 赋值调用int number = sum(15, 25);number += 100;System.out.println("变量的值：" + number); // 140}public static int sum(int a, int b) {System.out.println("方法执行啦！");int result = a + b;return result;}
}

注意事项:

方法定义的先后 [ 顺序无所谓 ]
方法 [ 不能嵌套 ]，不能在一个方法的内部定义另外一个方法
方法定义之后，自己不会执行；如果希望执行，一定要进行方法的调用
如果方法 [ 有返回值 ]，那么必须写上“return 返回值;”，不能没有
return 后面的返回值数据，必须和方法的返回值 [ 类型对应 ] 起来
对于一个 [ void 没有返回值 ] 的方法，不能写 return 后面的返回值，只能写“return ;”（可省略）
一个方法当中可以有 [ 多个 return 语句 ]，但是必须保证同时 [ 只有一个会被执行 ]到，两个return 不能连写
[ 不能在 return 后面写代码 ]， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码

public static void method1() {//  return 10; // 错误的写法！方法没有返回值，return后面就不能写返回值。return; // 没有返回值，只是结束方法的执行而已。
}public static void method2() {System.out.println("AAA");System.out.println("BBB");
//  return; // 最后一行的return可以省略不写。
}public static int method3(int a,int b) {return a + b;
//  System.out.println("Hello");// 错误，return已经结束，这里不会执行，无效代码
}

tips：

对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。

但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。

9. 2 方法 - 图解

方法的结构
方法调用的流程
方法返回值的有无

9. 3 方法重载 [ 导图 ]

练习：判断哪些方法是重载关系

public static void open(){} // 正确重载
public static void open(int a){} // 正确重载
static void open(int a,int b){} // 代码错误：和第8行冲突 （与修饰符无关）
public static void open(double a,int b){} // 正确重载
public static void open(int a,double b){} // 代码错误：和第6行冲突
public void open(int i,double d){} // 代码错误：和第5行冲突 （与修饰符无关）
public static void OPEN(){} // 代码正确不会报错，但是并不是有效重载
public static void open(int i,int j){} // 代码错误：和第3行冲突//说明：方法重载与修饰符（public static）无关

十、数组

10. 1 数组定义和访问 [ 导图 ]

数组定义格式详解：

注意事项：

静态初始化标准格式可以拆分成为两个步骤：声明数组、创建空间
动态初始化也可以拆分成为两个步骤
静态初始化一旦使用省略格式，就不能拆分成为两个步骤了

public static void main(String[] args) {// 省略格式的静态初始化int[] arrayA = { 10, 20, 30 };System.out.println(arrayA); // 获得的是【地址值】/* 下方内容 【编译报错】，原因：编译器会认为数组限定的元素个数[3]与实际存储个数{10,20,30}个数可能不一致，存在一定的安全隐患。*/
//  int[] arrayA2 = new int[3] { 10, 20, 30 }; //错误写法！// 静态初始化的标准格式，可以拆分成为两个步骤int[] arrayB;  //或 int arrayB[]; （效果相同，但不是首选方法）arrayB = new int[] { 11, 21, 31 };// 动态初始化也可以拆分成为两个步骤int[] arrayC;arrayC = new int[5];// 静态初始化的省略格式，不能拆分成为两个步骤
//  int[] arrayD;
//  arrayD = { 10, 20, 30 }; //写法错误
}

使用动态初始化数组时，其中的元素将会自动拥有一个默认值。规则如下：

数据类型	默认值
整数类型	0
浮点类型	0.0
字符类型	‘\u0000’
布尔类型	false
引用类型	null

tips：

数组有定长特性，长度一旦指定，不可更改。

使用建议：如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

10. 2 数组原理内存图

内存：是计算机中的重要原件，临时存储区域，作用是运行程序

Java虚拟机的内存划分（5部分）

区域名称	说明
栈（Stack）	存放的都是方法中的局部变量。方法的运行一定要在栈中执行
堆（Heap）	凡是new出来的东西，都在堆当中
方法区（Method Area）	存储.class相关信息，包括方法的信息
本地方法栈（Native Method Stack）	与操作系统相关
寄存器（pc Register）	与CPU相关

数组在内存中的存储

只有一个数组的内存图
- 方法区存储.class相关信息，保存了程序的main方法
- ① 查看方法区信息，将main方法加载到栈内存中，并为其开辟一个内存空间（main方法进栈）
- ② 创建数组，JVM在堆内存中开辟空间，用来存储数组（凡是new出来的东西，都在堆中）
- ③ 数组中有三个元素，于是将空间划分为三部分，且元素默认值为0
- ④ 创建好的数组在内存中有自己的内存地址（十六进制的地址值）
- ⑤ 数组的地址值被JVM赋值给变量array（new出的数组在堆中，变量在栈中）
- ⑥ 引用数据类型的变量array中存储的是数组的地址值，根据该地址值找到堆中的数组
- …

有两个独立数组的内存图

两个引用指向同一个数组的内存图

10. 3 数组的常见操作

数组越界异常

如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常 ArrayIndexOutOfBoundsException
原因：索引编号（编号从0开始，一直到“数组的长度-1”为止）写错了
解决：修改成为存在的正确索引编号

public static void main(String[] args) {int[] array = { 15, 25, 35 };// 错误写法：并不存在3号元素，所以发生异常System.out.println(array[3]);
}

数组空指针异常

所有的引用类型变量，都可以赋值为一个null值（代表其中什么都没有），数组必须进行new初始化才能使用其中的元素
如果只是赋值了一个null，没有进行new创建，那么将会发生：空指针异常 NullPointerException
原因：未对数组进行new初始化
解决：补上new

public static void main(String[] args) {int[] array = null;
//  array = new int[3];  //补上new即可System.out.println(array[0]);
}

数组遍历

对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式是打印输出

public static void main(String[] args) {int[] array = { 15, 25, 30, 40 };// 首先使用原始方式System.out.println(array[0]); // 15System.out.println(array[1]); // 25System.out.println(array[2]); // 30System.out.println(array[3]); // 40System.out.println("=================");// 使用循环，次数其实就是数组的长度（array.length）for (int i = 0; i < array.length; i++) {System.out.println(array[i]);}
}

数组最值

//数组获取最大值元素
public static void main(String[] args) {int[] array = { 5, 15, 30, 20, 10000, 30, 35 };// 定义变量，保存数组中0索引的元素int max = array[0]; // 遍历数组，取出每个元素for (int i = 1; i < array.length; i++) {// 如果当前元素，比max更大，则max换成大值if (array[i] > max) {max = array[i];}}// 输出最大值System.out.println("最大值：" + max);
}

数组反转

要求：
- 数组元素反转，如：[1, 2, 3, 4] → [4, 3, 2, 1]
- 不能使用新数组，就用原来的唯一一个数组
思路与实现：

public static void main(String[] args) {int[] array = { 10, 20, 30, 40, 50 };/*初始化语句：int min = 0, max = array.length - 1条件判断：min < max步进表达式：min++, max--循环体：用第三个变量倒手*/for (int min = 0, max = array.length - 1; min < max; min++, max--) {int temp = array[min];array[min] = array[max];array[max] = temp;}// 打印遍历输出数组后来的样子for (int i = 0; i < array.length; i++) {System.out.println(array[i]);//50, 40, 30, 20, 10}
}

10. 4 数组作为方法参数和返回值

数组作为方法的参数

传递进去的是：数组的地址值

public static void main(String[] args) {int[] array = { 10, 20, 30, 40, 50 };System.out.println(array); // 地址值//调用方法，传递数组printArray(array); // 传递进去的是array中保存的地址值}/*三要素返回值类型：只是进行打印而已，不需要进行计算，也没有结果，用void方法名称：printArray参数列表：必须给我数组，我才能打印其中的元素。int[] array*/public static void printArray(int[] array) {System.out.println("printArray方法收到的参数是：");System.out.println(array); // 地址值for (int i = 0; i < array.length; i++) {System.out.println(array[i]);}}

数组作为方法的返回值

返回的是：数组的地址值
一个方法可以有0、1、多个参数；但只能有0或1个返回值，不能有多个返回值
问：如果希望一个方法当中产生了多个结果数据进行返回，怎么办？
解决方案：使用一个数组作为返回值类型即可

public static void main(String[] args) {int[] result = calculate(10, 20, 30);System.out.println("main方法接收到的返回值数组是：");System.out.println(result); // 地址值System.out.println("总和：" + result[0]);System.out.println("平均数：" + result[1]);
}public static int[] calculate(int a, int b, int c) {int sum = a + b + c; // 总和int avg = sum / 3; // 平均数// 两个结果都希望进行返回// 需要一个数组，也就是一个塑料兜，数组可以保存多个结果/*int[] array = new int[2];array[0] = sum; // 总和array[1] = avg; // 平均数*/int[] array = { sum, avg };System.out.println("calculate方法内部数组是：");System.out.println(array); // 地址值return array;
}

tips:

任何数据类型都能作为方法的参数类型，或者返回值类型

方法的参数为基本类型时，传递的是数据值；
方法的参数为引用类型时，传递的是地址值

Java基础|1-01-Java基础语法(详细) @Java相关推荐

蓝桥杯基础练习 01字串 C/C++/Java/Python描述
蓝桥杯基础练习 01字串 C/C++/Java/Python描述大家好,我叫亓官劼(qí guān jié ),在CSDN中记录学习的点滴历程,时光荏苒,未来可期,加油~博客地址为:亓官劼的博 ...
基础篇 | 01 机器学习基础
本系列概述核心内容是深度学习,只不过我们会进行代码实践,来巩固我们讲的概念的基础.会使用机器学习开发可以实际使用的工程项目,这也是我们这个系列跟其它机器学习最大区别的地方. 深度学习的意义当然,不 ...
【计算机基础】01计算机基础知识
第1章计算机基础知识 1.1 概述 1.1.1 计算机的发展史 1942年2月,美国宾夕法尼亚大学研制出世界上第一台电子多用途数字计算机ENIAC. 5个发展时代: 1. 第一代计算机第一代 ...
计算机应用基础在线测试01,计算机应用基础在线测试(全部正确).pdf
<计算机应用基础>第 01 章在线测试 <计算机应用基础>第 01 章在线测试剩余时间: 59:45 答题须知: 1.本卷满分 20 分. 2 .答完题后,请一定要单击下面的 ...
python图形编程基础知识_AI-图像基础知识-01|python基础教程|python入门|python教程
目前人工智能Artificial Intelligence主要分为两大分支: 计算机视常见:Computer Vision,简称CV CV主要是研究如何让机器看懂世界的一种技术,通过各种光学传感器来代 ...
java的 x跟x_关于语法：java中的x ++和++ x有区别吗？
java中的++ x和x ++有区别吗? 提示大量相同的答案...... ...并提出第一个完全相同的答案... 最快的去战利品,按最旧排序,点击upvote.ohowoho. 我确信我有它! 无论如 ...
Matlab 基础应用01 - Python 基础应用 n阶幻方【MagicSquare】和构造
前言: 本章介绍幻方的基本知识,同时利用Matlab 和 Python 构造简单的幻方方阵. 最后用幻方结合图像,展示了一个渐进的魔幻效果. 幻方定义: 简单介绍幻方(Magic Square)是一 ...
视觉slam学习|基础篇01
系列文章目录 SLAM基础篇01 SLAM基础篇02 目录系列文章目录前言 SLAM是干什么的? SLAM的数学建模机器人学基础齐次矩阵关于旋转的表示:旋转向量.欧拉角.四元数李群和李代数 ...
打怪升级之小白的大数据之旅(一)＜Java基础语法之Java的身世之谜＞
打怪升级之小白的大数据之旅(一) Java基础语法之Java的身世之谜打怪升级之小白的大数据之旅(一) 前言一.学习大数据之前二.Java基础 what? why? how? 总结前言做了几 ...

Java基础|1-01-Java基础语法(详细) @Java