一、Java概述

1.1 Java语言背景

Java语言诞生于1995年，是Sun（Stanford University Network）公司推出的一门计算机语言

公认的Java之父：詹姆斯·高斯林（James Gosling）

1.2 Java语言的三个版本

1.Java SE：Java 语言的（标准版），用于桌面应用的开发，是其他两个版本的基础

2.Java EE：Java 语言的（企业版），用于 Web 方向的网站开发

3.Java ME : Java 语言的（小型版），用于嵌入式消费类电子设备

1.3 Java语言的跨平台原理

常用的操作系统(平台)有哪些:

1.Windows

2.Mac

3.Linux

Java为什么可以跨平台：

1.Java 程序可以在任意操作系统上运行，实现了一次编写，到处运行

2.在需要运行 Java 应用程序的操作系统上，安装一个与操作系统对应的 Java 虚拟机（JVM Java Virtual Machine）即可

3.JVM 虚拟机本身不允许跨平台，允许跨平台的是 Java 程序（我们的代码）

总结：一次编写，到处运行

1.4 JRE和JDK

Java程序开发的三个步骤：

1. 编写代码：书写正确的代码

2. 编译代码：通过javac命令编译java文件，编译成功后，会生成对应的字节码文件

3. 运行代码：通过java命令运行

JDK、JRE和JVM分别是什么？有什么作用？

JDK（Java Develop Kit）是 Java 语言的软件开发工具包，内部包含了代码的编译工具和运行工具

JRE（Java Runtime Environment）指Java运行环境，包含 JVM 虚拟机及 Java 核心类库

JVM（JVM Java Virtual Machine）Java 虚拟机

核心类库：我们自己在编写代码的过程中，需要用到 java 已经写好的这些 java 文件

包含关系：（JDK1.8之后）JDK 包含JRE 包含JVM

1.5 DOS命令

目的：

JDK提供的[编译]和[运行]工具，并不是双击使用的，我们需要在DOS中通过命令去执行

如何打开DOS命令窗口？

win + R，在弹出的窗口输入cmd，敲回车

常用DOS命令有哪些？

二、Java环境搭建

2.1 环境变量的配置

为什么要配置环境变量：

目的：在计算机中的任意位置，都能访问到bin目录下的javac和java工具

环境变量的配置流程：

第一步：我的电脑右键 - 属性 - 高级系统设置 - 环境变量

第二步：系统变量中：新建变量名为 JAVA_HOME，值为JDK的安装路径

第三步：系统变量中：找到Path，新建变量 %JAVA_HOME%\bin

第四步：依次点击三个[确定]，缺一不可!

另一种配置方式：

在Path中直接配置bin目录的[绝对路径]

三、Java基础语法

3.1 注释

什么是注释：对代码解释说明的文字信息，方便程序员阅读代码

注释的分类：

单行注释 //

多行注释 /* 内容 */

文档注释 /** 内容 */

注意：多行注释不能嵌套使用；注释不参与编译和运行！

3.2 关键字（保留字）

什么是关键字：被Java赋予了特殊含义的英文单词

关键字的特点：

1：英文单词纯小写

2：代码编辑器对其有特殊颜色标记

3.3 常量

什么是常量：程序运行过程中，其值不会发生改变的量(数据)

常量的分类：

1.整数常量：-100 200

2.小数常量：5.5 3.14

3.字符常量：'A' '7' '男'

4.字符串常量："HelloWorld" "肆月廿"

5.布尔常量：值只有true和false

6.空常量：null

3.4 变量

什么是变量：本质是内存中的存储空间，空间中存着经常发生改变的量

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

范例1：int age = sc.nextInt();

范例2：double price = 99.99;

范例3：boolean result = true;

如何使用变量：使用变量的标识（变量名）

范例1：System.out.println(age);

范例2：System.out.println(price);

范例3：System.out.println(result);

使用变量的注意事项：

注意1：变量名不能重复定义

注意2：一条语句可定义多个变量，中间用逗号分隔

注意3：变量在使用前必须赋值

注意4：定义float类型变量，在数据末尾加F；定义long类型变量，在数据末尾加L

注意5：变量的作用域范围

3.5 数据单元

想要了解数据类型，需要先了解数据在计算机中的大小单元

最小信息单元：bit，比特位，通常用 b 表示

最小的存储单元：byte，字节，通常用 B 表示

一个byte字节，由8个bit位组成

1B(字节) = 8bit、1KB = 1024B、1MB = 1024KB

1GB = 1024MB、1TB = 1024GB、1PB = 1024TB

Java是一门强类型语言，不同数据类型分配了不同的[内存空间]，所以他们表示的[数据大小]也不一样

3.6 数据类型

基本数据类型分为 [四类八种]：

1.整型：byte short int(默认) long

2.浮点型：float double(默认)

3.字符型：char

4.布尔型(非数值)：boolean

引用数据类型：数组([])、类(class)、接口(interface)..

3.7 标识符

什么是标识符：给类、方法、变量等起名字的符号（由自己定义命名的标识）

标识符的定义规则：

规则1：由数字、字母、_（下划线）、$组成

规则2：不能是Java的关键字

规则3：不能以数字开头

规则4：区分大小写(命名约定：1.小驼峰命名法，用于变量、方法.. 2.大驼峰命名法，用于类)

