Java基础

1. 搭建 JAVA 环境

1.1 JAVA 语言发展史

1.1.1 什么是语言？

• 语言：人与人交流沟通的表达方式

1.1.2 什么是计算机语言

• 计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言

1.1.3 JAVA 语言

• Java语言是美国 Sun 公司在 1995 年推出的计算机语言
• Java之父：詹姆斯·高斯林

1.1.4 JAVA 语言发展史

• Java8 企业用的最多的版本
• Java15 我们学习的版本

1.2 JDK 的下载与安装

1.2.1 官网下载

• 第一步：在浏览器输入地址栏输入 http://www.oracle.com
• 第二步：选择 Products，找到 Java
• 第三步：找到 Download Java 点击
• 第四步：找到 JDK Download 点击
• 第五步：根据不同操作系统，选择对应的 JDK。我们大部分使用的都是 windows，故这里选择 windows 对应的 jdk，然后点击
• 第六步：在弹出的界面中，选择接受协议，继续点击下载，即可得到 JDK 的安装包

1.2.2 安装步骤

• 傻瓜式安装，下一步即可
• 可以自己修改安装路径
• java 和 javac 这两个命令在 bin 目录

1.3 Notepad++ 的安装与配置

1.3.1 可以自己修改安装路径

1.3.2 配置

默认语言 + 编码配置

• 第一步：选择设置下面的首选项
• 第二步：在弹出的窗体里面，左边选择新建，中间选择 Java，右边选择 ANSI。然后关闭即可

1.4 Path 环境变量配置

• 新建 JAVA_HOME 变量 (系统变量)
  • 变量值：安装路径
• 编辑 Path 变量
  • 新增 %JAVA_HOME%\bin

1.5 HelloWorld 案例

1.5.1 Java程序开发流程

• 编写程序

  public class HelloWorld {
       
  	public static void main(String[] args) {
       
  		System.out.println("HelloWorld");
  	}
  }
  

• 编译程序 javac 文件名.java

• 运行程序 java 类名

1.6 常见问题

• 单词拼写（大小写 / 关键字）

• 非法字符：中英文符号问题

1.7 三大平台

• JavaSE（Java 语言的标准版）
• JavaME（Java 语言的小型版）
• JavaEE（Java 语言的企业版）

1.8 Java的主要特性

1.9 JRE 和 JDK

• JDK：开发工具 （JRE + 开发工具）
• JRE：运行环境 （JVM + 核心类库）
• JVM：保证跨平台
• JDK > JRE > JVM

2. 基础语法

2.1 注释

2.1.1 什么是注释

• 注释是在程序指定位置添加的说明性信息
• 注释不参与程序运行，仅起到说明作用

2.1.2 注释的分类

• 单行注释：// 注释信息
• 多行注释：/* 注释信息 */
• 文档注释：/** 注释信息 */

2.2 关键字

2.2.1 什么是关键字

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

2.2.2 关键字的特点

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

2.3 常量

2.3.1 什么是常量

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

2.3.2 常量的分类

• 字符串常量
• 整数常量
• 小数常量（浮点数）
• 字符常量
• 布尔常量（true，false）
• 空常量（null）

2.4 数据类型

2.4.1 计算机存储单元

计算机存储设备的最小信息单元：位 (bit)，用 b 表示

计算机中最小的存储单元：字节 (byte)，用 B 表示

B 和 b 的关系：

• 1B (字节) = 8b (bit)

常见的存储单位：

• 1TB = 1024GB
• 1GB = 1024MB
• 1MB = 1024KB
• 1KB = 1024B

2.4.2 数据类型分类

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

2.5 变量

2.5.1 什么是变量

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

2.5.2 变量的定义

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

• 范例：

  int a = 10;
  

2.5.3 变量的使用

1：取值

• 格式：变量名

• 范例：

  a
  

2：修改值

• 格式：变量名 = 数据值;

• 范例：

  a = 20;
  

2.5.4 变量的注意事项

• 名字不能重复
• 变量未赋值，不能使用
• 定义 long 类型变量，为了防止整数过大，数据后面加 L
• 定义 float 类型变量，为了防止类型不兼容，数据后面加 F

