Java学习笔记---基础语法

1. Java语言的发展史

java是哪家公司哪一年推出的？
sun公司在1995推出的编程语言
java之父是谁？
詹姆斯.高斯林
java的主要发展历程？
1995由sun公司推出。
2004推出JDK1.5，这是里程碑式的版本。
2009年sun公司被oracle（甲骨文公司）收购。
目前最新版本JDK12。
java的三大技术架构
JavaSE：java标准版，主要用于桌面应用软件的开发。比如计算器，QQ软件等。
JavaEE：java企业版，基于JavaSE的企业级应用的开发。比如淘宝，京东，ERP系统等。（大型互联网）
JavaME：java微型版，应用于移动设备和电子类产品的嵌入式开发。比如手机游戏，手机软件等。（安卓，IOS，HTML，微信小程序）

2. Java语言跨平台原理

java语言的特点
java语言具有简单易学、面向对象、健壮性、安全性、与平台无关性等特点。
什么是平台？
平台即操作系统，目前主流的有微软Windows系统，苹果Mac系统，Linux系统
什么是java跨平台？
通过java语言编写的应用程序可以在不同的操作系统上直接运行。具有一次编译，到处运行的特点。
java如何实现跨平台？
通过JVM虚拟机实现的跨平台。在不同的操作系统上安装对应的JVM虚拟机。

java跨平台的原理
java程序并非是直接运行的， javac编译器将java源程序（.java文件）编译成与平台无关的字节码文件（.class文件），然后通过java运行工具启动java虚拟机，由java虚拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下， 只需安装不同的java虚拟机即可实现java程序的跨平台

3. JVM、JRE、JDK

JVM、JRK、JDK三者之间的关系

JVM：Java虚拟机，保证java程序跨平台。 
			//JVM保证java程序的跨平台性
JRE：Java运行环境，包含JVM和核心类库。如果只是想运行java程序，只要安装JRE即可。
			//JRE=JVM+核心类库
			核心类库包括：java.util包中的Random/Scanner/Arrays等
JDK：Java开发工具包，包含JRE和开发工具。如果程序员想要开发java程序，需要安装JDK环境 
			//JDK=JRE+开发工具
			开发工具包括：编译工具javac.exe  ，运行工具java.exe 等

JVM、JRE、JDK关系图解

4. 常用的DOS命令

进入DOS命令行窗口
快捷键win + R打开运行窗口，输入cmd，按回车进入。
常用DOS命令

操作	说明
盘符名称	盘符切换。E:回车，表示切换到E盘
dir	查看当前路径下的内容
cd 目录	进入单级目录。cd develop，表示进入develop文件夹
cd …	回退到上一级目录
cd 目录1\目录2…	进入多级目录。cd develop\java，表示进入develop下的java文件夹
cd \	回退到盘符根目录
cls	清屏
exit	退出命令提示符窗口

5. Path环境变量的配置

什么是环境变量
环境变量：指在操作系统中用来指定操作系统运行环境的一些参数
为什么要配置环境变量
开发java程序， 需要使用JDK提供的开发工具（比如javac.exe、java.exe等命令），而这些工具在JDK的安装目录的bin目录下，如果不配置环境变量，那么这些命令只可以在该目录下执行。 我们不可能把所有的java文件都放到JDK的bin目录下， 所以配置环境变量的作用就是可以使bin目录下的java相关命令可以在任意目录下使用。
常见配置的环境变量

环境变量名	作用
JAVA_HOME	指 JDK 安装的根目录，如：C:\develop\Java\jdk-11
PATH	指 java 开发工具的位置，如：C:\develop\Java\jdk-11\bin
CLASSPATH	指 JVM 在运行时到哪一个目录去加载字节码文件

6. 注释

注释的作用？
对代码进行解释说明，便于开发人员理解和维护代码。
注释不会被程序编译和运行。
注释的分类？
单行注释 // 注释内容，单行注释可以嵌套。
多行注释 /* 注释内容 /，多行注释不能嵌套使用。
文档注释 /* 注释内容 */，文档注释不能嵌套使用。

7. 关键字

什么是关键字？
在java语言中有特殊意义的英文单词。
java关键字的特点？
单词全部小写。
在高级开发工具中，关键字会有特殊的颜色标记。
java中的关键字/保留字
goto和const是java中的预留关键字（goto和const也叫保留字）。

8. 常量

什么是常量？
在程序运行过程中，其值不可以发生改变的量。
常量的分类

字符串常量：使用双引号 "" 括起来的0到多个字符。"java" ,"程序员" ， "" ， "  "，"A" // 大于等于0个字符
字符常量：使用单引号 '' 括起来的单个字符。 'a' , '0' ,'我' //1个字符
整数常量：正负整数  10  -20
小数常量：带小数点的数字  -3.14   5.12
布尔常量：表示真或假，只有true或false两个值
空常量：值为null，不能使用输出语句直接输出。//System.out.println(null),会编译报错
定义的final变量

9. 数据类型

java是强类型的语言，每一个数据都有对应的数据类型。
位：计算机计算的基本单位，计算机底层是二进制 0 1
字节：计算机存储的基本单位，1字节=8位。
java数据类型分类？
基本数据类型：4型8种
整数：byte short int long （整数默认是：int类型）
小数：float double （小数默认是：double类型）
字符：char
布尔：boolean
引用数据类型：字符串，数组，类，接口 ,null
基本数据类型分类

