一、计算机基础知识

在JAVA正式开始之前，我们首先了解一下计算机知识

计算机就是 电脑

1.1 计算机的由来

随着时代进步，计算机的体积不断减小，到现在的笔记本电脑

但是从始至终，计算机的作用没有变，就是数据处理和运算

编程开发其实也是一种数据处理和运算。

1.2 计算机中数据的存储和运算

• 结论：计算机中对于数据的存储和运算，都是通过二进制数据来完成的。

二进制：二进制数据就是用0和1两个数码来表示的
进制规则是“逢二进一”，借位规则是“借一当二”。

计算机都是由电路组成的，电路一般分为“通电”和“不通电”
计算机底层都是硬件电路，可以通过不通电，通电，表示0、1。

计算机中存储数据的单位是字节 byte
每个字节由8位组成 1 byte=8 bit

1.3 人机交互方式

早期计算机没有图形化界面，都是以指令的方式来操作计算机

命令行的操作方式 运行速度快 消耗内存小 在服务器中常用命令行操作

1.4 DOS命令行

常用DOS命令

符号	说明
盘符名称：	盘符切换。 E: 回车，表示切换到E盘
dir	查看当前路径下的内容。
cd 目录	进入单级目录。 cd itheima
cd..	回退上一级目录。
cd 目录1\目录2\...	进入多级目录。cd itheima\JavaSE
cd\	回退到盘符目录
cls	清屏
exit	退出命令提示符窗口

1.5 Path 环境变量

1.6 计算机语言

计算机语言：人与计算机之间沟通交流的方式

• 机器语言
  机器语言就是 0/1 代码，计算机只能识别 0 和 1 .
  在计算机内部，无论是一部电影或者一张图片，最终都是 0/1 代码。
• 汇编语言
  汇编语言就是将遗传苦哉的机器语言转化为英语单词
  比如说：add 1,2;
• 高级语言
  我们所学到的JAVA就是高级语言。
  System.out.println("你好老铁")
  使用普通英语进行代码编写，然后通过编译器翻译成类似于汇编语言的指令，之后由计算机执行
  

---

二、Java介绍和环境搭建

2.1 Java背景介绍

Java三大平台

• Java SE
  Java语言的（标准版），用于桌面应用的开发，是其他两个版本的基础。
  桌面应用：用户只需要打开程序，程序的界面会让用户在最短时间内找到他们需要的功能，同时主动带领用户完成他们的工作并得到最好的体验。
• Java ME
  Java语言的（小型版），用于嵌入式消费电子设备
• Java EE
  Java语言的（企业版），用于Web方向类网站开发
  网页：用于数据展示
  网站：网页+后台服务器

2.2 Java跨平台性

平台：指的是操作系统。

• Windows
• MacOS
• Linux

跨平台：Java程序可以在任意操作系统上运行

Java程序在运行时，不看操作系统，只看JVM虚拟机
JVM虚拟机本身不允许跨平台，允许跨平台的是Java程序

2.3 JDK的下载和安装

下载JDK

JDK官方下载网站： oracle官网网站

注意：针对不同的系统，下载不同版本的JDK 安装JDK必须安装在纯英文的路径下

2.4 第一个Java程序

编写第一个Java程序：

1、在电脑任意位置，新建一个TXT文本文档

2、将文本文档的名称及后缀名更改，HelloWorld.java

3、在里面编写Java代码

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

4、使用 javac.exe [编译] 使用 java.exe [运行]

Java开发步骤：编写 → 编译 → 运行

2.5 HelloWorld案例详解

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

class在Java中非常重要，被称为类（一般在代码中类class后面添加的是文件名）

main方法又叫做主方法，它就是我们程序执行的入口

System.out.println("Hello Java");这句被称为打印语句，用处是在控制台打印出（“”）中的内容。

public权限修饰符（限制类名称和文件名需要保持一致）

2.6 HelloWorld常见问题

Bug 原意是虫子或者臭虫，现在指的是电脑系统中或者程序的隐藏的一些问题或者漏洞

2.7 JDK的组成

JDK主要分为三部分 JVM虚拟器 核心类库 开发工具Java Javac...

JVM虚拟器 核心类库一般被称为JRE

2.8 配置 JAVA_HOME