3.8 键盘录入对象 Scanner

使用步骤：

步骤1：导包 import java.util.Scanner;

步骤2：创建对象 Scanner sc = new Scanner(System.in);

推荐步骤：控制台提示 System.out.println("请输入一个整数：");

步骤3：调用方法，接收数据 int num = sc.nextInt();

注意：自己起的类名，不能和系统已有的类名相同，否则程序会出现错误（例如：Scanner、String、System不可用作自己的类名）

四、类型转换

4.1 隐式转换(自动转换)

类型转换：因为Java中基本数据类型，本质上的区别是数据取值范围大小不一样。那么在操作过程中，会出现赋值、互相转换的过程

隐式转换：也称为自动转换，是将取值范围小的数据，赋值给取值范围大的数据，可以直接赋值（计算机自动完成）

范例1：double d = 10; 范例2：long l = 10;

数据范围从小到大：byte -> short (char) -> int -> long -> float -> double

隐式转换注意细节：

细节1：小的数据类型，和大的数据类型运算，小的会提升为大的之后，再进行运算

细节2：byte、short、char在运算时，不管是否有更高的类型存在，都会自动提升为int类型，然后再参与运算

4.2 强制转换

什么是强制转换：将取值范围大的数据，赋值给范围小的数据

范例1：int a = 5.5; //编译报错范例2：int b = 10000000L; //编译报错

强转的格式：目标数据类型变量名 = (目标数据类型) 变量值;

范例1：int a = (int)5.5; //手动书写强转格式

范例2：int b = (int)100000000000L; //手动书写强转格式

注意：强转会造成数据精度的丢失，不建议使用

五、运算符

什么是运算符：对常量或变量进行操作的符号

什么是表达式：用运算符将常量或变量连接起来，并且符合Java语法的式子

[ 1 ] 算数运算符

算数运算符有哪些：

1.加 +

2.减 -

3.乘 *

4.除 /：两数相除，只取商，且只能得到整数，如果想带有小数的结果，必须有小数(浮点数)参与运算

范例1：10 / 3.0 = 3.3333333333333335

范例2：10.0 / 3 = 3.3333333333333335

5.取余 %：两数相除，只取余数

范例：10 % 3 = 10 / 3 = 商3...余1 // 计算机看到是%，只取余数1

字符的+操作

char字符在参与运算时，是怎么提升为int的：对应ASCII码表中10进制的int值

ASCII：美国信息交换标准代码，计算机中[字节]到[字符]的一套对应关系

字符串的+操作

当+号遇到字符串，这时的+号是字符串连接符。字符串可以使用+号和任意类型进行[拼接]

[ 2 ] 自增自减运算符

自增自减运算符有哪些：

++：变量自身+1，可用于变量前、后

--：变量自身-1，可用于变量前、后

变量单独使用和参与操作时的区别：

单独使用：在前在后效果一样

参与操作：

（1）符号在前：先拿变量自增或自减，再拿结果参与操作（先运算再赋值）

（2）符号在后：先拿变量参与操作，然后将结果自增或自减（先赋值再运算）

[ 3 ] 赋值运算符

基本赋值运算符：

= （将等号右边的值，赋给左边的变量）

扩展赋值运算符：

+=、-=、*=、/=、%= （将等号两边的值参与运算，再将结果，赋给左边的变量）

扩展赋值运算符的特点：隐含了强转

[ 4 ] 关系运算符

关系运算符也称为“比较运算符”：

等于 ==、不等于 !=、大于>、大于等于 >=、小于 <、小于等于 <=

关系表达式：含有关系运算符的表达式，称为关系表达式

关系表达式的结果，都是什么类型：结果只能是true和false，都是boolean类型

[ 5 ] 逻辑运算符

逻辑运算符：

与 &：遇false则false

或 |：遇true则true

非 !：取反

异或 ^：相同为false，不同为true

作用：整合多个关系表达式的条件，结果也都是boolean类型

短路逻辑运算符：

短路与 &&：遇fasle则短路（作用上和逻辑运算符结果一样）

短路或 ||：遇true则短路（作用上和逻辑运算符结果一样）

推荐使用短路逻辑运算符，可以提升代码的效率

[ 6 ] 三元运算符

三元运算符的格式：对应数据类型变量名 = 关系表达式 ? 位置1 : 位置2;

执行流程：判断关系表达式的结果，为true返回表达式1，为false返回表达式2

六、分支结构

6.1 流程控制语句

流程控制语句分为:

1. 顺序结构：默认执行流程

2. 分支结构：if、switch

3. 循环结构：for、while、do..while

顺序结构：是Java程序的默认执行流程，从上到下，从左到右依次执行

作用：通过一些语句，来控制程序(代码)的执行流程

6.2 分支结构 - if语句

格式：if(关系表达式1){

语句体1;

} else if(关系表达式2){

语句体2;

}...else{

//上述表达式都不成立，则走else语句体

}

注意1. 如果if语句所控制的语句体，只有一条语句，可以省略大括号

注意2. if语句的小括号后面，不要写分号，Java中分号代表语句的结束

6.3 分支结构 - switch语句

格式：switch(变量/表达式){ //变量/表达式：将要被匹配的值，取值为byte、short、int、char、枚举(JDK5)、String(JDK7)

case 值: //后面跟的是，要和表达式进行比较的值（被匹配的值）

要执行的语句;

break; //表示中断，结束的意思，用来结束switch语句
…
default: //表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似

要执行的语句;
}