1.定义 long 类型加L
		int number = 100L;
2.定义 float 类型加F
		int f = 10.0F;

10. 变量

什么是变量？
变量指程序运行过程中，其值在一定范围内会发生变化的量。
变量的定义格式

数据类型 变量名 = 初始化值
int a = 12;

变量的分类

成员变量：（也叫全局变量，字段）
	直接定义在类中，方法外，默认有初始值
	1.类成员变量：使用static修饰符修饰的成员变量
	2.实例成员变量：没有使用static修饰符修饰的成员变量
局部变量：变量除了成员变量之外,其他就是局部变量
	分为：方法形参，方法内变量，代码块变量
	没有初始化值，必须先初始化才能使用

变量使用的注意事项

1、变量可以定义时初始化，也可以先定义，使用前进行初始化。
	//定义的时候初始化
	double d = 3.14;
	//先定义，后初始化
    double d;
    d = 3.14;
    
2、没有初始化的变量不能直接使用。
    int a ;
    System.out.println(a);  //编译报错，
	
3、相同范围内，变量名不能重复。

	//第一种:方法的形参上变量名不能相同
    public static void sum(int a,int a){ //编译报错

    }
    //第二种:一对 {} 内变量名不能相同
    public static void sum(){
        int a = 10;     //编译报错
        int a = 20;		//编译报错
    }

4、整数默认是int类型，定义long类型时需要加L 或者l,建议加L。
	long num = 10L;

5、小数默认是double类型，定义float类型的时候需要在数字后面加F或者f,建议加F。
	float f = 3.14F;

6、一行代码上可以定义多个变量。（不推荐）
	int a=10,b=20;

    int a,b =20;
    a=10;

变量的生命周期

	存在位置	生命周期开始	生命周期结束	在内存中的位置
类成员变量	使用static修饰的成员变量	当所在字节码被加载进JVM	当JVM停止	方法区
实例成员变量	没有使用static修饰的成员变量	当创建所在类的对象的时候	当该对象被垃圾回收器回收	堆
局部变量	方法形参，代码块中，方法内	当代码执行到初始化变量的时候	所在的方法/代码块结束	栈

11. 标识符

标识符的作用
给 包，类，方法，变量起名的符号。
标识符的组成规则
大小写英文字母、数字、下划线_、美元符$、中文（不推荐）
注意事项：
1、不能是数字开头
2、不能是关键字
3、区分大小写
标识符的命名规范
小驼峰式命名：变量名、方法名
第一个单词首字母小写，从第二个单词开始每个单词的首字母大写。

userName，maxValue等

大驼峰式命名：类名
每个单词的首字母都大写。

String， ArrayList等

建议：标识符的起名尽量做到见名知意。

12. 类型转换

隐式类型转换（自动类型转换）
从范围小的类型到范围大类型的转换，系统会自动进行类型提升，称为自动类型转换。

1.boolean不参与类型转换
2.byte不能自动类型转换为char
3.char不能自动类型转换为short
4.short不能自动类型转换为char

强制类型转换
从范围大的类型到范围小的类型的转换，需要进行强制类型转换。
格式：

目标数据类型 变量名 = （目标数据类型）变量值（常量值）；

弊端：会造成数据精度丢失。尽量少用强制转换。

1.boolean不参与类型转换
2.char可以强制类型转换为byte
3.short可以强制类型转换为char
4.char可以强制类型转换为short

13. 运算符和表达式

运算符：对常量或者变量进行操作的符号。
表达式：通过运算符连接起来的式子

例如：
+ 是运算符，10 + 20 是表达式
- 是运算符，a - b   是表达式

常用的运算符
算术运算符、赋值运算符、自增自减运算符、关系运算符、逻辑运算符、三元运算符

13.1 算术运算符

符号	作用	说明
+	加	对数字进行加法运算，对字符串进行拼接
-	减	进行减法操作
*	乘	进行乘法操作
/	除	整数相除的结果只能是整数，想要得到小数，必须有浮点数参与运算。 a / b ,获得 a 和 b 的商
%	取余	a%b 获得 a 和 b 相除的余数

13.1.1 表达式类型提升

byte、short、char变量之间进行运算时，类型自动提升为int。
变量参与运算时，最终结果以最高类型为准。

/*
	表达式类型提升:
		1. byte、short、char变量之间进行运算时，类型自动提升为int。
		2. 变量参与运算时，最终结果以最高类型为准。
*/
public class OperatorDemo02 {
	public static void main(String[] args) {
		
		// 1、byte、short、char变量之间进行运算时，类型自动提升为int。
		byte b = 10;
        
         //编译报错，b+5，变量b会自动提升为int类型，运算结果为int，赋值给byte需要强转。
		// byte b2 = b + 5;  
       
		int b2 = b+5; 
		System.out.println(b2);
		
		// 2. 变量参与运算时，最终结果以最高类型为准。
		int num1 = 10;
		long num2 = 20L;
		long num3 =  num1 + num2; //int + long --->long
		System.out.println(num3);
	}
}