我们需要在环境变量中配置JAVA_HOME 使它在任何地方都可以使用

---

三、IDEA开发工具

3.1 IDEA的下载和安装

下载：IDEA官网

在官网有专业版和社区版，专业版是需要收费的，社区版是完全免费的但是他的版本功能更少

一般推荐专业版，具体下载安装激活教程 自行搜索即可。

3.2 IDEA的第一个代码

IDEA的项目结构：

• project（项目、工程）
• module（模块）
• package（包）
• class（类）

前三个本质就是文件夹，用于对我们代码的管理和分类。
所以说结构的划分是，为了更方便的管理文件

IDEA第一个代码的创建编写流程：

1、创建Project 项目
打开我们的IDEA，直接点击新建项目或➕图标，我们第一次选择创建一个空项目

2、创建Module 模块
然后在我们新建好的项目中，项目结构位置，选择模块-新建模块

3、创建Class 类
之后在我们新建好的模块的src里直接创建一个Java文件 HelloWorld.java

4、在类中编写代码

public class Helloworld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

5、完成编译运行
直接在代码空白位置右键，选择运行HelloWorld.java，等待编译完成，看到控制台输入的语句则成功运行

3.3 IDEA中的操作

3.3.1 IDEA中的类操作

• 新建类文件
  直接在需要的目录右键，新建类即可
• 删除类文件
  在IDEA中的删除是不走回收站的，删除的操作要慎重
• 修改类文件
  修改名字时，类名称和文件名需要一致，可以右键修改选择重命名，类名称和文件名会同时修改

3.3.2 IDEA中的模块操作

• 新建模块
  在项目结构位置，选择模块，选择新建模块，依次完成所需设置即可（新建模块后一定点击OK）
• 删除模块
  对着所需删除的模块右键，选择移除（这样删除只是临时的删除，我们需要在硬盘中删除）
• 修改模块
  右键选择重构-重命名
• 导入模块
  点击文件-项目结构-模块-导入模块-选择需要导入的模块，一直下一步直到OK即可

3.3.3 IDEA中的项目操作

• 关闭项目
  文件-关闭项目
• 打开项目
  IDEA应用初始首页，选择项目打开即可
  在首页右侧的齿轮可选择移除项目，则会临时删除项目
• 修改项目
  项目结构-项目-就可以修改一些关于项目的设置（名字，SDK，语言级别等）
• 新建项目
  初始首页，新建项目依次设置即可
  

---

四、Java基础语法

4.1 注释

注释就是在程序指定位置添加的说明性信息

简单来说，就是对代码的一种解释

• 单行注释
  格式：// 注释信息
• 多行注释
  格式：/*<br> 注释信息<br> */
• 文档注释
  格式：/**<br> 注释信息<br> */

// 这是一个java程序
public class Helloworld {
// 这是主方法，是程序的入口
    public static void main(String[] args) {
// 这是输出语句
        System.out.println("Hello World!");
    }
}

4.2 关键字

4.3 字面量

字面量就是数据在程序当中的书写格式

Java中的数据分类

常用数据	生活中的写法	程序中的写法	说明
整数	666，-888	666，-888	写法一致
小数	13.14，-5.21	13.14，-5.21	写法一致
字符串	黑马程序员	"黑马程序员"	双引号
字符	A，0，我	‘A’，‘0’，‘我’	单引号且只有一个字符
布尔值	'真'，'假'	true，false	true真，false假
空值		null	一个特殊的值

4.4 变量

变量就是内存中的存储空间，空间中存储着经常发生改变的数据

变量的定义格式：
数据类型 变量名 = 数据值；
例： int salary = 15000;

变量的使用方法：
根据变量名进行使用
例：System.out.printLn(age);

4.5 Debug工具

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

4.6 标识符

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

标识符命名规则

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

标识符命名规范

小驼峰命名法：
用于给变量起名

• 标识符是一个单词的时候，所有字母小写
  例：name
• 标识符有多个单词组成时，从第二个单词开始首字母大写
  例：firstName

大驼峰命名法：
用于给类起名

• 标识符是一个单词的时候，首字母大写
  例：Student
• 标识符由多个单词组成的时候，每个单词的首字母大写
  例：GoodStudent