2.6. 标识符

2.6.1 什么是标识符

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

2.6.2 组成规则

• 由数字、字母、下划线 ( _ ) 和美元符 ( $ ) 组成

2.6.3 注意事项

• 不能以数字开头
• 不能是关键字
• 区分大小写

2.6.4 命名约定

2.6.4.1 小驼峰命名法：方法，变量

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

• 范例1：name

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

• 范例2：firstName

2.6.4.2 大驼峰命名法：类

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

• 范例1：Hello

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

• 范例2：HelloWorld

温馨提示：最好能做到见名知意

2.7 类型转换

2.7.1 类型转换分类

在 Java 程序中，根据需要，不同的基本数据类型的值可能会需要进行相互转换

针对 Java 语言所提供的7种数值类型之间可以相互装换

• boolean 类型不是数值型，因此不能参与转换

有两种类型转换方式：

• 隐式转换
• 显式转换

2.7.2 隐式转换

• 也叫自动类型转换，由系统自动完成

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

• 范例：

  double d = 10;
  

  

2.7.3 显式转换

• 也叫强制类型转换

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

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

• 范例：

  int k = (int)88.88;
  

• 注意：显式转换的数据可能丢失精度

3. IDEA

3.1 IDEA 概述和安装

3.1.1 IDEA概述

• IDEA：全称 Intellij IDEA，是用于 Java 语言开发的集成环境，是业界公认的目前用于 Java 程序开发最好的工具
• 集成环境：把代码编写，编译，运行，调试等多种功能综合到一起的开发工具

3.1.2 IDEA下载和安装

• 下载：https://www.jetbrains.com/idea

• 安装：傻瓜式安装，建议修改安装路径

  • 第一步：选中 IDEA 安装包双击，然后点击 Next 即可
  • 第二步：在这个界面不要着急点击 Next，我们需要修改安装路径
  • 第三步：修改安装路径，路径修改完毕后，点击 Next 继续
  • 第四步：在该界面选择 64-bit 即可，点击Next继续
  • 第五步：点击 Install 继续，等待软件安装
  • 第六步：点击 Finish 完成 IDEA 的安装

3.2 IDEA 中 HelloWorld

刚才我们完成了 IDEA 的安装，接下来我们要使用 IDEA 完成 HelloWorld 程序的开发。

而在讲解 HelloWorld 之前，我们先来做一下 idea 启动的基本配置流程讲解

3.2.1 IDEA 启动的基本配置

IDEA启动配置步骤：

• 第一步：如果出现 JETBRAINS USER AGREEMENT，选中接受协议，并点击 Continue 继续
• 第二步：如果出现 DATA SHARING，选择 Don’t Send 即可
• 第三步：如果出现 Config or installation directory，选择 Do not import settings，并点击 OK 继续
• 第四步：出现 Activate Intellij IDEA，需要选择免费试用，并点击 Evaluate 并继续
• 第五步：出现 Welcome to Intellij IDEA (Administrator)，说明 IDEA 启动的配置完成了

3.2.2 IDEA中HelloWorld步骤

• 新建一个空项目 (JavaSE_Code)

  • 左边选择 Projects，右边选择 New Project
  • 出现 Project SDK，不要选择 Java 项目，要选择空项目 (Empty Project)，点击 Next 继续
  • 修改项目名称 (JavaSE_Code) 和项目存储路径 (D:\IdeaProjects\JavaSE_Code)
  • 选择 Create 即可完成空项目的创建

• 新建一个新模块 (idea_test)

  • 空项目创建完毕后，会弹出 Project Structure，不要关闭，左边选择 Modules，右边选择 + 下面的 New Module
  • 这一次选择 Java，然后点击 Next 继续
  • 修改模块名称
  • 名称修改为：idea_test，然后点击 Finish
  • 模块新建成功，然后点击 OK 即可
  • 这个时候，我们在IDEA中能够看到
    • src 目录 (将来 Java 程序的代码就存储在这个目录下)
    • idea_test.iml (是 idea 自动创建的模块文件，存储了当前模块的配置信息)