13.1.2 字符的 + 运算

字符参与运算的规则：
将字符换算成编码表里对应的数值进行运算。
等价于：把char类型数据换成对应的十进制数来参与运算
编码表：
计算机底层使用二进制运算，所以文字和符号必须转换成二进制数才能被计算机识别，编码表就是将文字等符号编成对应的数的表格，因为二进制记录起来比较麻烦，所以使用十进制数进行文字编码。
世界上第一张编码表ASCII（美国标准信息交换码）。常用编码表都兼容ASCII码表。
常用的编码：
ASCII编码：美国标准信息交换码，世界上第一张编码表。
GB2312编码：简体中文编码，对常用汉字进行了编码，兼容ASCII。
GBK：加强版的中文编码表，对更多汉字进行了编码，兼容ASCII
UTF-8编码：万国码表，常作为浏览器上的网页编码，可以统一显示各国文字，兼容ASCII。
常见字符对应的十进制数：
‘ a’ ~ ‘z’ : 97 ~ 122
‘A’ ~ ‘Z’ : 65 ~ 90
‘0’ ~ ‘9’ : 48 ~ 57
基本汉字：19968 ~ 40869
char类型表示的范围：0~65535
ASCII编码表

/*
	字符参与运算的规则：
		将字符换算成编码表里对应的数值进行运算。
*/
public class CharDemo2{
	public static void main(String[] args){
		//a~z  97~122
		//A~Z  65-90
		//0~9  48~57
		//基本汉字：19968 ~ 40869
	
		char c = 'a';
		int b = c + 10;
		System.out.println(b); //c是char类型，参与运算先转为十进制，在参与运算 //107
		
		char  c2 = 97;
		System.out.println(c2); //c2是char，打印c2就是打印他的char类型数据 //a
		
		//char类型范围 0~65535
		// char c3 = 65536;  //报错，超过了char的范围
		
		int c3 = '中';
		int c4 = '国';
		
		System.out.println(c3); //20013
		System.out.println(c4); //22269
		
		char c5 = 20013;
		char c6 = 22269;
		System.out.println(c5); //中
		System.out.println(c6); //国
		
		char c7 = '9';  //9
		char c8 = 57;  //9
		char c9 = 9; //打印的结果不是数字9,而是9对应的编码表的符号73
	}
}

13.1.3 字符串的+运算

与字符串进行 “+” 运算，是进行字符串拼接操作，运算结果还是字符串。
字符串只能进行 + 运算

//字符串的加法运算
public class StringAddDemo{
	public static void main(String[] args){
		int age = 25;
		System.out.println("我的年龄是："+age+"岁"); //输出结果：我的年龄是：25岁
	}
}

13.2 赋值运算符

赋值运算符作用
将表达式或者常量值赋给变量。
赋值运算符分类

符号	作用	说明
=	赋值	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 FuZhiDemo {
	public static void main(String[] args) {
		//1. 基本赋值运算符 =
		int a = 10;
		System.out.println(a);
		
		//2. 扩展赋值运算符
		int b = 20;
		// b+=5;
		// b-=5;
		// b*=5;
		// b/=5;
		b%=5;  //b = b%5; 
		System.out.println(b);//0
		
		// 3. 扩展赋值运算符隐含了强制类型转换
		byte num = 10;
		num+=5;  // 相当于:num = (byte)(num+5);
        
        // num  = num + 5; //报错
        
        System.out.println(num);	
	}
}

13.3 自增自减运算符

1、++ 、 – 可以放在变量的前面，也可以放在变量的后面。
单独进行运算时放在前面或者后面，效果一样。
2、参与其他运算的时候：
a++ ：先将a的值参与其他运算，运算结束后再自身加1。
++a ：先将a自身加1，再将自增后的值参与其他运算。
自减与自增规则相同。
3、最常见用法：单独使用。

13.4 关系运算符

符号	作用	说明
==	等于	a == b，判断如果a等于b，则为true，否则为false
!=	不等于	a!=b，判断如果a不等于b，则为true，否则为false
>	大于	a>b，如果a大于b，则为true，否则为false
>=	大于等于	a>=b，如果a大于等于b，则为true，否则为false
<	小于	a
<=	小于等于	a<=b，如果a小于等于b，则为true，否则为false

注意：

1. 关系运算符的运算结果都是boolean类型，要么是true，要么是false。
2. = 是赋值符号， == 才是判断是否相等的符号。

13.5 逻辑运算符

什么是逻辑运算符？
1、逻辑运算符用于连接关系表达式，描述更复杂的逻辑关系。
2、逻辑运算符的运算结果是boolean类型。
逻辑运算符有哪些

符号	说明	格式	运算结果
&	逻辑与	表达式1 & 表达式2	有false则false
|	逻辑或	表达式1 | 表达式2	有true则true
！	逻辑非	! (表达式)	对表达式结果取反
^	逻辑异或s	表达式1 ^ 表达式2	不同为true，相同为false

短路逻辑运算符（掌握）

符号	作用	说明
&&	短路与	作用和&相同，但是有短路效果
||	短路或	作用和|相同，但是有短路效果

区别：