4.7 数据类型

数据类型介绍：

基本数据类型

不同数据类型取值范围不一样，内存占用大小也不一样

整数类型首选int，基本常规数据在int都能装得下

小数类型首选double

4.8 键盘录入

键盘录入效果介绍：
用户可以自行录入数据，变量记录的值来自用户自行设置

键盘录入步骤：

1、Java程序内置了一个Scanner，导入软件包

在class上面书写 import java.util.Scanner 意思是导入Java/util/Scanner文件

2、创建对象

在主方法中书写 Scanner sc = new Scanner(System.in); 意思是写了一个带参构造方法，创建对象

3、调用方法

int age = sc.nextInt();这样意思是，接收一个输入的整数，并且存到age中

五 运算符

5.1 算数运算符

• 运算符：对字面量或变量进行操作的符号
• 表达式：用运算符被字面量或变量连接起来，符合Java语法的式子称为表达式
  不同运算符连接得表达式，体现的是不同的类型得表达式
• 例：int c = a + b 其中 + 为运算符，a + b是表达式

符号	作用	说明
+	加
-	减
*	乘
/	除
%	取余	获取两个数据做除法得余数

5.2 字符串拼接操作

当 + 操作中，遇到了字符串，这时 + 字符串拼接符，而不是算数运算符

public class Test {
    public static void main(String[] args){
        System.out.println("年龄是" + 18)
        // 输出为  "年龄是18"
        System.out.println(1 + 99 + "等于" + 1 + 1)
        // 输出为  "100等于11"
        // 因为代码有执行顺序，前面都是运算符，遇到了字符串才变为拼接符
        // 所以前面1 + 99 = 100，后面1 + 1 = 11
        System.out.println("5+5="+(5+5))
        // 输出为"5+5=10"
        // 和数学运算一样，添加括号回增加权重（则先算括号里面的），
        // 所以，先运算了（5+5），得数是10，然后和"5+5="拼接，结果为字符串"5+5=10"
    }
}

因为代码有执行顺序，前面都是运算符，遇到了字符串变为拼接符

在运算符代码中添加括号，可以为括号里的运算添加权重，然后再将括号外面的，进行正常运算

5.3 自增自减运算符

符号	作用	说明
++	自增	变量自身的值加一
--	自减	变量自身的值减一

自增自减的用法：

1、单独使用，在代码中直接添加++、--
在变量前面添加或在变量后面添加，是没有区别的
例：a++ --a

2、参与运算使用：
++在前：先自增，再操作
++在后：先操作，再自增
例：

public class Test{
    public static void main(String[] args){
        int a = 10;
        int b = ++a;
        System.out.println("a=" + a "b=" + b)
        // ++在前，a先加1，然后赋值给b，所以 a = 11, b = 11
// ————————————————————————————————————————
        int a = 10;
        int b = a++;
        System.out.println("a=" + a "b=" + b)
        // ++在后，a先赋值给b，然后a再加1，所以 a = 11, b = 10
    }
}

3、++、-- 只能操作变量，不能操作常量

5.4 类型转换

类型转换分类：

隐式转换：
1、把一个取值范围小的数值或变量，赋值给另一个取值范围大的变量
2、取值范围小的数据和取值范围大的数据进行运算时，小的会提升为大的之后，在进行运算
3、在Java中数据类型不统一，没法直接进行运算
（byte short char 三种数据类型，在运算时都会提升为int，再进行运算）

public class Test{
    public static void main(String[] args){
        int a = 10;
        double b = a;
        System.out.printLn(b);
        // double取值范围比int大，所以可以直接赋值，输出为10.0，将他转换成了double类型
        // ————————————————————————————————
        int a = 10;
        double b = 12.3;
        System.out.printLn(a+b);
        // int类型和double类型进行运算，先将int提升为double之后再进行运算，输出为22.3
    }
}

强制转换：
把一个取值范围大的数值或者变量，赋值给另一个取值范围小的变量
不允许直接复制，需要加入强制转换
格式：目标数据类型 变量名 = （目标数据类型）被强制的数据；

public class Test {
    public static void main(String[] args) {
        double a = 12.3;
        int b = (int) a;
        System.out.println(b);
        // 输出为12，少了0.3，这个称为精度缺失
        // 强制转换，【有可能】出现精度缺失的情况
    }
}