执行流程:

1：首先判断表达式的值

2：依次和case后面的常量进行比较

(1)如果有对应的值，执行case后的语句体，在执行过程中遇到break就会结束

(2)如果所有的case后面的值都不能匹配，就会执行default语句体，然后将程序结束掉

switch语句的case穿透

case的穿透是如何产生的:

1.如果switch语句中，case后面省略了break，就会开始穿透

2.开始case穿透，后续的case就不再具有匹配效果，内部语句都会执行；直到再次遇到break停止，或者switch语句执行完毕后停止

6.4 循环结构 - for循环

for循环格式：for( 初始化语句; 判断语句; 控制语句 ){

循环体;

}

for循环执行流程：

1. 执行初始化语句

2. 执行判断语句，看其boolean类型的结果

（1）如果为false则结束循环

（2）如果为true则继续执行

3. 执行循环体语句

4. 执行控制语句

5. 回到第2步继续判断

6.5 循环结构 - while循环

while循环完整格式：初始化语句;

while(判断语句){

循环体;

控制语句;

}

while循环简化格式：while(判断语句){

循环体;

} //多用于死循环

while循环执行流程：

1. 执行初始化语句

2. 执行判断语句，看其boolean类型的结果

3. 执行循环体语句

4. 执行控制语句

5. 回到第2步继续判断

6.6 循环结构 - do...while循环

do..while循环完整格式：初始化语句;

do{

循环体;

控制语句;

}while(判断语句)

do..while循环简化格式：do{

循环体;

}while(判断语句)

三种循环的区别

for：需要先判断条件是否成立，然后决定是否执行循环体语句（先判断，后执行）

while：需要先判断条件是否成立，然后决定是否执行循环体语句（先判断，后执行）

do..while：先执行一次循环体，然后再判断条件是否成立，然后决定是否执行循环体语句（先执行一次循环体，再判断）

for和while循环区别

for循环初始化语句定义的变量，归属于for循环语法结构，所以循环结束后就不能再使用了

while循环初始化语句定义的变量，由于在循环体外定义（main方法中），不归属于while循环体，所以循环结束后还可以使用

应用场景区别

知道循环次数，推荐使用for循环

不知道循环次数，推荐使用while循环

do..while循环很少使用

6.7 死循环

for循环死循环：for( ; ; ){ }

while循环死循环（常用）：while( true ){ }

do..while循环死循环：do{ }while( true );

如果使用死循环，需要考虑程序的出口（结束循环的条件）

6.8 跳转控制语句

continue关键字作用：

仅用于循环语句，作用是跳过本次循环，继续下一次循环的执行

break关键字作用：

用于循环语句和分支语句，作用是结束整个循环或者分支

循环标号的使用：

在循环语句的关键字前，起一个"标号名"，然后在某种情况下，使用break + 标号名，结束该循环语句

6.9 Random随机数对象

Random的作用：产生一个指定范围内的伪随机数（常用生成整数）

使用步骤：

步骤1：导包 import java.util.Random;

步骤2：创建对象 Random r = new Random();

步骤3：获取随机数 int number = r.nextInt(范围); // 左包含右不包含

（1）范围处填写一个整数，代表指定0到该整数（左包含右不包含）的范围

（2）获取一个min到max之间的随机整数，包含min和max，万能公式：(max - min + 1) +min;

七、数组

7.1 数组的概念及作用

什么是数组：数组(array)是一种容器，可用来存储多个相同类型的数据

建议：数组容器的类型，和存储的数据类型保持一致!

7.2 数组的定义格式

格式1：数据类型[] 变量名

范例：int[ ] arr（推荐使用的格式）

格式2：数据类型变量名[]

范例：int arr[ ]

7.3 数组动态初始化

Java中的数组(变量)必须先初始化，然后才能使用

初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器的过程

数组动态初始化的格式：

数据类型[] 变量名 = new 数据类型[长度];

范例：int[] arr = new int[5];

//动态初始化了一个数组，数组名是arr，长度为5，该数组能存储5个int类型数据

打印数组变量名会出现什么：

数组的内存地址：