• 表达式1 & 表达式2 ：所有表达式都会执行。
• 表达式1 && 表达式2 ：如果表达式1为false，则右边表达式不再执行，可以提高效率。
• 表达式1 | 表达式2 ：所有表达式都会执行。
• 表达式1 || 表达式2 ：如果表达式1为true，则右边表达式不再执行，可以提高效率。
  实际开发中，会使用短路与&&、短路或||来提高运算效率。

13.6 三元运算符（三目运算符）

语法格式：

判断表达式 ? 表达式1 : 表达式2;

执行流程：
执行判断表达式，判断结果是boolean类型，为true时执行表达式1并返回结果，false执行表达式2并返回结果。

应用场景

/*
	需求：(使用三元运算符)把三个整数按从小到大打印。	
	步骤:
		求最小值
		求最大值
		中间值：三个数的和 - 最小值 - 最大值
	
*/
public class SanYuanDemo4{
	public static void main(String[] args){
		int a = 60;
		int b = 20;
		int c = 30;
		
		//求最小值
		int tempMin = ab?a:b;
		int max = tempMax>c?tempMax:c;
		
		//中间值：三个数的和 - 最小值 - 最大值
		int mid = a+b+c-min-max;

		//按从小到大打印
		System.out.println(min);
		System.out.println(mid);
		System.out.println(max);
	}
}

14. 键盘录入：Scanner类

Scanner类的作用是什么
Scanner是JDK提供的用于获取键盘输入的数据的工具类。该类位于java.util包下。
Scanner的使用步骤

1、导包	import java.util.Scanner
2、创建Scanner的对象	Scanner sc = new Scanner(System.in);
3、调用方法接收数据	int num = sc.nextInt();

/*
	需求：Scanner录入数据求两个整数的和
*/
//导包
import java.util.Scanner;
public class ScannerDemo2 {
	public static void main(String[] args) {
		//创建Scanner对象
        Scanner sc = new Scanner(System.in);

        //提示用户输入
        System.out.println("请输入第一个数字：");
        //获得键盘输入
        int a = sc.nextInt();

        System.out.println("请输入第二个数字：");
        int b = sc.nextInt();

        //求和
        int sum = a + b;
        //打印求和结果
        System.out.println("和为：" + sum);
    }
}

15. 进制

15.1 概念

进制也就是进位制，是人们规定的一种进位方法。 对于任何一种进制—X进制，就表示某一位置上的数运算时是逢X进一位。
十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，x进制就是逢x进位。

15.2 常见的进制

二进制:由两个基本数字0，1组成，运算规律是逢二进一.计算机都使用二进制表示数据.
八进制:由0、1、2、3、4、5、6、7组成,运算规律是逢八进一.
十进制:由0，1，2、3、4、5、6、7、8、9组成.
十六进制:由0～9以及A，B，C，D，E，F组成.

15.3 进制之间的转换

15.3.1 十进制和二进制之间转换

十进制—>二进制

对于整数部分，用被除数反复除以2，除第一次外，每次除以2均取前一次商的整数部分作被除数并依次记下每次的余数。
另外，所得到的商的最后一位余数是所求二进制数的最高位。

二进制—>十进制

进制数第1位的权值是2的0次方，第2位的权值是2的1次方，第2位的权值是2的2次方……公式：第N位 * 2的N-1次方,结果再相加.

15.3.2 十进制和十六进制之间转换

十进制—>十六进制:

10进制数转换成16进制的方法，和转换为2进制的方法类似，唯一变化：除数由2变成16。

十六进制—>十进制:
第0位的权值为16的0次方，第1位的权值为16的1次方，第2位的权值为16的2次方……

16. 原码、反码、补码

16.1 概述

在计算机内，有符号数有3种表示法：原码、反码和补码,所有数据的运算都是采用补码进行的

16.2 原码

写出二进制,正数符号位为0,负数符号位为1

16.3 反码

正数的反码是本身,负数的反码是在其原码的基础上, 符号位不变,其余各个位取反

16.4 补码

正数的补码就是其本身,负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)

17. 流程控制语句

流程控制语句分为哪几类
顺序结构、选择(分支)结构、循环结构

17.1 顺序结构

按照代码书写顺序，从上往下执行。

17.2 选择结构（if switch）

17.2.1 if结构

if语句格式1

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

执行流程：
1、首先计算关系表达式的值。
2、表达式的值为 true 时执行语句体，为 false 时不执行语句体。
3、往下执行 if结构后面的语句内容。

if语句格式2

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

执行流程：
1、首先计算关系表达式的值。
2、表达式的值为 true 时执行语句体1，为 false 时执行语句体2。
3、继续执行 if-else 结构后面的语句内容。

if语句格式3

if(关系表达式1){
    语句体1；
}else if(关系表达式2){
    语句体2；
}else{
    语句体3；
}
//【注意】 该格式中可以有多个else if结构，可以没有else结构。

执行流程：
1、首先计算关系表达式1的值。
2、如果为 true 则执行语句体1，为 false 时计算关系表达式2的值。
3、如果为 true 则执行语句体2，为 false 时计算关系表达式3的值，以此类推。
4、所有关系表达式都为false时，执行else里的语句体n+1。