• 在 idea_test 模块的 src 下新建一个包 (com.asaawan)

  • 选中 src，右键 New，选中 package
  • 输入包名称，然后回车即可

• 在 com.asaawan 包下新建一个类 (HelloWorld)

  • 选中com.asaawan，右键 New，选中 Java Class
  • 输入类名称，然后回车即可

• 在 HelloWorld 类中编写代码

  • 在类中编写 main 和输出语句即可

• 在 IDEA 中运行 HelloWorld

  • 在当前代码区域右键选中 Run 执行即可

3.3 IDEA中修改字体大小

• 选择File，找到 Settings…
• 选择 Editor 下面的 Font，右边 Size 填写 16 即可。也可以根据自己情况调整大小

3.4 IDEA中项目结构

3.5 IDEA中内容辅助剂和快捷键

现在我们对 IDEA 的工具已经有了一定的了解了，好像没看到哪里提高开发效率了，反而操作起来比较麻烦。

不要着急，提高效率的内容马上就来了

3.5.1 内容辅助键

快速生成语句

• main 方法：psvm，回车
• 输出语句：sout，回车

内容辅助键

• Ctrl + Alt + 空格键 (内容提示)

3.5.2 快捷键

注释

• 单行：选中代码，Ctrl + /，再来一次，就是取消
• 多行：选中代码，Ctrl + Shift + /，再来一次，就是取消

格式化

• Ctrl + Alt + L

3.6 IDEA中模块的操作

3.6.1 新建模块

• 选择 File，找到 Project Structure…
• 左边选择 Modules，右边选择 + 下面的 New Module
• 选择 Java，然后点击 Next 继续
• 修改模块名称，名称修改为：idea_demo，然后点击 Finish
• 模块新建成功，然后点击 OK 即可

3.6.2 删除模块

• 在演示删除模块前，我先到项目路径下，把刚才新建的模块复制一份保存放到D盘根目录下，为演示导入模块做准备

• 选中要删除的模块右键，Remove Module

• 意思是移除指定模块，但没有文件被删除，就是说，模块移除了，硬盘上的文件还在，选中 Remove 继续

• 打开硬盘上的文件，可以通过盘符目录找到，也可以采用这里提供的简单的方式：

  • 选择 idea_test 右键 Open In → Explorer
  • 快速打开模块所在目录

• 发现 idea_demo 这个内容确实还存在

• 想要彻底删除，在硬盘上，选中 idea_demo 右键，删除即可

3.6.3 导入模块

• 选择 File，找到 Project Structure…
• 左边选择 Modules，右边选择 + 下面的 Import Module
• 找到 D 盘提前准备好的 idea_demo 模块提前准备好的，点击 Ok 继续
• 点击 Next 继续
• 点击 Next 继续
• 点击 Next 继续
• 点击 Next 继续
• 选中 Overwrite 继续
• 点击 Finish 继续
• 现在就看到导入成功了，点击 OK 继续
• 注意：打开类文件，如果提示 Project JDK is not defined，按照右边的路径选中本机安装过的 JDK 即可

3.7 IDEA 新建空项目

• 选择 File → New → Project…
• 出现 New Project，不要选择 Java 项目，要选择空项目 (Empty Project)，点击 Next 继续
• 修改项目名称 (JavaSE_Code) 和项目存储路径 (D:\IdeaProjects\JavaSE_Code)
• 选择 Finish 即可完成空项目的创建

4. 运算符

4.1 算数运算符

在讲解具体的运算符之前，我们先来说一下什么叫运算符，什么叫表达式。

表达式：

• 用运算符把常量或者变量连接起来符合 java 语法的式子就可以称为表达式
• 不同运算符连接的表达式体现的是不同类型的表达式

举例说明：

int a = 10;
int b = 20;
int c = a + b;

+： 是运算符，算术运算符
a + b： 是表达式，由于 + 是算术运算符，所以这个表达式叫算术表达式

4.1.1 算数运算符

• /

  • 两数做除法，/ 取结果的商

• %

  • 两数做除法，% 取结果的余数

• 注意：整数相除只能得到整数，要想得到小数，必须有浮点数的参与

4.1.2 数值拆分

需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台

分析：