在代码中进制的分类及书写：

public class Test {
    public static void main(String[] args){
        /*
            计算机中的进制分类及写法：
            十进制：默认写法
            二进制：0b开头书写
            八进制：0开头书写
            十六进制：0x开头书写
        */
        System.out.println(110);
        System.out.println(0b110);
        System.out.println(0110);
        System.out.println(0x110);
        // 依次输出为  110、6、72、272，依次代表的是十进制，二进制，八进制，十六进制的110的值
    }
}

Java拥有一个机制：常量优化机制

byte b1 = 3
byte b2 = 4
byte b3 = b1 + b2
// 这个运算会报错
// 因为b1和b2是两个byte类型，在运算的时候，会提升为int类型
// 提升之后，就是两个int在运算了，运算的结果还是int.
// 将int类型的结果，赋值给byte类型的变量，属于大给小，不能直接给.
byte b = 3 + 4
// 这个运算不会报错，因为Java中有一个机制叫做常量优化机制

在编译的时候，会将两个字面量（3、4）进行运算，得出结果7，再去转换 字节码 byte
我们产生的字节码文件中 byte b = 7;

5.5 package

我们如果直接在src文件夹下创建Java文件，会导致文件不好找，没有分类，乱七八糟的情况

所以我们要用到包管理模式 package

一般包的命名就是公司的网址，倒着写+项目名称 例：
top.ericw.test

5.6 赋值运算符

符号	作用	说明
=	赋值	a=10,将10赋值给a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a+=b，将a-b的值给a
*=	乘后赋值	a+=b，将a*b的值给a
/=	除后赋值	a+=b，将a/b的商给a
%=	取余后赋值	a+=b，将a%b的余数给a

public class OperatorDemo1 {
    // 赋值运算符
    public static void main(String[] args) {
        int a = 10;
        a += 10;
        System.out.println(a);
        // 20
        
        int b = 10;
        b -= 10;
        System.out.println(b);
        // 0
        
        int c = 10;
        c *= 10;
        System.out.println(c);
        // 100
        
        int d = 10;
        d /= 10;
        System.out.println(d);
        // 1
        
        int e = 10;
        e %= 10;
        System.out.println(e);
        //0
    }
}

5.7 关系运算符

关系运算符，又称为比较运算符号

符号	说明
==	a==b,判断a和b是否相等
!=	a!=b,判断a和b是否不相等
>	a>b,判断a是否大于b
>=	a>=b,判断a是否大于等于b
<	a<b,判断a是否小于b
<=	a<=b,判断a是否小于等于b

5.8 逻辑运算符

符号	介绍	说明
&	逻辑与	遇false则false
|	逻辑或	遇true则true
!	逻辑非	取反
^	逻辑异或	相同为false，不同为true

短路逻辑运算符

符号	介绍	说明
&&	双与	当左边为false时，右边不执行
||	双或	当左边为ture时，右边不执行

public class OperatorDemo4 {
    public static void main(String[] args) {
        int x = 3;
        int y = 4;
        boolean result = ++x > 5 && y-- < 4;
        System.out.println(x);
        System.out.println(y);
        System.out.println(result);
//      输出为 x = 4, y = 4 , result = false
//      y--没有执行，是因为&&的短路效果（当左边为false时，右边就不执行了）
//      & 没有短路效果  | 没有短路效果，||当左边为true时，右边不执行
//      &&，||，执行效果会更快，效率更高，更常用
    }
}

5.9 三元运算符

• 格式：判断条件 ？ 值1 ： 值2；
• 执行流程：
  首先计算判断条件的值
  如果为true，值1就是运算结果
  如果为flase，值2就是运算结果

public class OpreatorDemo5 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        int max = num1 > num2 ? num1 : num2;
        System.out.println(max);
//      输出为20，判断条件为flase，值2就是结果
    }
}

5.10 运算符优先级

优先级	运算符
1	. （）{}
2	！- ++ --
3	* / %
4	+ -
5	<< >> >>>
6	< <= > => innstanceof
7	== !=
8	&
9	^
10	|
11	&&
12	||
13	?:
14	= += -= *= /= %= &=