//案例：键盘录入一个1~7的整数，输出对应的星期一到星期日。
//导包
import java.util.Scanner;
public class IfTest{
	public static void main(String[] args){
		//创建Scanner对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数(1~7)：");
		
		//接收键盘录入的整数
		int week = sc.nextInt();
		
		//使用if-elseif结构判断
		if(week==1){
			System.out.println("星期一");
		}else if(week==2){
			System.out.println("星期二");
		}else if(week==3){
			System.out.println("星期三");
		}else if(week==4){
			System.out.println("星期四");
		}else if(week==5){
			System.out.println("星期五");
		}else if(week==6){
			System.out.println("星期六");
		}else if(week==7){
			System.out.println("星期日");
		}else{
			System.out.println("您输入的数字无效！");
		}
	}
}

17.2.2 switch结构

switch语句格式

switch(表达式){ //整数 byte short int  //char 字符串 //枚举
        case 值1：
            语句体1；
           	break;
        case 值2：
            语句体2；
           	break;
        ...
        default 
            语句体n+1；
           	break;
}

执行流程：
1、先计算括号中表达式的值。
2、将结果依次和case后面的值比较，匹配上的就执行case对应的语句体，遇到break就结束switch结构。
3、当所有的case值都不匹配时，执行default后面的语句体n+1， default省略break，效果一样。

/*
	需求: 键盘输入1 2 3, 输出对应的 "冠军" ,"亚军", "季军" 

*/	
public class SwitchDemo {
	public static void main(String[] args) {
		//获取键盘录入
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数(1~3):");
		int num = sc.nextInt();
	
		switch(num){
			case 1:
				System.out.println("冠军");
				break;
			case 2:
				System.out.println("亚军");
				break;
			case 3:
				System.out.println("季军");
				break;
            default:
                System.out.println("无");
		}
	}
}

switch的注意事项：
1、switch中表达式的值：byte short char int , 枚举， 字符串
2、case 后面的值不能重复，不能是变量，只能是常量
3、case的值都不匹配的时候，执行default的内容，default可以省略(不建议)，default可以改变位置(不建议)
4、break的作用是结束switch语句
5、break可以省略，但是会有case穿透现象
case穿透现象：不用再判断case的值，直接执行下面的语句，直到遇到break或者程序结束。

case穿透案例:

/*
	春夏秋冬

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

	春：3、4、5
	夏：6、7、8
	秋：9、10、11
	冬：12、1、2
*/

import java.util.Scanner;

public class SwitchDemo {
	public static void main(String[] args) {
		//键盘录入月份数据，使用变量接收
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个月份：");
		int month = sc.nextInt();
	
		//case穿透
		switch(month) {
			case 3: 
			case 4:
			case 5:
				System.out.println("春季");
				break;
			case 6:
			case 7:
			case 8:
				System.out.println("夏季");
				break;
			case 9:
			case 10:
			case 11:
				System.out.println("秋季");
				break;
            case 12:
			case 1:
			case 2:
				System.out.println("冬季");
				break;
			default:
				System.out.println("你输入的月份有误");
		}		
	}
}

17.3 循环结构

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候结束循环，否则循环将一直执行下去，形成死循环。

17.3.1 for循环

for循环格式

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

//案例：for循环打印5次HelloWorld
for(int i=1; i<=5; i++){
    System.out.println("HelloWorld");
}

执行流程
1、执行初始化语句：int i = 1（只会执行一次）。
2、执行条件判断语句 i<=5，如果为true，执行循环体语句，如果为false，则结束循环。
3、执行循环体语句 ： System.out.println(“HelloWorld”);
4、执行条件控制语句 ：i++
5、回到第2步继续往下执行。

/*
	需求:使用for循环统计水仙花数的个数
*/
public class ForDemo5 {
    public static void main(String[] args) {
        //定义统计变量
        int count = 0;
        
		// 1. for循环获取所有三位数
		for(int i=100; i<1000; i++) {
            
			// 2. 得到每个三位数的个,十,百位上的数字
			int unit = i/1%10;
			int ten = i/10%10;
			int hundred = i/100%10;
			
			// 3. 判断是否是水仙花数 : 个, 十, 百位立方和等于该三位数本身
			if(unit*unit*unit + ten*ten*ten + hundred*hundred*hundred == i) {
				//4. 统计个数
				count++;
			}
		}
        // 5. 循环结束打印个数
        System.out.println(count);
    }
}

17.3.2 while循环

while循环格式

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

//案例：while循环打印5次HelloWorld 
int i = 1;
while(i<=5){
    System.out.println("HelloWorld");
    i++;
}

执行流程图

/*
	需求:使用while循环求1~100的偶数个数
*/
public class WhileDemo{
	public static void main(String[] args){
		//定义统计变量
		int count = 0;
        
		//初始化循环条件
		int i = 1;
		//循环获得1~100的整数
		while(i<=100){
			//获得偶数
			if(i%2==0){
				//统计个数
				count++;
			}
			//控制循环条件
			i++;
		}
		//循环结束,打印偶数个数
		System.out.println("1~100的偶数个数为:"+count);
	}
}

17.3.3 do while循环

do-while循环格式

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

//案例：while循环打印5次HelloWorld 
int i = 1;
do{
    System.out.println("HelloWorld");
    i++;
}while(i<=5);