使用 Scanner 键盘录入一个三位数

• 个位的计算：数值 % 10

  • 123 除以 10（商 12，余数为 3）

• 十位的计算：数值 / 10 % 10

  • 123 除以 10 （商 12，余数为 3，整数相除只能得到整数）
  • 12 除以 10 （商 1，余数为 2）

• 百位的计算：数值 / 10 / 10 % 10

  • 123 / 10 / 10 % 10（123 / 10 得到 12，12 / 10 得到 1，1 % 10 得到 1）

4.1.3 字符的+操作

拿字符在计算机底层对应的数值来进行计算的

• ‘A’ 65 A-Z 是连续的
• ‘a’ 97 a-z 是连续的
• ‘0’ 48 0-9 是连续的

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

提升规则：

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

4.1.4 字符串的+操作

• 当 “+” 操作中出现字符串时，这个 “+” 是字符串连接符，而不是算术运算

  • “zhongguo”+ 666

• 在 “+” 操作中，如果出现了字符串，就是连接运算符，否则就是算术运算

• 当连续进行“+”操作时，从左到右逐个执行

  • 1 + 9999 + “岁zhongguo”
  • 结果：10000岁zhongguo

4.2 赋值运算符

赋值运算符：可以将一个常量赋值给变量，也可以将一个变量的值赋值给另一个变量。

4.2.1 赋值运算符

• = (赋值)
• += (加后赋值)
• -= (减后赋值)
• *= (乘后赋值)
• /= (除后赋值)
• %= (取余后赋值)
• 注意：扩展的赋值运算符隐含了强制类型转换

4.2.2 思考题

请问下面的程序有错误吗？如果有是哪一行？为什么？

① byte b = 10;

② b = b + 1;

③ b += 1;

程序有问题

• 第②行会出错
• b 是 byte 类型，和 int 类型的 1 做加法，根据表达式类型提升，结果是 int 类型
• ③ 之所以不出错，是因为 += 隐含了强制类型转换，最终把 int 类型结果转为了 byte 类型

4.3 自增自减运算符

4.3.1 自增自减运算符

• ++ (自增)
• – (自减)

4.3.2 注意事项

• ++ 和 – 既可以放在变量的后边，也可以放在变量的前边
• 单独使用
  • ++ 和 – 无论是放在变量后边，还是变量的前边，结果是一样的
• 参与操作
  • 如果放在变量的后边，先拿变量参与操作，后拿变量做 ++ 或者 –
  • 如果放在变量的前边，先拿变量做 ++ 或者 --，后拿变量参与操作
• 常见用法
  • 单独使用

4.4 关系运算符

4.4.1 关系运算符

• ==
• !=
• >
• >=
• <
• <=

4.4.2 注意事项

• 关系运算符的结果都是 boolean 类型，要么是 true，要么是 false
• 千万不要把 “==” 写成了 “=”

4.5 逻辑运算符

在数学中，一个数据x，大于3，小于6，我们可以这样来进行表示： 3 < x < 6

在 Java 中，需要把上面的式子先进行拆解，再进行合并表达

拆解为： x > 3 和 x < 6

合并后： x > 3 && x < 6

&& 其实就是一个逻辑运算符

我们可以这样说，逻辑运算符，是用来连接关系表达式的运算符

当然，逻辑运算符也可以直接连接布尔类型的常量或者变量

4.5.1 逻辑运算符

• &
  • 与
  • a & b，a 和 b 都是 true，结果为 true，否则为 false
• |
  • 或
  • a | b，a 和 b 都是 false，结果为 false，否则为 true
• ^
  • 异或
  • a ^ b，a 和 b 的结果不同为 true，相同为 false
• !
  • 非
  • !a，结果和 a 的结果正好相反

4.5.2 短路逻辑运算符

• &&
  • 与
  • 作用与 & 相同，但是具有短路效果
  • 注意事项
    • 逻辑与 &，无论左边真假，右边都要执行
    • 短路与 &&
      • 如果左边为真，右边执行；
      • 如果左边为假，右边不执行