六 方法（函数）

6.1 方法的介绍

如果我们将代码都写到一起，维护困难，难以控制。

所以我们需要将相同功能的代码单独编写，需要的时候通过名字直接找到它，更利于维护

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

方法的优点就是：可以将我们原本臃肿的代码，按照功能进行分类管理，可以提高代码的复用性

6.2 方法的定义和调用

方法的定义格式：

public static void 方法名(){
  // 方法体
}

方法的调用格式：

方法名();

注意事项：

1、方法以方法之间是平级关系，不允许嵌套定义（我们写的方法不能写到主方法里面）

2、方法不调用就不执行，并且不限制调用次数（提高代码复用性）

3、方法的定义顺序和执行顺序无关，执行顺序只和调用有关

Ctrl + F12 展开当前类的结构大纲（快速寻找当前类的方法）

6.3 Debug查看方法的执行流程

1、首先在所需要停止的地方添加断点

2、选择Debug运行模式，查看运行结果

3、在Debug栏目，在 Framse 中可以找到正在执行的方法

4、点击第二个按钮为进入的按钮，可以进入到放大里面

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

假设我们之后进入公司，需要和同事配合开发
我们有可能我写的方法，别人去使用
我们刚刚学到的方法中使用的数据是固定的，数据不灵活

所以我们可以把需要的参数空出来，将我们的参数写在小括号中，就是带参方法

定义格式：

pubilc static void 方法名 (数据类型 变量名) {
    // 方法体
}

pubilc static void 方法名 (数据类型1 变量名1,数据类型2 变量名2) {
    // 方法体
}

6.4.1 形参和实参

形参：全称形式参数，是指在定义方法时，所声明的参数

实参：全称实际参数，调用方法时，所传入的参数

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

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

定义格式：

public static 数据类型 方法名 (数据类型1 变量名1,数据类型2 变量名2) {
    return 数据值;
}

调用格式：

数据类型 变量名 = 方法名(实参1,实参2);

6.6 方法的通用定义格式

pubilc static 返回值类型 方法名 (参数) {
    方法体
    return 数据;
}

定义方法时，要做到两个明确

明确参数：主要明确参数的类型和数量

明确返回值：主要明确方法结束后是否有结果数据，以及对应参数类型。（如果没有则写void）

方法返回值类型为void，表示方法没有返回值，没有返回值的方法，可以省略return语句
如果要编写return,后面不能更具体的数据。

return下面的代码不会执行，因为永远执行不到，属于无效代码。

6.7 方法重载

在调用方法的时候，Java虚拟机会根据参数的不同来区分同名的方法：

pubilc class Test {
    pubilc static int add (int a,int b){
        return a + b;
    }
    pubilc static int add (double a,double  b){
        return a + b;
    }
    pubilc static int add (int a,int b,int c){
        return a + b + c;
    }
}

在同一个类中，定义了多个同名的方法，每个方法具有不同的参数类型或参数个数
这些同名的方法，就构成了重载关系

同一个类中，方法名相同，个数不同、类型不同、顺序不同，就是方法重载关系

只看方法名和参数，与返回值无关

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

七 流程控制语句

流程控制语句就是通过一些语句，来控制程序的执行流程

7.1 顺序结构

Java的默认执行流程，没有特定语法，按照代码顺序先后去执行，依次执行程序中大多数的代码

7.2 分支结构

7.2.1 if 语句

• 格式一 ：

if (判断条件) {
    语句体;
}

执行流程：

1、首先计算判断条件的结果

2、如果判断条件为 true 就执行语句体

3、如果判断条件为 false 就不执行语句体

• 格式二 ：

if (判断条件) {
    语句体1;
} else {
    语句体2;
}

执行流程：

1、首先判断计算结果

2、如果条件为 true 就执行语句体1

3、如果条件为 false 就执行语句体2

• 格式三

if (判断条件1) {
    语句体1;	
} else if (判断条件2) {
    语句体2;	
} else {
    语句体n+1;
}

执行流程：

1、首先计算判断条件1的值

2、如果值为true就执行语句体1；如果值为false就计算判断条件2的值

3、如果值为true就执行语句体2；如果值为false就计算判断条件3的值

4、如果没有任何判断条件为true，就执行语句体n+1。