执行流程
1、执行初始化语句。（只执行一次）
2、执行循环体语句。
3、执行条件控制语句。
4、执行条件判断语句，如果为false则结束循环，如果为true则回到第2步继续执行。
注意：do-while循环至少会执行一次循环体语句。

17.3.4 三种循环的区别

	for	while	do-while
特点	先判断，再执行	先判断，再执行	先执行，后判断（至少执行一次）
初始化变量	for循环外无法使用初始化变量	循环结束后，初始化变量能继续使用	循环结束后，初始化变量能继续使用
适用场景	循环次数确定的情况	循环次数不确定的情况	循环至少需要执行一次

依次推荐使用：for循环 、while循环 、do-while循环
三种循环的死循环简单写法：

//1、for循环
for(;;){
    
}

//2、while循环(建议)
while(true){
    
}

//3、do-while循环
do{
    
}while(true);

17.4 跳转控制语句

17.4.1 break关键字

break使用场景:
    1、在switch中，用于结束switch结构。
    2、在循环中，用于结束break所在循环。
    3、当有循环嵌套时，可以为循环加上标签，让break结束指定循环。

注意：
	break语句后面不能直接跟其他语句，否则会编译报错。

17.4.2 continue关键字

continue使用场景:
	1. continue只能在循环中使用，用于跳过一次循环，开始下一次循环。
	2. 当有循环嵌套时，可以配合标签,跳到指定循环继续执行。
	
注意：	
	continue后面不能直接跟其他语句，否则会编译报错。

17.4.3 break和continue的区别

break：结束整个循环。
continue：跳过本次循环，继续下一次循环。

public class ControlDemo{
    public static void main(String[] args){
        
        for(int i=1; i<=5; i++){
            if( i%2==0 ){
                continue; //遇到continue开始下次循环：打印奇数
               // break; //遇到break结束整个循环
            }
        }
        
        System.out.println(i);
    }
}

/*
	模拟一个用户系统
	控制台显示一个用户菜单：
		输入数字选择您要的操作：
		1.新增用户  2.修改用户  3.删除用户  4.查看信息  5.退出系统
	工作人员输入对应的编号进行操作，当输入5时退出系统。
*/
import java.util.Scanner;
public class BreakDemo{
	public static void main(String[] args){
		//创建键盘录入对象
		Scanner sc =  new Scanner(System.in);
		
		//死循环
		loop:while(true){
			System.out.println("输入数字选择您要的操作：");
			System.out.println("1.新增用户  2.修改用户  3.删除用户  4.查看信息  5.退出系统");
			
			int num = sc.nextInt();
			
			switch(num){
				case 1:
					System.out.println("新增成功");
					break;
				case 2:
					System.out.println("修改成功");
					break;
				case 3:
					System.out.println("删除成功");
					break;
				case 4:
					System.out.println("当前用户数1000");
					break;
				case 5:
					System.out.println("欢迎使用本软件");
					//结束指定循环：loop  
					break loop; //结束loop标志的的循环
				default:
					System.out.println("您的输入有误,请重新输入！");
			}
		}
	}
}

18. 随机数：Random类

认识Rondom类
Random是java提供的工具类，位于【 java.util 】包下，用于产生随机数。
Random类的使用步骤

1.导包
	import java.util.Random;

2.创建对象	
	Random r = new Random();

3.产生随机数	
	int num = r.nextInt(100);//获取0~99的随机数

注意:r.nextInt(100); 获取0~99的随机数
	r.nextInt(200);  获取0~199的随机数

说明：
nextInt( 数值 )：代表随机生成并返回一个整数，如果括号数值为10，表示生成0-9的整数，数值20，表示生成0~19的整数

产生范围65~90之间的整数   int num =  r.nextInt(26)+65; 0~25 + 65
产生范围97~122之间的整数  int num =  r.nextInt(26)+97; 0~25 + 97

/*
	需求:随机生成一个1~100之间的整数.
*/
//1.导包
import java.util.Random;
public class RandomDemo{
	public static void main(String[] args){
        
		//2.创建Random对象
		Random r = new Random();
		//3.调用方法产生随机数
		int num = r.nextInt(100)+1; 
        
		System.out.println(num);
	}
}

19. 数组

19.1 数组的作用和特点

    作用：数组可用于存储同一类型的多个数据，是一个java的数据容器。
    特点：数组长度固定，所存数据类型一致。

19.2 数组的定义格式

//【格式1】（掌握）
数据类型[]  数组名
    //示例
    int[] arr
    boolean[] arr
    double[]  arr

//【格式2】（了解）
数据类型  数组名[]
    //示例
    double arr[]

什么是数组初始化
java中变量使用前必须完成初始化，数组也一样，需要完成初始化才能使用。
数组初始化就是为数组分配内存空间，并为数组中每个元素赋值。
数组的初始化分为:
动态初始化
静态初始化

19.3 数组的动态初始化

什么是动态初始化
只给定数组的长度，由系统给出默认初始化值。
动态初始化的格式

数据类型[]  数组名 = new 数据类型[数组长度];
double[]  arr = new double[50]; 

格式说明

  int[] arr = new int[5];
         等号左边：
                int:数组的数据类型
                []:代表这是一个数组
                arr:代表数组的名称
        等号右边：
                new:为数组开辟内存空间
                int:数组的数据类型
                []:代表这是一个数组
                5:代表数组的长度