1.[：表示一维数组

2.@：连接符

3.I：int的意思，表示数组中存储的数据类型

4.数字和字母的组合串：该数组16进制的内存地址

7.4 数组元素访问

什么是索引：索引是数组容器中空间的编号，可以用来标识数组中元素的位置

索引的特点：

特点1：从0开始

特点2：索引是连续的

特点3：逐个+1

数组元素访问的格式：

数组名[索引];

范例：arr[0]; // 获取该数组第一个元素

7.5 Java内存图

一个数组内存图

Java中内存分配：

栈内存：方法运行时，进入的内存空间；局部变量也存放于栈内存中

堆内存：new出来的内容进入堆内存，并且会产生地址值

方法区：字节码文件(.class)加载时进入的内存空间

本地方法栈：调用操作系统相关资源

寄存器：交给CPU使用

Java中数据的默认值：

整数：0 浮点数：0.0 布尔：false 字符：空字符引用数据类型：null

引用数据类型：引用，记录了地址值的变量，所对应的数据类型就是引用数据类型

范例：int[] arr = new int[3];

// 数组的变量就是引用数据类型

两个数组内存图

多个数组指向相同内存图

当多个引用指向相同的内存，如果其中一个引用，改变了内存中的内容，其他引用看到的都是"改变后的内容"

理解：多个人牵同一条狗，任何人对狗的操作都会使其看到操作后狗的样子

7.6 数组静态初始化

数组静态初始化的格式：

数据类型[] 变量名 = new 数据类型[]{元素1, 元素2, ...};

范例：int[] arr = new int[]{1, 2, 3};

简化格式：简化了new int[]的书写

范例：int[] arr = {1, 2, 3}; （推荐使用的格式）

7.7 应用场景

静态初始化：知道数组具体元素（给元素）

动态初始化：不知道具体元素，但是知道数组长度时（给长度）

数组操作的两个常见问题

索引越界异常 ArrayIndexOutOfBoundsException：操作了不存在的索引

空指针异常 NullPointerException：访问的引用类型不再指向堆内存

数组遍历：是指将数组中的所有数据取出来（打印、判断、求和等后续操作）

八、方法

8.1 方法概述

什么是方法：一段具有独立功能的代码块，不调用就不执行

方法有什么好处：可以提高代码的复用性

方法使用须知：

1.方法必须先创建才可以使用（方法定义）

2.方法创建后并不是直接运行的，需要手动调用（方法调用）

8.2 方法的定义和调用

带返回值格式:

public static 返回值类型方法名(参数列表){ 方法体; return 返回值; }

不带返回值格式:

public static void 方法名(参数列表){ 方法体; }

通用格式:

修饰符返回值类型方法名(参数类型参数名1,参数类型参数名2,．．．．．．){

方法体;

return 返回值;
}

如果调用了一个没有定义的方法：程序会报错

方法没有被调用：在方法区

方法被调用时加载到了哪里：栈内存

栈内存：栈内存特点是先进后出，后进先出（子弹匣子）

8.3 带参数方法的定义和调用

注意事项：

1. 参数中的数据类型与变量名都不能缺少，否则程序报错

2. 多个参数之间使用逗号分隔

3. 调用带参数的方法时，参数的数量、类型必须与方法定义中设置的匹配，否则程序报错

形参和实参

什么是形参：形式参数，是指方法定义时的参数；作用是接收实参

什么是实参：实际参数，是指方法调用时的参数；也就是实际参与运算的数据，由调用者指定

8.4 带返回值方法的定义和调用

为什么要有带返回值的方法：我们经常会根据一个方法产出的结果，去组织另一段代码逻辑，为了拿到这个方法产生的结果，就需要定义带返回值的方法

return关键字的作用：返回返回值（并且停止方法）

注意事项：

1. return后面的返回值，与方法定义上的数据类型要匹配，否则报错

2. 方法的返回值通常会使用变量接收，否则该返回值将无意义

方法通用定义格式

方法定义时的两个明确：

明确1：返回值类型

该方法需不需要返回一个结果? 它是什么类型的? 如果不需要返回一个结果，在返回值类型处写void

明确2：参数列表

该方法执行过程中，需不需要原材料（实际参与运算的数据），如果需要，写在参数列表中，由数据和变量名组成；有多个参数，使用逗号分隔；如果不需要则不写

8.5 方法的注意事项

定义方法时：

1：参数中的数据类型与变量名都不能缺少，否则程序报错

2：多个参数之间使用逗号分隔

3：方法不能嵌套定义

4：return后面的返回值与方法定义上的数据类型要匹配，否则报错

5：方法的返回值为void，表示该方法没有返回值，可以省略return不写

6：return的作用是返回返回值，并且停止方法；所以return语句下面不能编写代码，属于无效语句会报错

调用方法时：

1：调用带参数的方法时，参数的数量、类型必须与方法定义中设置的匹配，否则程序报错

2：如果调用了一个有返回值的方法，需要用相同类型变量接收，否则返回值将无意义

方法调用的三种方式：

1. 直接调用：用于调用没有返回值的方法（如果调用有返回值的方法，那么将无意义）

2. 赋值调用：必须调用有返回值的方法（将返回值使用相同类型变量接收，用于后续操作）

3. 打印调用：必须调用有返回值的方法（在输出语句中调用方法，相当于直接打印了返回值）

8.6 方法的重载

方法重载的概念：在同一个类中，出现了方法名相同，参数列表不同（数量、类型、顺序）的方法，我们称这些方法构成了重载；方法的重载与返回值无关

方法重载的好处：不用记忆过多繁琐的方法名

8.7 方法的参数传递

传递基本类型：传递的是“记录的具体数值”，形参的改变，不会影响实参

传递引用类型：传递的是“地址值”，形参的改变，会影响实参

8.8 Debug

Debug 介绍与操作流程：

Debug：是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序

Debug调试又称为断点调试：断点就是一个标记，告诉Debug从标记的位置开始查看

Debug操作流程：

1.打断点：在代码行号后面，点击出一个小红点，开启Debug运行模式后，从标记的地方开始查看

2.在代码区域右键，单击Debug执行即可

3.看Debugger窗口

（1）Frames：看代码运行到哪里了

（2）Variables：看代码执行过程中变量的变化

4.看Console窗口：看代码执行过程中的结果展示，可以录入要录入的数据

5.点Step Into 这个箭头下一步

6.点Stop结束

7.选择要删除的断点，单击鼠标左键即可，或者批量删除

九、进制

9.1 进制的介绍与书写格式

进制：指进制位，是人们规定的一种进位方式

常见进制：

二进制：数据使用0和1表示，逢二进一，借一当二（0b开头，b大小写均可）

八进制：由0到7八个数字组成，逢八进一（0开头）

十进制：逢十进一，借一当十（Java中数值默认是10进制，不需要修饰）

十六进制：由0到9，a到f组成，其中a到f表示10到15，字母大小写均可（0x开头，x大小写均可）

任意进制到十进制的转换：系数*基数的权次幂相加

系数：每一位上的数据本身，不带进制标识

基数：几进制转换，基数就是几

权：从右朝左，0开始逐个+1

十进制到任意进制的转换：除基取余法

使用源数据，不断的除以基数（几进制转换，基数就是几）得到余数，直到商为0，再将余数【倒着拼接】起来即可

9.2 快速进制转换法

8421码：又称BCD码，是BCD码中最常用的一种

BCD： (Binary-Coded Decimal) 二进制码十进制数在这种编码方式中，每一位二进制值的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数

二进制，快速转十进制：

128 - 64 - 32 - 16 - 8 - 4 - 2 - 1

将二进制的值，从左边套入其中，0对应的值不取，1对应的值取出来相加即可

二进制，快速转八进制：

将三个二进制位看为一组，分别套入上述公式，将结果拼接（注意不是加）

原因：八进制逢八进一，三个二进制位最多可以表示111，也就是数值7（套入上条公式），如果出现第四位，就超范围了

二进制，快速转十六进制：

将四个二进制位看为一组，如果不够使用0补位，分别套入上述公式，将结果拼接（注意不是加）

原因：十六进制逢十六进一，四个二进制位最多可以表示1111，也就是数值15，如果出现第五位，就超范围了

9.3 原码反码补码

计算机中的数据，都是以二进制补码的形式在运算，而补码则是通过反码和原码推算出来的

原码：给人看的，可通过8421码，推算出具体数值

就是二进制定点表示法，即最高位为符号位，0表示正，1表示负，其余位表示数值的大小

反码：转换的桥梁

正数的反码与其原码相同，负数的反码是对其原码逐位取反，但符号位除外

补码：计算机底层运算使用补码，也就是真正做运算的

9.4 位运算

基本位运算符

什么是位运算：

是二进制位的运算，需要先将十进制数转为二进制后，再进行运算

在二进制位运算中1和0表示什么：1表示true，0表示false

位运算符：

& 位与：将十进制数转为二进制后竖式运算，遇false则false，遇0则0

| 位或：将十进制数转为二进制后竖式运算，遇true则true，遇1则1

^ 位异或：将十进制数转为二进制后竖式运算，相同为false，不同为true

~ 取反：将十进制数转为二进制后竖式运算，全部取反，0变1，1变0（包括符号位）

异或运算符的特点：

一个数被另一个数，异或两次，该数本身不变

位移运算符

<< 有符号左移：二进制位向左移动，符号位丢弃，右边补齐0

运算规律：向左移动几位，就是乘以2的几次幂

>> 有符号右移：二进制位向右移动，使用符号位进行补位

运算规律：向右移动几位，就是除以2的几次幂

>>> 无符号右移：无论符号位是0还是1，都补0

几乎没什么使用场景

十、二维数组

10.1 二维数组概述

什么是二维数组：用于存储一维数组的数组(容器)

10.2 二维数组动态初始化

二维数组的定义格式：

格式1：数据类型[] [] 数组名（常用）

格式2：数据类型数组名[] []

格式3：数据类型[] 数组名 []

动态初始化格式：

数据类型数组名[] [] = new 数据类型[m] [n];

m表示：该二维数组可以存放几个一维数组

n表示：每个一维数组可以存放多少个元素

10.3 二维数组访问元素的细节问题

（1）二维数组中存储的都是一维数组，可以将创建好的一维数组直接存入（存入的是一个一个一维数组的内存地址），存储完成后，增加其中一维数组的元素(增加长度)，程序不会报错

（2）如果使用动态初始化创建二维数组，就不能在后期，改变其中一维数组的长度了

10.4 二维数组静态初始化

静态初始化格式：

数据类型数组名[][] = new 数据类型[][] {{元素1,元素2,元素3 ..} , {元素1,元素2,元素3 ..}};

简化格式：省略书写 new 数据类型[][]

范例：int[][] arr = {{11,22,33},{44,55,66}};

十一、面向对象基础

11.1 面向对象的三大特征是什么

封装、继承、多态

11.2 类和对象

面向对象和面向过程的思想对比

两种思想的区别：

面向过程 POP：是一种以[过程]为中心的编程思想，功能的每一步，都是自己实现的

面向对象 OOP：是一种以[对象]为中心的编程思想，通过指挥对象实现具体的功能

面向对象是基于面向过程的

类和对象的关系

什么是类：类是对现实生活中，一类具有共同属性和行为的事物的抽象

类的组成有哪些：类由属性和行为组成

属性：该类事物所具有的共同特征 (成员变量)

行为：该事物存在的功能,能做的事情 (成员方法)

什么是对象：是看得见，摸得着的真实存在的物体

类是对事物也就是对象的一种描述，可以将类理解为一张设计图，根据设计图，可以创建出具体存在的事物

小结1、客观存在的任何一种事物，都可看做为程序中的对象（万物皆对象）

小结2、使用面向对象思想可以将复杂问题简单化

小结3、将我们从执行者的位置，变成了指挥者

类的定义

类的属性和行为，在代码中通过什么体现：

属性：成员变量（类中方法外的变量）

行为：成员方法（和前面学习的方法相比不带static关键字）

定义一个类的步骤：

步骤1、创建Java文件编写类名

步骤2、编写类的成员变量

步骤3、编写类的成员方法

类创建完成后，不能直接右键运行：

因为我们没有提供main方法，我们需要再创建一个测试类，在测试类中先创建对象，再进行测试

对象的创建和使用

如何创建对象：

格式：类名对象名 = new 类名();

范例：Student stu = new Student();

注意：类名就是对象的[数据类型]

如果我们打印一个对象名，控制台会打印该对象的内存地址：

全类名(包名+类名)@十六进制内存地址

11.3 对象内存图

单个对象内存图

new出来的对象：在堆内存开辟空间

成员变量：有默认初始化值

两个对象内存图

当出现多次new的动作时，字节码文件不会多次加载：

我们通常使用一张"设计图"，就可以创造出多个"对象"

两个引用指向同一个对象内存图

对象类型的变量，是什么类型的数据：

引用类型

对象类型的变量，记录了什么：

记录了该对象的内存地址

垃圾回收：当堆内存中，对象和数组产生的地址，通过任何方式都不能被找到后，就会被判定为内存中的"垃圾"，垃圾会被"Java垃圾回收器"在空闲时间自动进行清理

11.4 成员变量和局部变量

成员变量和局部变量的区别：

区别1、类中位置不同

成员变量：类中方法外

局部变量：方法内或方法声明上

区别2、内存中位置不同

成员变量：堆内存（跟随对象走，对象是new出来的进堆）

局部变量：栈内存（跟随方法进栈）

区别3、生命周期不同

成员变量：随对象的存在而存在，随对象的消失而消失

局部变量：随方法的调用而存在，随方法的弹栈而消失

区别4、初始化值不同

成员变量：有默认初始化值

局部变量：没有默认初始化，必须先定义赋值，再使用

十二、封装

12.1 什么是封装

隐藏实现细节，仅对外暴露公共的访问方式

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

封装常见的体现

体现1、私有成员变量，并对外提供getXxx()、setXxx()方法

体现2、将代码，抽取到方法中，这是对代码的一种封装

体现3、将属性，抽取到类中，这是对数据的一种封装

封装的好处：

好处1、提高了代码的安全性

好处2、提高了代码的复用性

12.2 private关键字

什么是private关键字：

private，私有的意思，是一个权限修饰符，可修饰成员（成员变量、成员方法）

private关键字的特点：

被private修饰的成员，只能在本类中被访问

被private修饰的成员变量，可能被其他类使用，所以我们在本类中，需要提供public修饰的getXxx()、setXxx()方法，让其他类操作私有的成员

private关键字的使用

(不完全)标准类的编写

要求1、将所有成员变量使用private修饰

要求2、提供对应的getXxx()、setXxx()方法

12.3 this关键字

this关键字的作用：

作用1、可以调用本类的成员变量、成员方法

this.成员变量

this.成员方法

作用2、解决局部变量和成员变量重名问题

理解：方法被哪个对象调用，方法中的this就代表哪个对象！

十三、构造方法

13.1 什么是构造方法

什么是构造方法：

创建对象时，所调用的方法

13.2 构造方法的格式特点

特点1、方法名与类名相同

特点2、没有返回值，连void都没有

特点3、没有具体的返回值（不能由return带回结果数据）

执行时机是什么时候：

创建对象时候会自动调用。每创建一次对象，就会执行一次构造方法（注意不能手动调用构造方法）

构造方法的作用：

创建对象，给对象的数据进行初始化

构造方法的注意事项：

注意1、如果没有定义构造方法，系统会给一个默认空参构造（父类哪里继承来的）

注意2、如果定义了构造方法，系统就不会提供默认构造方法了（所以以后定义类时，空参带参都提供）

13.3 空参构造和带参构造的区别

与类名相同有参数的是带参构造无参数的是空参构造

注意:

1.如果在创建对象时不写参数，调用的就是无参的构造方法。可是如果你写的有有参的构造方法，而没有无参的构造方法，那么再“创建对象时不写参数”就会报错，程序会认为你知道该怎么做。

2.如果构造方法有参数，在创建对象时传入了参数，那么就会调用此方法，这一点和重载类似。

空参构造的作用是：实例化一个对象

带参构造的作用是：初始化类中的属性

十四、字符串

14.1 API

API：application应用 programing编程 interface接口

API概述 - 帮助文档的使用

什么是帮助文档：

一些定义好的类的使用说明文档（理解为字典）

帮助文档的查看流程：

查看1、当前类所在的包（继承体系）

查看2、基本介绍

查看3、构造方法（创建对象）

查看4、成员方法（常用方法）

14.2 键盘录入字符串

Scanner的哪些方法可以获取控制台录入的字符串：

方法1、next() 结束标识是空格键、tab键

方法2、nextLine() 结束标识是回车键

14.3 String

String概述

java.lang包下的类的使用特点：使用时，不需要导包

字符串对象一旦创建，对象的内容是否可以更改：

不可以（字符串是常量，底层被final修饰）

String类常见构造方法

打印String的变量名，会不会打印对象的内存地址值：

不会，而是打印了该字符串对象所记录的内容

创建String对象的四种方式

方式1、public String() 创建一个空白字符串对象

方式2、public String(char[] chs) 根据字符数组的内容，创建字符串对象

方式3、public String(String original) 根据传入的字符串内容，创建新的字符串对象

方式4、String s = "abc"; 直接赋值的方式创建

创建String对象的区别和对比：

==比较基本类型，和引用类型的区别：

情况1、比基本类型：比的是数据[具体值]

情况2、比引用类型比的是[地址值]

构造方法和双引号创建字符串对象，有什么区别：

使用""创建的字符串：

只要字符序列相同(顺序和大小写)，无论在程序中出现几次，JVM都只会建立一个String对象，并在字符串常量池中维护

结论：使用""创建的String对象，在字符串常量池

new出来的字符串：

每一次new都会在堆内存申请新的内存空间；就算内容相同，但是地址不同

结论：使用new创建的String对象，在堆内存

当使用双引号创建字符串对象时，系统会检查该对象，在字符串常量池中是否存在：

存在，则不会重新创建，直接拿来使用

不存在，则创建

字符串常量池，在JDK7版本开始，从方法区中挪到了堆内存

String特点

字符串对象有哪些特点：

特点1：Java程序中所有双引号引起来的内容，都是String类的对象

特点2：字符串内容不可变，它们的值在创建后不能被更改（在底层被final修饰，所以它是一个常量）

特点3：虽然String的内容不可变，但是可以被共享（结合常量池理解：如果使用""创建String，系统会检测常量池中有没有相同内容的，如果有相同内容的，直接拿来使用）

特点4：String在java的lang包下，使用时不需要导包

当字符串使用+号拼接时，底层是怎么执行的：

系统底层会自动创建一个StringBuilder对象，然后调用其append方法完成拼接，再将拼接的结果，调用toString方法转换为String对象

Java常量优化机制：

如果是常量"a"+"b"+"c"，那么在编译时，就会将它们拼接为"abc"。由于内容一样，且都是通过双引号创建，所以在内存中维护的是同一个对象

String方法小结：

boolean equals(Obj obj); 比较字符串内容，严格区分大小写

boolean equalsIgnoreCase(Obj obj); 比较字符串内容，忽略大小写

int length(); 返回字符串长度

char charAt(int index); 返回指定索引处的char值

char[] toCharArray(); 将字符串拆分为一个字符数组并返回

String substring(int 开始索引, int 结束索引); 根据传入的两个索引，左包含右不包含地截取，并返回新的字符串

String substring(int index); 从传入的索引截取到字符串末尾，并返回新的字符串

String replace(被替换的子串, 新的子串); 使用新值替换字符中所有旧值，并返回新的字符串

String[] split(String "标识"); 根据传入的标识切割字符串，返回字符串数组

14.4 StringBuilder

StringBuilder 概述

StringBuilder：

是一个可变的字符串类，我们可以将它看做是一个用来操作字符串对象的容器

StringBuilder的作用：

提高字符串操作的效率

System.currentTimeMillis();

可以获取当前系统时间的毫秒值

StringBuilder 构造方法

构造1、空参构造

StringBuilder sb = new StringBuilder();

创建一个空的sb对象

构造2、带参构造

StringBuilder sb = new StringBuilder("肆月廿");

根据传入的字符串，创建一个可变的字符串对象（也就是sb对象）

StringBuilder 常用的成员方法

常用方法1、public StringBuilder append(任意类型); 拼接数据，并返回对象本身

常用方法2、public StringBuilder reverse(); 返回相反的字符序列

常用方法3、public int length(); 返回长度（字符出现的个数）

常用方法4、public String toString(); 将当前的sb对象转换为String对象

StringBuilder 提高效率的原理

字符串使用+号拼接，堆内存会有什么现象?

一个+号创建了两个对象（一个sb一个String）

String和StringBuilder的区别?

String创建出来内容不可变，StringBuilder内容可变

十五、集合

15.1 什么是集合

提供一种存储空间可变的存储模型，存储的数据容量可以发生改变

通常，我们的Java程序需要根据程序运行时才知道创建了多少个对象。但若非程序运行，程序开发

阶段，我们根本不知道到底需要多少个数量的对象，甚至不知道它的准确类型。为了满足这些常规

的编程需要，我们要求能在任何时候，任何地点创建任意数量的对象，而这些对象用什么来容纳

呢？我们首先想到了数组，但是！数组只能存放同一类型的数据，而且其长度是固定的，那怎么办

了？集合便应运而生了

15.2 集合和数组的区别对比

共同点：都是存储数据的容器

不同点：数组容量固定，集合容量可变

15.3 ArrayList构造方法和添加方法

如何创建一个集合对象：

ArrayList list = new ArrayList(); //不完整格式

ArrayList<泛型> list = new ArrayList<>();

如果不指定集合泛型，那么集合可以存储多个不同类型数据，但是这样的需求少之又少，所以创建集合对象我们需要指定泛型

泛型的作用：

对集合存储的类型的数据进行限制（只能填写引用数据类型）

集合如要存基本数据类型，泛型需怎么写：

要写基本类型对应的包装类(引用类型)

除了int的包装类是Integer，char的包装类是Character这两个特殊，其余都是首字母大写（Byte、Short、Long、Float、Double、Boolean）

集合的添加方法

boolean add(E e); 将指定元素追加到集合末尾

boolean add(int index, E e); 将指定元素插入到指定索引处

ArrayList常用成员方法

boolean remove(Obj o); 删除指定的元素，返回是否删除成功

E remove(int index); 根据索引删除元素，返回被删除的元素

E set(int index, E e); 修改指定索引处的元素，返回被修改的元素

E get(int index); 返回指定索引处的元素

int size(); 返回集合中元素个数

Java SE 基础知识汇总相关推荐

Java SE 基础知识
Java SE 基础知识 1 2 @(Notes)[J2SE, Notes] VICTORY LOVES PREPARATION. 特别说明: 该文档在马克飞象查阅最佳: 本部分知识还在迭代中,欢迎补 ...
Java SE 基础知识体系梳理
## Java SE 基础知识体系梳理 ----------day01------------- (1)计算机的体系结构 (2)Java语言的概述 (3)开发环境的搭建和使用 1.计算机的体系结构(常 ...
Java复习总结（二）Java SE基础知识
Java SE面试题目录 Java SE基础基本语法数据类型关键字面向对象集合集合类概述 Collection接口进阶线程锁 JDK 反射 JVM GC io操作和NIO,AIO ...
JAVA SE基础知识总结
JAVA基础篇 1_JAVA语言概述 1.1 JAVA的总体概述 1.2 JAVA语言概述 1.2.1 基础常识 1.2.2 计算机语言的发展迭代史 1.2.3 Java语言版本迭代概述 1.2.4 ...
Java SE 基础知识(一)
一.基础知识 1. Java SE : Java Standard Edition Java ME : Java Micro Edition Java EE : Java Enterprise Edi ...
java重要基础知识汇总
Table of Contents 关于java语言设计理念抽象类与接口的区别是什么 java为什么不支持多继承 java里的枚举实现机制是什么 java中的内部类关于类Collections,A ...
Java SE基础知识(二)--整数的运算符
Java SE 是什么,包括哪些内容(二)? 本文内容参考自Java8标准一.代码运行机制相关的内容: 1.Java中的类型分类("你编程时能使用的类型全部在这里了"): ⑴.J ...
准备Java面试之Java SE基础知识——问题篇
由于这个月要开始面试了,所以重新把java SE的基础重新学习一遍,主要问题有如下37条.我将会在一周内更新完成答案. 作者:Xoper.ducky 链接:https://www.nowcoder.c ...
Java核心基础知识汇总
3.1.Java简介(了解) Java是一门编程语言,Java发展到今天,已经成为了一个真正意义上的语言标准,如果学习过(C.C++.Java)可以发现语法结构是很类似的,但是Java的标准指的是一种 ...

Java SE 基础知识汇总

目录

一、Java概述

1.1 Java语言背景

1.2 Java语言的三个版本

1.3 Java语言的跨平台原理

1.4 JRE和JDK

1.5 DOS命令

二、Java环境搭建

2.1 环境变量的配置

三、Java基础语法

3.1 注释

3.2 关键字（保留字）

3.3 常量

3.4 变量

3.5 数据单元

3.6 数据类型

3.7 标识符

3.8 键盘录入对象 Scanner

四、类型转换

4.1 隐式转换(自动转换)

4.2 强制转换

五、运算符

[ 1 ] 算数运算符

[ 2 ] 自增自减运算符

[ 3 ] 赋值运算符

[ 4 ] 关系运算符

[ 5 ] 逻辑运算符

[ 6 ] 三元运算符

六、分支结构

6.1 流程控制语句

6.2 分支结构 - if语句

6.3 分支结构 - switch语句

6.4 循环结构 - for循环

6.5 循环结构 - while循环

6.6 循环结构 - do...while循环

6.7 死循环

6.8 跳转控制语句

6.9 Random随机数对象

七、数组

7.1 数组的概念及作用

7.2 数组的定义格式

7.3 数组动态初始化

7.4 数组元素访问

7.5 Java内存图

7.6 数组静态初始化

7.7 应用场景

八、方法

8.1 方法概述

8.2 方法的定义和调用

8.3 带参数方法的定义和调用

8.4 带返回值方法的定义和调用

8.5 方法的注意事项

8.6 方法的重载

8.7 方法的参数传递

8.8 Debug

九、进制

9.1 进制的介绍与书写格式

9.2 快速进制转换法

9.3 原码 反码 补码

9.4 位运算

十、二维数组

10.1 二维数组概述

10.2 二维数组动态初始化

10.3 二维数组访问元素的细节问题

10.4 二维数组静态初始化

十一、面向对象基础

11.1 面向对象的三大特征是什么

11.2 类和对象

11.3 对象内存图

11.4 成员变量和局部变量

十二、封装

12.1 什么是封装

12.2 private关键字

12.3 this关键字

十三、构造方法

13.1 什么是构造方法

13.2 构造方法的格式特点

13.3 空参构造和带参构造的区别

十四、字符串

9.3 原码反码补码