• ||
  • 或
  • 作用与 | 相同，但是具有短路效果
  • 意事项
    • 逻辑或 |，无论左边真假，右边都要执行
    • 短路或 ||
      • 如果左边为假，右边执行；
      • 如果左边为真，右边不执行；

4.6 三元运算符

4.6.1 三元运算符格式

• 格式：关系表达式 ？表达式1 ：表达式2；
• 范例：a > b ? a : b;

4.6.2 三元运算符运算规则

• 首先计算关系表达式的值
• 如果值为 true，表达式 1 的值就是运算结果
• 如果值为 false，表达式 2 的值就是运算结果

5. 数据输入

我们目前程序中的数据都是固定的，程序不够灵活，为了提高程序的灵活性，我们也需要把数据的来源改进为输入数据。

而我们目前所学的知识还比较少，

不能够自己实现这个操作，只能够使用 Java 提供给我们的专门用于获取用户录入数据的类 Scanner。

下面我们来说一下 Scanner 的使用步骤。

5.1 Scanner 的使用步骤

• 导包

  import java.util.Scanner;
  

• 创建对象

  Scanner sc = new Scanner(System.in);
  

• 获取数据

  int i = sc.nextInt();
  

5.2 数据录入基本步骤练习

需求：用变量i接受键盘录入的 int 类型数据，并把i的结果输出在控制台

分析：

• 新建一个类 (ScannerTest01)

• 在类 ScannerTest01 定义的上面导包

• 在 main 方法中创建 Scanner 对象

• 定义 int 类型变量i获取键盘输入数据

• 输出变量 i 的值

5.3 导包的几种方式

• 手动导包
• 自动导包
  • Alt + Enter 导包
  • 写代码的时候，根据提示自动导包

5.4 数据求和

需求：键盘录入两个 int 类型数据，求两个数据之和，并把结果输出在控制台

分析：

• 新建一个类 (ScannerTest02)

• 在类 ScannerTest0 2定义的上面导包

• 在 main 方法中创建 Scanner 对象

• 定义 int 类型变量i获取键盘输入第一个数据

• 定义 int 类型变量j获取键盘输入第二个数据

• 定义 int 类型变量 k 接收 i + j 的结果

• 输出变量k的值

6. 流程控制语句

6.1 流程控制语句分类

• 顺序结构
• 分支结构：if，switch
• 循环结构：for，while，do…while

6.2 顺序结构

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

• 程序中大多数的代码都是这样执行的

  

6.3 分支结构

讲解完毕顺序结构后，接下来我们来学习分支结构，分支结构有两种语句：

• if 语句

• switch 语句

6.3.1 if 语句

if 语句是用来针对某些情况进行判断的，它又有三种情况：

• 针对 1 种情况的判断

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

• 针对 2 种情况的判断

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

• 针对多种情况的判断

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

6.3.2 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 相似

春夏秋冬案例

需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出

春：3, 4, 5

夏：6, 7, 8

秋：9, 10, 11

冬：12, 1, 2

注意事项：

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

在不判断下一个 case 值的情况下，向下运行，直到遇到 break，或者整个 switch 语句结束

6.3.3 Debug

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

它的两大作用，查看程序执行流程，调试程序。

由于目前我们每个程序的代码内容还比较少，

所以，今天重点掌握查看程序执行流程，当代码复杂的时候，我们需要通过debug来调试程序。

那么，debug操作的流程是什么样子的呢？

Debug 调试，又被称为断点调试，断点其实是一个标记，告诉我们从哪里开始查看

操作流程：

• 第一步：如何加断点

  • 选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可

• 第二步：如何运行加了断点的程序

  • 在代码区域右键 Debug 执行

• 第三步：看哪里

  • 看 Debugger 窗口
  • 看 Console 窗口

• 第四步：点哪里

  • 点 (Step Over F8) 开始
  • 点 (Stop) 结束

• 第五步：如何删除断点

  • 选择要删除的断点，单击鼠标左键即可
  • 如果是多个断点，可以每一个点击一次。也可以一次性全部删除
    • 第一步，点击两个红色小圆点
    • 第二步，点击 Java Line Breakpoints
    • 第三步，点击 “一”
    • 第四步，点击 Done

6.4 循环结构

6.4.1 for循环语句