19.4 数组元素访问

数组变量存储的是什么
数组在堆内存中的地址值
什么是索引
数组索引：数组元素的编号，从0开始，最大值为数组长度-1。
可以通过索引操作数组元素。
数组元素访问的格式

数组名[索引]

public class ArrayDemo {
    public static void main(String[] args) {
        //定义并初始化长度为3的int数组
        int[] arr = new int[3];

        //输出数组名，得到一个地址值
        System.out.println(arr);  //[I@880ec60

        //输出数组中的元素
        System.out.println(arr[0]); //默认值0
        System.out.println(arr[1]); //默认值0
        System.out.println(arr[2]); //默认值0
    }
}

19.5 电脑内存分配（指运行内存，非硬盘）

19.6 JVM的内存分配

各个内存区的作用

区域名称	作用
栈内存（Stack）	方法运行时使用的内存，存放方法中的变量和参数
堆内存（Heap）	存储对象或数组，new出来的数据，都存储在堆内存
堆内存（Heap）	存储对象或数组，new出来的数据，都存储在堆内存
寄存器	给CPU使用，和我们开发无关
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关
方法区	存储已加载的class文件信息

栈内存：栈中存放局部变量，方法执行完毕，内存释放。
堆内存：堆中存放的是new出来的数据( 数组，对象等 )。数据使用完毕后，等待垃圾回收器回收。
              new出来的数据, 都有一个对应的地址

19.7 数组的内存图

数组元素的默认初始化值

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

19.7.1 一个数组的内存图

19.7.2 多个数组的内存图

19.7.3 多个数组指向相同的内存地址

其中任意一个数组改变了堆中元素的值，其他的数组都会受到影响

19.8 数组的静态初始化

什么是静态初始化
在创建数组时，直接确定元素的值。
静态初始化的格式

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

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

静态初始化简化格式

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

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

19.9 数组的遍历

获取数组长度
数组名.length
遍历数组

//for循环进行数组遍历
public class ArrayDemo2 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55};

        //使用for循环遍历并打印
        for(int i=0; i <arr.length; i++) {
            System.out.println(arr[x]);
        }
    }
}

求最值

/*
 * 需求：求出数组的最大值、最小值
 */
public class ArrayDemo3 {
	public static void main(String[] args) {
		//定义数组
		int[] arr = {45,12,98,73,60};
		
		//------------求数组最大值------------    
		//定义变量存放数组最大值，并假设第一个元素为最大值
		int max = arr[0];
		//从第二个元素开始，依次和max变量比较
		for(int i=1; i<arr.length; i++){
			//如果比max大的，就替换max的值
			if( arr[i]>max ){
				max = arr[i];
            
			}
		}
		//循环结束后max存放的就是最大的值
		System.out.println("最大值为："+ max);

		//------------求数组最小值------------
        
		//假设第一个元素是最小的
		int min = arr[0];
		//从第二个元素开始，依次和min变量比较
		for(int i=1; i<arr.length; i++){
			//如果比min小的，就替换min的值
			if( arr[i]<min ){
				min = arr[i];
			}
		}
		//循环结束后，打印最小值
		System.out.println("最小值为：" + min);
	}
}

19.10 多维数组

数组元素类型[] 数组名;

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

一维数组:数组中的每一个元素都是一个值(基本类型和引用类型的值).
二维数组:数组中的每一个元素又是一个一维数组.
三维数组:数组中的每一个元素又是一个二维数组.

二维数组的初始化操作:
静态初始化:
int[][]  arr = new int[][]   {
	{1,2,3} ,
	{4,5},
	{6}
};
动态初始化:
int[][]  arr = new int[3][5] ;创建一个长度为3的二维数组,每一个元素(一维数组)的长度为5.
int[][]  arr = new int[0][5] 
-------------------------------------
针对于N维数组,需要N个循环嵌套.

20. 方法

20.1 方法的概述

什么是方法
方法是将具有独立功能的代码组成一个整体，使其成为具有特殊功能的代码块。
方法的两个注意
1、方法必须先定义才能使用。（方法定义）
2、方法定义后不会自动运行，需要手动调用才能执行方法的功能。（方法调用）

20.2 方法的定义和调用

20.2.1方法的定义格式1：无参数无返回值

public static void 方法名(){
    方法体代码; //需要在方法内完成的代码
    
}

//调用格式
方法名（）

/*
	需求:
		1. 定义一个方法,方法名为: printHelloWorld
		2. 在方法中使用循环打印5次hello world.
		3. 在main方法中调用执行 printHelloWorld 方法.
*/
public class MethodDemo {
    public static void main(String[] args){
        printHelloWorld();
    }
    public static void printHelloWorld(){
        for(int i=1;i<=5;i++){
            System.out.println("hello world");
        }
    }
    
}

方法在栈中的调用执行过程

1、栈是方法运行的内存区域。
2、先调用的方法先入栈，后调用的方法后入栈，后入栈的方法先执行完毕，并在栈内存中消失。
3、main方法是最先开始执行，最晚从内存中消失的。

20.2.2 方法的定义格式2：有参数无返回值