7.2.2 switch 语句

格式：

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

default对于语法来说，不写是不影响的，但是为了规范需要写default

注意事项：

1、case后面的值不允许重复

2、case后面只能是字面量，不能是变量

3、switch（）中可以接收的类型：
基本数据类型：byte short char int
引用数据类型：jdk5版本开始可以是枚举，jdk7版本开始可以是string字符串

4、switch语句的case的穿透现象：
这个说的是switch语句中没写break的情况
正常情况会有break来结束case，但是如果没有写，他将会向下穿透，直到break结束或代码结束

5、case后面允许编写多个数据，通过,分隔。case 1,2,3,4,5 :

更简单的格式：(使用箭头直接指向我们要做的事)

switch(week){
    case 1,2,3,4,5 -> System.out.println("工作日");
    case 6,7 -> System.out.println("休息日");
    default -> System.out.println("输入有误");
}

if 语句 适用于范围性的判断

switch 语句 适用于固定值判断

7.3 循环语句

7.3.1 for 循环

格式：

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

//  循环体语句：循环任务
//  sout("跑圈");
//  初始化语句：定义变量
//  int i = 1;
//  条件判断语句：循环条件
//  i < 4
//  条件控制语句：改变变量
//  i++;

执行流程：

1、执行初始化语句，在整个循环过程中，只会执行一次

2、执行判断条件，看起返回的结果是true还是false
false：循环结束
true：执行第三步

3、执行循环体语句

4、执行条件控制语句

5、回到第二步继续执行

快捷写法：5.fori 写这个将会生成一个循环五次的for循环

注意事项：

1、for循环 {} 当中定义的变量，在每一轮循环结束以后，都会从内存中释放

2、for循环 () 定义的变量，会在整个循环结束后，从内存中释放

3、for循环 () 和 {} 之间不要写分号

7.3.2 循环嵌套

循环嵌套：再循环语句中，继续出现循环语句

当循环体结束，才会进行下一次循环

for(int i = 1;i <= 5; i++){
    for(int j = 1;j <= 5; J++){
        System.out.println("HelloWorld");
    }
}

上述代码：分为外循环和内循环，先执行内循环，外循环执行一次，内循环执行五次

System.out.println("") 打印数据后，有换行

System.out.print("") 答应数据后，没有换行

7.3.3 while 循环格式与执行流程

格式：

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

例：

int i = 1;
while(i <= 5){
    System.out.println("黑马程序员");
    i++;
}

执行流程：

1、执行初始化语句

2、执行判断条件，看其返回结果是true，false
false：循环结束
true：继续执行，进入第三步

3、执行循环体语句

4、执行条件控制语句

5、回到第二步继续执行

7.3.4 do...while 循环格式与执行流程

格式：

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

例：

int i = 1;
do{
    System.out.println("黑马程序员")
    i++;
} while(i <= 5);

执行流程：

1、执行初始化语句

2、执行循环体语句

3、执行条件控制语句

4、执行判断条件，看其看会的结果是true，false
false：循环结果
true：回到第二步执行

注意事项：

do...while 循环至少会执行一次循环体语句（无论条件是否满足，都会执行一次）

7.3.5 三种循环的区别

• for循环 和 while循环 （先执行后判断）
• do...while （先执行后判断）

for循环和while循环有什么区别？

for循环：用于控制循环的变量，在循环结束后，就会从内存中消失，循环结束后，不能再使用

while循环：用于控制循环的变量，在循环结束后，不会在内存中消失，循环结束后，可以继续使用

因为我们for循环将变量定义在循环里面，而while则将循环定义在循环外面

7.4 跳转控制语句

有时候在循环过程中，是需要强行做结束的。
这时候我们就需要跳转控制语句，用于停止循环的执行，或者跳过执行。

break关键字的用处就是，结束循环或switch语句（结束）
但是一般是能在循环或者switch中使用。

continue关键字的用处就是，跳过本次循环继续下一次循环（跳过）
一般只能在循环当中使用，如果脱离了循环就会报错。

break continue这两个关键字的下面不能在写代码，因为执行不到就已经结束了，属于无效代码

7.5 Random随机数

书写流程：

1、找符咒（导包）

2、召唤精灵（引用定义Random）