6.4.1.1 for循环语句

格式：

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

格式说明：

• 初始化语句：
  • 这里可以是一条或者多条语句，这些语句用来完成初始化操作 (int i = 1)
• 条件判断语句：
  • 这里使用一个结果值为 boolean 类型的表达式，这个表达式能决定是否执行循环体语句 (i <= 5)
• 循环体语句：
  • 这里可以是任意语句，这些语句可能被多次执行
• 条件控制语句：
  • 这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果 (i++)

6.4.1.2 水仙花数

需求：在控制台输出所有的“水仙花数”

public static void main(String[] args) {
   
        //统计水仙花数的个数
        int count = 0;

        //确定水仙花数
        for (int i = 100; i < 1000; i++) {
   
            //获取个位、十位、百位
            int unit = i % 10;
            int decade = i / 10 % 10;
            int hundreds = i / 100 % 10;

            if (Math.pow(unit, 3) + Math.pow(decade, 3) + Math.pow(hundreds, 3) == i) {
   
                System.out.println(i);
                count++;
            }
        }

        //输出水仙花数的个数
        System.out.println("水仙花数的个数为：" + count);
}

6.4.2 while 循环语句

6.4.2.1while 循环语句

格式：

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

6.4.2.2 while 循环求偶数和

需求：求1-100之间的偶数和，并把求和结果在控制台输出

6.4.3 do…while 循环语句

6.4.3.1 do…while 循环语句

格式：

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

6.4.3.2 do…while 循环求偶数和

需求：求1-100之间的偶数和，并把求和结果在控制台输出

6.4.4 三种循环语句的区别

• 三种循环语句的区别

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

• for 和 while 的区别

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

• 死循环格式

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

6.5 跳转控制语句

6.5.1 跳转控制语句

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

7. 随机数

7.1 Random 的使用步骤

• 导包

  import java.util.Random
  

• 创建对象

  Random r = new Random();
  

• 获取数据

  int i = r.nextInt(10); //获取数据范围：[0,10) 包括 0，不包括 10
  

7.2 猜数字

需求：程序自动生成一个 1-100 之间的数字，使用程序实现猜出这个数字是多少？

当猜错的时候根据不同情况给出相应的提示

如果猜的数字比真实数字大，提示你猜的数据大了

如果猜的数字比真实数字小，提示你猜的数据小了

如果猜的数字与真实数字相等，提示恭喜你猜中了

分析：

• 要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，

  • 范围 1 到 100

• 因为无法预知几次能够猜中，因此猜数字这个操作应该是反复进行的，需要使用循环

  • 而 while 循环通常用于描述未知循环次数的循环

• 使用程序实现猜数字，每次均要输入猜测的数字值，

  • 需要使用键盘录入实现

• 比较输入的数字和系统产生的数据，需要使用分支语句。

  • 这里使用 if…else…if… 格式，根据不同情况进行猜测结果显示，当猜中后使用break结束循环即可

案例：

import java.util.Random;
import java.util.Scanner;

public class RandomTest {
   
    public static void main(String[] args) {
   
        //要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
        Random r = new Random();
        int number = r.nextInt(100) + 1;

        while(true) {
   
            //使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入你要猜的数字：");
            int guessNumber = sc.nextInt();

            //比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if..else..if..格式，根据不同情况进行猜测结果显示
            if(guessNumber > number) {
   
                System.out.println("你猜的数字" + guessNumber + "大了");
            } else if(guessNumber < number) {
   
                System.out.println("你猜的数字" + guessNumber + "小了");
            } else {
   
                System.out.println("恭喜你猜中了");
                break;
            }
        }
    }
}

8. 数组

8.1 数组定义格式

8.1.1 什么是数组

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

8.1.2 数组定义格式

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

  • 范例：

  • int[] arr;
    

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

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

  • 范例：

  • int arr[];
    

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

• 推荐使用：格式1

8.2 静态初始化

8.2.1 数组初始化

• Java 中的数组必须先初始化, 然后才能使用
• 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
• 注意：数组中的每一个数据，我们称之为数组中的元素

8.2.2 数组初始化方式

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

8.2.3 静态初始化