public static void 方法名( 参数类型1 参数名1, 参数类型2 参数名2, ...){
    方法体代码; 
}

注意：
	方法的参数，可以是一个，也可以是多个，如果是多个参数，中间需要以逗号分隔。
	
//调用格式
方法名（参数值1/变量1，参数值2/变量2，...）

调用带参方法的注意事项

1、调用带参方法，传入方法括号里的参数，无论个数和类型，都必须和方法定义时的个数和类型匹配。
2、传入方法的参数，可以是变量，也可以是常量。

20.2.3 形参和实参

形参，也叫形式参数，指的是定义方法的时候，方法小括号中定义的参数。
实参，也叫实际参数，指的是调用方法的时候，传入小括号中的常量或变量。

20.2.4 方法的定义格式3：有、无参数有返回值

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

//无参数有返回值
public static void 方法名（参数列表）{
    方法体代码；
    return 数据值；
}

1、格式要求
有返回值类型，就必须要有return语句。
返回值必须和返回值类型相匹配。
2、return语句的作用
return语句用于将方法的运算结果返回给调用者。
return语句一旦执行，方法的调用就结束了。
return语句后面不能直接跟其他代码
3、有返回值的方法是否一定要接收返回结果
调用有返回值的方法时，方法的返回值可以接收也可以不接收，根据实际需要确定。如果不接收，该返回值就会丢失。大部分情况下，需要接收返回结果的。
4、有返回值的方法调用方式

1. 直接调用：该方式会丢失返回值数据。
	方法名(参数值);

2. 输出调用：在输出语句中调用，直接使用结果。
	System.out.println( 方法名(参数值) );

3. 赋值调用：调用方法，并定义变量接收返回值。 （使用最多的方式）
	数据类型  变量名 =  方法名(参数值);

20.2.5 方法使用注意事项

1、方法与方法之间是平级关系，不允许嵌套定义。
2、方法有明确返回值类型时，必须要有return语句返回对应的数据。
3、返回值类型为void，则代表无返回值，可以省略return语句，也可以单独使用return关键字，用于结束方法，但是return后面不能跟任何数值。
4、方法有形参时，调用时必须传递实参，传递的实参个数和类型必须和形参匹配。
5、return语句后面不能直接跟其他代码。

20.2.6 方法的通用格式

public static  返回值类型  方法名(参数类型  参数名1, 参数类型  参数名2, ...){
    方法体代码;
    return 返回值;
}

格式说明：
        public static：public和static都是关键字，具有特殊的含义。（先这样写着，后续讲解）
        返回值类型：方法有返回值时写返回值类型（基本数据类型、引用数据类型），没有返回值时写void。
        方法名：用于方法调用时使用。
        ( )：括号里面写参数列表，多个参数使用逗号隔开，没有参数时直接写 ( ) 即可。
        参数类型：限定传入方法的参数的数据类型。（基本数据类型、引用数据类型）
        参数名：用于接收传入方法的数据。
        { }：大括号和里面的代码称为方法体。
        return：方法有返回值时需要使用return关键字，返回对应的类型的数据。 没有返回值（void）时不用写return语句。
定义方法的两个明确：
        1、明确返回值类型：确定方法是否需要返回值，以及返回值的类型。
        2、明确参数：明确参数的类型和个数。
调用方法注意：
        1、void类型的方法，直接调用即可。
        2、非void类型的方法，推荐使用变量接收调用。
        3、方法有参数时，调用时需要传参。

20.3 方法重载

20.3.1 什么是方法重载

同一个类中，出现了多个同名的方法，叫做方法重载。

20.3.2 构成方法重载的条件

    1. 多个方法在同一个类中。
    2. 多个方法名称相同。
    3. 多个方法的参数列表不同（个数或者类型不同）。

    注意：
        方法重载与返回值和参数名称无关。

    简单总结： 
        同一类中，方法名称相同，参数列表不同，即构成方法重载。

20.3.3 方法重载的作用

方便程序员对参数不同，但是功能相同或相似的方法进行统一的命名和调用。

20.3.4 调用重载的方法

调用时，虚拟机会根据参数列表的不同来区分调用对应的重载方法。

20.4 方法参数传递

20.4.1 方法参数传递基本类型

结论：
方法参数为基本数据类型时，参数为值传递，形式参数的改变不会影响实际参数
代码：

/*
	参数传递为基本数据类型
*/
public class MethodDemo4 {
    public static void main(String[] args) {
        int num  = 5;
        add(num);
        System.out.println(num);
    }

    //方法形参为基本数据类型
    public static void add(int num){
        num+=10; //num = 15;
    }
}

20.4.2 方法参数传递引用类型

什么是引用类型数据？
在堆内存中创建，并产生了一个地址值的数据。（数组、对象，接口）
结论：
方法参数为引用数据类型时，参数为地址传递，形式参数的改变会直接影响实际参数。
代码：

/*
参数传递为引用类型
*/
public class MethodDemo5 {
    public static void main(String[] args) {

        int[] arr = {10,20,30};
        System.out.println("调用前："+arr[0]); //10

        change(arr);

        System.out.println("调用后："+arr[0]); //100
    }

    //方法形参为引用类型
    public static void change(int[] arr) {
        arr[0] = 100;
    }
}