3、指挥精灵干活（使用Random）

例：(生成一个10以内的随机整数[不包含10])

import java.util.Random
public class Test {
    pubilc static void main（String[] args）{
        Random r = new Random();
        int num = r.nextInt(10);    
    }
}

也可以给随机数进行计算：(生成一个1~10的随机数)

int num = r.nextInt(10)+1; 

八 数组

8.1 数组的介绍

• 数组指的是一种容器，可以用来存储同种数据类型的多个值

当我们有多个变量需要同时存储时，就需要数组来当容器

数据过多会导致数据过于零散，不宜维护。

8.2 数组静态初始化

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

数组的定义格式 一般使用格式一和简化格式

// 格式一
数据类型[] 数据名;
int[] arr

// 格式二
数据类型 数组名[];
int arr[]

// 数组静态初始化的格式
// 完整格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
int[] arr = new int[]{1,2,3};

//简化格式：
数据类型[] 数组名 = {元素1,元素2,元素3...};
int[] arr = {1,2,3}

8.3 数组的元素访问

数组访问格式（调用格式）：

// 当我们直接打印数组名的时候，输出的是数组的内存地址：
System.out.println(arr);  // 输出：[I@776ec8fd    输出的这一段就是当前数组的内存地址

// 正确的数组访问格式：
数组名[索引];
arr[0]

索引就是数组的变量的对应空间的编号（从0开始）

索引：索引是数组容器中空间的编号，编号从0开始，逐个+1增长

8.4 数组遍历操作

数组遍历就是将数组所有内容，取出来进行操作。

// 数组名.length  获取当前数组的长度
int[] arr = {11,22,33,44,55}
System.out.println("arr.length")  //打印出来是5

// 遍历数组的代码就是：
for(int i = 0; i < arr.length; i++){
    System.out.println(arr[i]);
}

// 数组遍历的快捷键：  数组名.fori

8.5 数组动态初始化

初始化时只指定长度，由系统为数组分配初始值（默认值）

// 格式
数据类型[] 数组名 = new 数据类型[数据长度];
int[] arr = new int[3];

各个类型的默认值：
整数：0
小数：0.0
布尔值：false
字符：'\u0000'
引用数据类型：null

• 动态初始化：手动指定数组长度，由系统给出默认初始化值
• 静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度

8.6 数组常见问题

如果遇到报错，一般从下往上看；

• ArrayIndexOutOfBoundsException 索引越界异常
  当访问了数组中不存在的索引，就会引发索引越界异常

• NullPointerExceptionDemo 空指针异常
  当引用数据类型的变量，被赋值为null之后，就代表和堆内存的连接切断了
  这个时候还想去访问堆内存，就会出现空指针异常

8.7 二维数组的介绍

二维数组是一种容器，该容器用于储存一维数组（二维数组就是数组的嵌套）

例如：要给一个销售部门的业绩进行分类存储为数组

如果写一个数组: int[] arr = {22,66,44,77,33,88,25,45,65,11,66,99};
这样书写不便于管理，需要认为分别出每个季度的数据

所以我们把他分为四个数组来存储。再由一个大数组来进行嵌套存储

今后若要操作的多组数据，属于同一种数据
就可以考虑使用二维数组进行维护

8.7.1 二维数组的静态初始化

完整格式：

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

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

简化格式：

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

int [][] arr = {{11,22}{33,44}};

数组的访问格式（调用格式）：

System.out.println(arr[0][0])

二维数组在存储一维数组，存储的是一维数组的地址值

8.7.2 二维数组的遍历

二维数组就是数组嵌套，那遍历二维数组需要嵌套循环

// 遍历二维数组
public static void printArray(){
    int[][] arr = {
        {11,22,33},
        {33,44,55}
    }
}

for(int i = 0;i < arr.length; i++){
// arr[i]  遍历每一个一维数组
// 遍历一维数组，获取内部的元素
    for(int j = 0;j < arr[i].length; j++){
        System.out.println(temp[i][j]);
    }
} 

8.7.3 二维数组的动态初始化

格式：

数据类型[][] 数组名 = new 数据类型[m][n];
int[][] arr = new int[2][3];

m表示这个二维数组，可以存放多少个一维数组

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