• 静态初始化：

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

• 格式：

  数据类型[] 变量名 = new 数据类型[]{
       数据1,数据2,数据3,…};
  

• 范例：

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

• 简化格式：

  数据类型[] 变量名 = {
       数据1,数据2,数据3,…};
  

• 范例：

  int[] arr = {
       1,2,3};
  

8.3 数组元素访问

8.3.1 数组元素访问

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

• 格式：

  数组名[索引]
  

8.3.2 索引是什么

• 索引是数组中数据的编号
• 作用：索引用于访问数组中的数据使用，数组名[索引] 等同于变量名，是一种特殊的变量名
• 特征 ① ：索引从 0 开始
• 特征 ② ：索引是连续的
• 特征 ③ ：索引逐一增加，每次加1

8.3.3 定义数组并获取元素

需求：定义一个 int 类型数组，用静态初始化赋值，然后获取数组中元素输出在控制台

控制台输出结果如下：

第一个元素：11

第二个元素：22

第三个元素：33

8.4 数组常见操作

• 遍历
• 最值
• 元素打乱

8.4.1 遍历

8.4.1.1 什么是数组遍历

• 获取数组中的每一个元素输出在控制台

8.4.1.2 获取数组长度 (元素个数)

• 格式：

  数组名.length
  

• 范例：

  arr.length
  

8.4.1.3 数组遍历通用格式

int[] arr = {
   ...};

for (int i = 0; i < arr.length; i++) {
   
    arr[i]; //对元素 arr[i] 进行操作
}

注：数组遍历指的是把数组中的元素取出来，取出来之后可以(打印，求和，判断…)

8.4.2 最值

需求：

已知数组元素为 {12, 45, 98, 73, 60}，请找出数组中最大值并输出在控制台

案例：

public class ArrayTest01 {
   
    public static void main(String[] args) {
   
        //定义数组
        int[] arr = {
   12, 45, 98, 73, 60};
        int max = arr[0];
        
        //找最大值
        for (int i = 1; i < arr.length; i++) {
   
            if (arr[i] > max) {
   
                max = arr[i];
            }
        }
        
        //输出数组中的最大值
        System.out.println("数组中的最大值为：" + max);
    }
}

8.4.3 元素打乱

4.3.1.1 数据交换

• 需求: 实现两个变量的数据交换

• 案例

  //定义两个变量
  int a = 10;
  int b = 20;
  
  //实现数据交换
  int temp = a;
  a = b;
  b = temp;
  

• 需求: 实现数组中第一个元素和最后一个元素的数据交换

• 案例：

  int[] arr = {
       1, 2, 3, 4, 5};
  
  int temp = arr[0];
  arr[0] = arr[arr.length - 1];
  arr[arr.length -1] = temp;
  

4.3.2.1 元素打乱

• 需求：

• 已知数组内部元素为 1 ~ 9 请将数组中元素随机打乱，随后遍历打印数组

• 分析：

  • 准备 Random 产生随机数
  • 循环遍历数组, 从 0 号索引开始访问每一个位置上的元素
  • 在循环中, 根据数组的长度产生随机数 – 表示随机索引位置
  • 数组元素交换
  • 遍历打印数组

• 案例：

  import java.util.Random;
  import java.util.Arrays;
  
  public class ArrayTest02 {
       
      public static void main(String[] args) {
       
          //定义数组
          int[] arr = {
       1, 2, 3, 4, 5, 6, 7, 8, 9};
          
          //创建随机数对象
          Random r = new Random();
          
          for (int i = 0; i < arr.length; i++) {
       
              int index = r.nextInt(9);
              int temp = arr[i];
              arr[i] = arr[index];
              arr[index] = temp;
          }
          
          //打印数组
          System.out.println(Arrays.toString(arr));
          
      }
  }
  

8.5 动态初始化

8.5.1 动态初始化

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

• 格式：

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

• 范例：

  int[] arr = new int[3];
  

8.5.2 数组元素来自键盘录入

• 需求：

• 定义一个可以存储 5 个元素的 int 数组，数据来自于键盘录入，最后遍历数组，把元素输出在控制台

• 分析：

  • 键盘录入，使用 Scanner 实现
  • 多个元素赋值，使用循环改进

• 案例：

  import java.util.Scanner;
  
  public class ArrayTest03 {
       
      public static void main(String[] args) {
       
          //定义数组
          int[] arr = new int[5];
          Scanner sc = new Scanner(System.in);
          
          //键盘键入数据
          for (int i = 0; i < arr.length; i++) {
       
              System.out.println("请输入第" + (i + 1) + "个数据：");
              arr[i] = sc.nextInt();
          }
  		System.out.println("----------");
          
          //遍历输出
          for (int item : arr) {
       
              System.out.println(item);
          }
      }
  }
  

• 小结：

  • 如果数组元素已知，用静态初始化
  • 如果数组元素长度已知，元素未知，用动态初始化

8.6 内存分配

8.6.1 Java 中内存分配

Java 程序在运行时，需要在内存中分配空间。

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

8.6.2 一个数组

8.6.3 两个数组

8.6.4 思考题

思考题1：

• 请问下列代码有问题吗？如果有，是什么问题？如何解决？

  int[] arr = new int[3];
  
  //输出元素
  System.out.println(arr[3]);
  

• 有问题

  • 访问了不存在的索引位置元素
  • 修改不存在的索引为正确的索引。范围 (0~数组长度 - 1)

思考题2：

• 请问下列代码有问题吗？如果有，是什么问题？如何解决？

  int[] arr = new int[3];
  System.out.println(arr[2]);
  
  //把 null 赋值给数组
  arr = null;
  
  //输出元素
  System.out.println(arr[0]);
  

• 有

• 对象不再指向堆内存，不能在继续访问数据

• 一般对象的使用：都先进行不为null的判断

  if(arr != null) {
       
  
    System.out.println(arr[0]);
  
  }
  

9. 二维数组

9.1 二维数组定义格式

9.1.1 什么是二维数组

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

需求：

假如我们要存储一个班级中多个学生的考试成绩，我们就可以采用数组来存储

现在的问题是？我们要存储多个班级的学生的考试成绩，该怎么办呢？

第一个班级：数组1

第二个班级：数组2

第三个班级：数组3

…

多个班级也可以采用数组存储啊？所以，Java 就提供了二维数组供我们使用

• 元素为一维数组的数组

9.1.2 二维数组定义格式

数据类型[][] 变量名;

数据类型 变量名[][];

数据类型[] 变量名[];

推荐使用：第一种格式

9.2 二维数组初始化

2.1 静态初始化

• 格式：

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

• 范例：

  int[][] arr = new int[][]{
       {
       1, 2, 3}, {
       4, 5, 6}, {
       7, 8, 9}};
  

• 解读：

  • 定义了一个二维数组
  • 二维数组中有三个元素（一维数组）
  • 每一个一维数组有三个元素（int 类型数据）

• 简化格式：

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

• 范例：

  int[][] arr = {
       {
       1, 2, 3}, {
       4, 5, 6}, {
       7, 8, 9}};
  

2.2 动态初始化

• 格式：

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

• 范例：

  int[][] arr = new int[2][3];
  

• 解读：

  • 定义了一个二维数组
  • 二维数组中有 2 个元素（一维数组）
  • 每一个一维数组有 3 个元素（int 类型数据）

9.3 二维数组常见操作

• 获取元素
• 遍历
• 元素打乱

3.1 获取元素

• 如何获取二维数组：

  数组名
  

• 如何获取每一个一维数组

  数组名[索引]
  

• 如何获取每一个二维数组元素：

  数组名[索引][索引]
  

3.2 二维数组遍历

需求：已知一个二维数组 arr = { {1,2,3},{4,5,6},{7,8,9}}; 请把元素在控制台输出

分析：

①循环嵌套的使用

②外层循环得到一维数组

③内存循环得到每一个二维数组元素

案例：

public class ArrayTest04 {
   
    public static void main(String[] args) {
   
		//定义数组
    	int[][] arr =  {
   {
   1, 2, 3}, {
   4, 5, 6}, {
   7, 8, 9}};
    
    	//遍历输出
        for (int i = 0; i < arr.length