一Java的基本语法
1 Java中的关键字
关键字（Keyword）是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字。JDK 8中有50个关键字，这些关键字都是小写的。
| abstract | assert | boolean | break | byte |
|---|---|---|---|---|
| case | catch | char | class | const |
| continue | default | do | double | else |
| enum | extends | final | finally | float |
| for | goto | if | implements | import |
| instanceof | int | interface | long | native |
| new | package | private | protected | public |
| return | strictfp | short | static | super |
| switch | synchronized | this | throw | throws |
| transient | try | void | volatile | while |
2Java中的标识符
定义：在编程过程中，经常需要在程序中定义一些符号来标记一些名称，如包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。
组成：标识符可以由任意顺序的大小写字母、数字、下划线（_）和美元符号（$）组成，但标识符不能以数字开头，也不能是Java中的关键字。
合法标识符:
username username123 user_name _userName
非法标识符:
123username // 不能以数字开头 class // 不能是关键字 Hello World // 不能包含空格特殊字符
通用规范:
| ①包名所有字母一律小写。例如：com.itheima.example01。 |
|---|
| ②类名和接口名每个单词的首字母都要大写。例如：ArrayList、Iterator。 |
| ③常量名所有字母都大写，单词之间用下划线连接。例如：DAY_OF_MONTH。 |
| ④变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如：lineNumber、getLineNumber。 |
| ⑤在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如：使用userName表示用户名，password表示密码。 |
3 Java中的注释
作用：在编写程序时，为了使代码易于阅读，通常会在实现功能的同时为代码添加一些注释。注释是对程序的某个功能或者某行代码的解释说明，它能够让开发者在后期阅读和使用代码时能更容易理解代码的作用。
说明：注释只在Java源文件中有效，在编译程序时编译器会忽略这些注释信息，不会将其编译到class字节码文件中。
(1)单行注释
单行注释通常用于对程序中的某一行代码进行解释，用符号“//”表示，“//”后面为被注释的内容。
int c = 10; // 定义一个整型变量c
(2)多行注释
多行注释顾名思义就是可以同时为多行内容进行统一注释，它以符号“/*”开头，并以符号“*/”结尾。
/* 定义一个整形变量x 将5赋值给变量x */ int x; x = 5;
(3)文档注释
文档注释通常是对程序中某个类或类中的方法进行的系统性的解释说明，开发人员可以使用JDK提供的javadoc工具将文档注释提取出来生成一份API帮助文档。文档注释以符号“`/”开头，并以符号“*/`”结尾**。
/**
* Title：HelloWorld类
* @author ycy
* @version 1.0
*/
public class HelloWorld {
/**
* 这是一个main()方法入口
* @param args 参数名
*/
public static void main(String[] args){
System.out.println("这是第一个Java程序！");
}
}
(4)注释的嵌套
在Java中，有的注释可以嵌套使用，有的则不可以
1)多行注释可以嵌套单行注释
/* int c = 10; // 定义一个整型的c int x = 5; */
2)多行注释不能嵌套多行注释
/* /*int c = 10;*/ int x=5; */
二 变量和常量
1常量
定义：常量就是在程序中固定不变的值，是不能改变的数据。例如数字1、字符'a'、浮点数3.2等。
分类：在Java中，常量包括整型常量、浮点数常量、布尔常量、字符常量等。
(1)整型常量
整型常量是整数类型的数据，有二进制、八进制、十进制和十六进制4种
| 二进制： | 由数字0和1 组成的数字序列。在JDK 7以后，允许使用二进制字面值来表示整数，此时二进制数值前面要以0b或0B开头，目的是为了和十进制进行区分，如：0b01101100、0B10110101。 |
|---|---|
| 八进制： | 以0开头，并且其后由0 ~7范围（包括0和7）内的整数组成的数字序列，如：0342。 |
| 十进制： | 由数字0~9范围（包括0和9）内的整数组成的数字序列。如：198。 |
| 十六进制： | 以0x或者0X开头，并且其后由0~9、A~F（包括0和9、A和F）组成的字符序列，如：0x25AF。 |
(2)浮点常量
浮点数常量就是在数学中用到的小数，分为float单精度浮点数和double双精度浮点数两种类型。
例如:
2e3f 3.6d 0f 3.84d 5.022e+23f
注意:
单精度浮点数后面以F或f结尾，而双精度浮点数则以D或d结尾。当然，在使用浮点数时也可以在结尾处不加任何后缀，此时Java虚拟机会将浮点数默认识别为double双精度浮点数。
(3)字符常量
字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号（' '）引起来，它可以是英文字母、数字、标点符号以及由转义序列来表示的特殊字符。
例如:
'a' '1' '&' '\r'
(4)字符串常量
字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号（" "）引起来。
例如:
"HelloWorld" "123" "Welcome \n XXX" ""
(5)布尔常量
布尔常量即布尔类型的两个值true和false，该常量用于区分一个条件的真假。
(6)null常量
null常量只有一个值null，表示对象的引用为空。
2转义符
定义：在字符常量中，反斜杠（\）是一个特殊的字符，被称为转义符，它的作用是用来转义紧随其后的一个字符。
说明：转义后的字符通常用于表示一个不可见的字符或具有特殊含义的字符，例如“\n”表示换行。
常见的转义字符:
| \r ： | 表示回车，将光标定位到当前行的开头，不会跳到下一行。 |
|---|---|
| \n ： | 表示换行，换到下一行的开头。 |
| \t ： | 表示制表符，将光标移到下一个制表符的位置，就像在文档中用Tab键一样。 |
| \b ： | 表示退格符号，就像键盘上的Backspace。 |
3 java中的常量
定义：Java中的常量，其实就是特殊的变量，也是固定不变的量，有且只能进行一次赋值。
语法：Java中定义常量的语法也非常简单，只需要在定义变量的语法基础上加上一个final关键字修饰即可。
Java中的常量的语法格式：
final 常量类型 常量名 [= 初始值];
例如：
final int a=0, b; // 定义一个int类型的常量a和b，并为常量a初始化赋值0 b= 1; // 后续为常量b赋值
4 变量
定义：在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。
变量的基本语法格式如下：
变量类型 变量名 [= 初始值];
变量类型:决定了变量的数据性质、范围、存储在内存中所占的字节数以及可以进行的合法操作
变量名:必须是一个合法的标识符
[]:代表可选项，即在定义变量的同时，可以对该变量进行初始化赋值
例如:
int x = 0,y; y = x+3;
说明：
上述代码中，第一行代码的作用是定义了两个int类型的变量x和y，也就相当于分配了两块内存单元，在定义变量的同时为变量x分配了一个初始值0，而变量y没有分配初始值。
变量x和y在内存中的状态变化图：
5 变量的数据类型
Java是一门强类型的编程语言，它对变量的数据类型有严格的限定。在定义变量时必须先声明变量的数据类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序在编译期间就会出现类型匹配错误的问题。
在Java中变量的数据类型分为两种：基本数据类型和引用数据类型。
(1)基本数据类型
基本数据类型总共有8个,也叫作8大基本数据类型
1)整数类型变量
整数类型变量用来存储整数数值，即没有小数部分的值。
| 类型名 | 占用空间 | 取值范围 |
|---|---|---|
| byte | 8位（1个字节） | -128 ～ 127 |
| short | 16位（2个字节） | -215 ～ 215-1 |
| int | 32位（4个字节） | -231 ～ 231-1 |
| long | 64位（8个字节） | -263 ～ 263-1 |
例如:
long num = 2200000000L; // 所赋的值超出了int型的取值范围，后面必须加上字母L long num = 198L; // 所赋的值未超出int型的取值范围，后面可以加上字母L long num = 198; // 所赋的值未超出int型的取值范围，后面可以省略字母L
注意:
在为一个long类型的变量赋值时，所赋值的后面要加上一个字母“L”（或小写“l”），说明赋值为long类型。如果赋的值未超出int型的取值范围，则可以省略字母“L”（或小写“l”）。
2)浮点数类型变量
浮点数类型变量用来存储小数数值
| 类型名 | 占用空间 | 取值范围 |
|---|---|---|
| float | 32位（4个字节） | 1.4E-45 ～ 3.4E+38，-1.4E-45 ～ -3.4E+38 |
| double | 64位（8个字节） | 4.9E-324 ～ 1.7E+308，-4.9E-324 ～ -1.7E+308 |
例如:
float f = 123.4f; // 为一个float类型的变量赋值，后面必须加上字母f或F
double d1 = 199.3d; // 为一个double类型的变量赋值，后面可以加上字母d或D
double d2 = 100.1; // 为一个double类型的变量赋值，后面可以省略字母d或D
float f = 100; // 声明一个float类型的变量并赋整数值
double d = 100; // 声明一个double类型的变量并赋整数值
注意:
一个小数会被默认为double类型的值，因此在为一个float类型的变量赋值时，所赋值的后面一定要加上字母“F”（或者小写“f”），而为double类型的变量赋值时，可以在所赋值的后面加上字符“D”（或小写“d”），也可以不加。
在程序中也可以为一个浮点数类型变量赋予一个整数数值
3)字符类型变量
字符类型变量用于存储一个单一字符，在Java中用char表示。
Java中每个char类型的字符变量都会占用2个字节(16位)。
在给char类型的变量赋值时，需要用一对英文半角格式的单引号（' '）把字符括起来，如'a'，也可以将char类型的变量赋值为0~65535范围内的整数，计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为'a'。
例如:
char c = 'a'; // 为一个char类型的变量赋值字符'a' char ch = 97; // 为一个char类型的变量赋值整数97，相当于赋值字符'a'
4)布尔类型变量
布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型的变量只有两个值，即true和false。
例如:
boolean flag = false; // 声明一个boolean类型的变量，初始值为false flag = true; // 改变flag变量的值为true
(2)引用数据类型
除了8大基本数据类型,其余全部是引用类型
例如:保存字符串需要用到String类型
String str = "hello world";
6 变量的类型转换
说明：在程序中，当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。
分类：根据转换方式的不同，数据类型转换可分为两种：自动类型转换和强制类型转换。
(1)自动类型转换
自动类型转换也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。当把一个类型取值范围小的数值直接赋给另一个取值范围大的数据类型变量时，系统就会进行自动类型转换。
自动类型转换就好比将小瓶水倒入到大瓶的换装过程。我们将小瓶水倒入到大瓶中时，由于小瓶的容量比大瓶的容量小，所以倒入的水永远不可能溢出大瓶。
Java中支持的不同数据类型之间的自动转换，如下图所示。
例如:
byte b = 3; int x = b; // 程序把byte类型的变量b转换成了int类型，无需特殊声明 double y = x; // 将int类型的变量x转换成double类型，无需特殊声明
(2)强制类型转换
强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。
强制类型转换就好比将大瓶水倒入到小瓶中一样，如果大瓶中的水的容量小于小瓶的大小，那么水是可以完全倒入的；否则多出来的水就会溢出。所以系统默认不支持这种行为，只能由开发者自己决定是否进行强制类型转换。
强制类型转换语法格式：
目标类型 变量名 = （目标类型）值;
例如:
int a = 127; byte b = (byte)a; //127在byte的存储范围内,可以正常强制转换 int c = 128; b = (byte)c;//128超出了byte的存储范围,强制转换,数据会丢失
注意：
在对变量进行强制类型转换时，会发生取值范围较大的数据类型向取值范围较小的数据类型的转换情况，如将一个int类型的数转为byte类型，这样做极容易造成数据精度的丢失。
(3)表达式类型自动提升
所谓表达式是指由变量和运算符组成的一个算式。变量在表达式中进行运算时，也有可能发生自动类型转换，这就是表达式数据类型的自动提升，如byte、short和char类型的变量在运算期间类型会自动提升为int，然后再进行运算。
例如:
byte a = 1; byte b = 2; byte c = a+b; //报错:a和b在进行运算时会自动提升为int,所以a+b的结果是int类型
7 变量的作用域
定义：变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
三 运算符
所谓运算符就是专门用于告诉程序执行特定运算或逻辑操作的符号。
| 算术运算符 |
|---|
| 赋值运算符 |
| 比较运算符 |
| 逻辑运算符 |
| 条件运算符 |
1 算术运算符
Java中的算术运算符就是用来处理四则运算的符号。
也是最简单和最常用的运算符号。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +3 | 3 |
| - | 负号 | b=4;-b; | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 6-4 | 2 |
| * | 乘 | 3*4 | 12 |
| / | 除（即算数中整除的结果） | 7/5 | 1 |
| % | 取模（即算术中的求余数） | 7%5 | 2 |
| ++ | 自增（前） | a=2;b=++a; | a=3;b=3; |
| ++ | 自增（后） | a=2;b=a++; | a=3;b=2; |
| -- | 自减（前） | a=2;b=--a; | a=1;b=1; |
| -- | 自减（后） | a=2;b=a--; | a=1;b=2; |
注意:
在进行自增（++）和自减（--）的运算时，如果运算符（++或--）放在操作数的前面则是先进行自增或自减运算，再进行其他运算。反之，如果运算符放在操作数的后面则是先进行其他运算再进行自增或自减运算。
在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数；如果除法运算有小数参与，得到的结果会是一个小数。
在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。
2赋值运算符
赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量。
它将运算符右边的值赋给左边的变量。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| = | 赋值 | a=3;b=2; | a=3;b=2; |
| += | 加等于 | a=3;b=2;a+=b; | a=5;b=2; |
| -= | 减等于 | a=3;b=2;a-=b; | a=1;b=2; |
| *= | 乘等于 | a=3;b=2;a*=b; | a=6;b=2; |
| /= | 除等于 | a=3;b=2;a/=b; | a=1;b=2; |
| %= | 模等于 | a=3;b=2;a%=b; | a=1;b=2; |
在使用+=、-=、*=、/=、%= 赋值运算符时，需要进行的强制类型转换会自动完成，程序不需要做任何显式地声明
public class Example05 {
public static void main(String[] args) {
short s = 3;
int i = 5;
s += i;
System.out.println("s = " + s);
}
}
注意:
在Java中可以通过一条赋值语句对多个变量进行赋值。
在赋值运算符中，除了“=”，其他的都是特殊的赋值运算符，以“+=”为例，x += 3就相当于x = x + 3，首先会进行加法运算x+3，再将运算结果赋值给变量x。其余的-=、*=、/=、%=赋值运算符都可依此类推。
3 比较运算符
用来对两个数值或变量进行比较。
其结果是布尔类型的true或false。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4 == 3 | false |
| != | 不等于 | 4 != 3 | true |
| < | 小于 | 4 < 3 | false |
| > | 大于 | 4 > 3 | true |
| <= | 小于等于 | 4 <= 3 | false |
| >= | 大于等于 | 4 >= 3 | true |
4 逻辑运算符
是用于对布尔类型的值或表达式进行操逻辑判断的符号。
其返回值类型是布尔类型。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| & | 与 | a & b | a和b都为true，结果为true，否则为false |
| | | 或 | a | b | a和b中只要有一个为true，则结果为true，否则为false |
| ^ | 异或 | A ^ b | a与b不同，结果为true，否则为false |
| ! | 非 | ! A | 若a为false，结果为true，否则相反 |
| && | 短路与 | a && b | a和b都为true，结果为true，否则为false |
| || | 短路或 | a || b | a和b中只要有一个为true，则结果为true，否则为false |
注意:
逻辑运算符可以针对结果为布尔值的表达式进行逻辑运算。如：5 > 3 && 1 != 0的结果为true。
运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。
“&”和“&&”的区别：在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。如果使用&&进行运算，当左边为false时，右边的表达式不会进行运算，因此“&&”被称作短路与。
运算符“|”和“||”都表示或操作，当运算符任何一边的操作数或表达式为true时，其结果为true，当两边的值都为false时，其结果才为false。同与操作类似，“||”表示短路或，当运算符“||”的左边为true时，右边的表达式不会进行运算。
运算符“^”表示异或操作，当运算符两边的布尔值相同时（都为true或都为false），其结果为false。当两边布尔值不相同时，其结果为true。
5 条件运算符
也称作三元运算符（或三目运算符），由符号“? :”组合构成。
对布尔类型的表达式判断，如果为true，就执行冒号“:”前面的表达式，否者执行后面的表达式。
格式:
(boolean_expr) ? true_statement : false_statement;
规则：先判断boolean_expr的值，如果为true，就执行表达式true_statement，否者执行表达式false_statement
例如:
int store = 5; System.out.println(store <=0 ? "没有库存啦！" : "库存量为："+store); // 输出结果为 “库存量为：5”
6 运算符的优先级
指的是在表达式中各个运算符参与运算的先后顺序
例如：先乘除，后加减
| 优先级 | 运算符 |
|---|---|
| 1 | . [] () |
| 2 | ++ -- ~ ! |
| 3 | * / % |
| 4 | + - |
| 5 | << >> >>> |
| 6 | < > <= >= |
| 7 | == != |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ?: |
| 14 | = *= /= %= += -= <<= >>= >>>= &= ^= |= |
四 选择结构语句
在实际生活中经常需要作出一些判断，比如开车来到一个十字路口，这时需要对红绿灯进行判断，如果前面是红灯，就停车等候，如果是绿灯，就通行。Java中有一种特殊的语句叫做选择结构语句，它也需要对一些条件作出判断，从而决定执行哪一段代码。
Java中的选择结构语句分为：if条件语句和switch条件语句
1 if条件语句
if条件语句的分类:
(1)if语句
格式:
if(判断条件){
满足条件执行的代码
}
执行流程:
例如:
如果一个人的年龄不满18周岁，那么就可以判定这个人是未成年人
/*
伪代码:
if (年龄不满18岁) {
此人是未成年人！
}
*/
int age = 20;
if(age<18){
System.out.println("此人是未成年人!");
}
(2)if...else语句
格式:
if (判断条件){
执行语句1
...
}else{
执行语句2
...
}
执行流程:
例如:
int age = 16;//定义变量age,保存年龄
if(age>=18){//年龄大于等于18-->代码
//条件成立
System.out.println("恭喜你,被录用了");
}else{
//条件不成立
System.out.println("很遗憾,年龄不满足需求");
}
注意:
if...else语句还可以与前面学习的条件运算符“？:”进行替换。
System.out.println(num % 2 == 0 ? num+"是一个偶数" :num+"是一个奇数" );
(3)if...else if...else语句
格式:
if (判断条件1) {
执行语句1
} else if (判断条件2) {
执行语句2
}
...
else if (判断条件n) {
执行语句n
} else {
执行语句n+1
}
执行流程:
例如:
int num = 100;
//根据数字输出对应的星期
if(num==1){
System.out.println("星期一");
}else if(num==2){
System.out.println("星期二");
}else if(num==3){
System.out.println("星期三");
}else if(num==4){
System.out.println("星期四");
}else if(num==5){
System.out.println("星期五");
}else if(num==6){
System.out.println("星期六");
}else if(num==7){
System.out.println("星期天");
}else{
System.out.println("无效的星期");
}
2 switch条件语句
定义：switch 条件语句也是一种很常用的选择结构语句，它由一个switch控制表达式和多个case关键字组成。
说明：与if条件语句不同的是，switch 条件语句的控制表达式结果类型只能是byte、short、char、int、enum枚举以及String类型，而不能是boolean类型。
格式:
switch (控制表达式){
case 目标值1:
执行语句1
break;
case 目标值2:
执行语句2
break;
．．．
case 目标值n:
执行语句n
break;
default:
执行语句n+1
break;
}
规则： switch语句将控制表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，会执行对应case后的执行语句，并通过break关键字跳出该switch语句；如果搜索完所有case中的目标值仍没找到任何匹配的值，就会执行default后的语句。
注意:
第一，switch条件语句后{}中的多个case以及default标签顺序可以随机，并不影响程序的执行结果；
第二，在case和default标签中的执行语句后务必都加上break关键字，用于执行完语句后跳出当前的switch条件语句，否则，程序会接着执行后续的执行语句，直到遇到break关键字或switch语句末尾为止。
例如:
根据月份判断当前所属季节
int month = 9;
switch(month){
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
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;
default:
System.out.println("月份不正确!");
break;
}
五 循环结构语句
在实际生活中经常会将同一件事情重复做很多次，例如在做眼保健操的第四节轮刮眼眶时，会重复刮眼眶的动作；打乒乓球时，会重复挥拍的动作等。在Java中有一种特殊的语句叫做循环语句，它可以实现将一段代码重复执行，例如循环打印100位学生的考试成绩。
循环语句的分类:
1 while循环
定义：while循环语句和选择结构语句有些相似，都是根据条件判断来决定是否执行大括号{}内的执行语句。
区别：while语句会循环判断循环条件是否成立，只要条件成立，{}内的执行语句就会执行，直到循环条件不成立，while循环才结束。
格式:
while(循环条件){
执行语句
...
}
执行流程:
注意:
一般会通过 一个变量来控制循环条件
循环内容执行后需要对变量进行+1操作
例如:
循环输出10次"hello world"
int i = 0; //定义一个变量i,控制循环次数
while(i<10){
System.out.println("hello world");
i++;//对变量i进行+1操作
}
循环出1-10
int i = 1;//定义一个变量i,控制循环次数
while(i<=10){
System.out.println(i);
i++;//对变量i进行+1操作
}
2 do-while循环
定义：do…while循环语句也被称为后测试循环语句，它和while循环语句的功能类似。
区别：while是先判断条件后执行循环体，而do...while会无条件执行一次循环体后再判断条件。
格式:
do {
执行语句
...
} while(循环条件);
执行流程:
注意:
一般会通过 一个变量来控制循环条件
循环内容执行后需要对变量进行+1操作
例如:
循环输出10次"hello world"
int i = 0; //定义一个变量i,控制循环次数
do{
System.out.println("hello world");
i++;对变量i进行+1操作
}while(i<10)
循环出1-10
int i = 1;//定义一个变量i,控制循环次数
do{
System.out.println(i);
i++;//对变量i进行+1操作
}while(i<=10)
3 for循环
for循环语句是最常用的循环语句，一般用在循环次数已知的情况下，通常情况下可以代替while循环。
格式:
for（初始化表达式; 循环条件; 操作表达式）{
执行语句
...
}
执行流程:
例如:
循环输出10次"hello world"
for(int i=0;i<10;i++){
System.out.println("hello world");
}
循环出1-10
for(int i=1;i<=10;i++){
System.out.println(i);
}
对1-10进行求和
int sum = 0;//定义一个变量,保存求和结果
for(int i=1;i<=10;i++){
//累计相加进行求和
sum += i; // sum = sum + i;
}
System.out.println("1-10的求和结果是:"+sum);
4 循环嵌套
定义：嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。
说明：while、do…while、for循环语句都可以进行循环嵌套，并且它们之间也可以互相嵌套。在实际开发时，我们最常用的是for循环嵌套。
双层for循环:
for(初始化表达式; 循环条件; 操作表达式) {
...
for(初始化表达式; 循环条件; 操作表达式) {
执行语句
...
}
...
}
规则：在双层for循环嵌套中，外层循环每执行一轮，都要执行完内层循环中的整个for循环，然后执行外层循环第二轮，接着再执行完内层循环中的整个for循环，以此类推，直至外层循环的循环条件不成立，才会跳出整个嵌套for循环。
例如:
//外层for循环
for(int i=0;i<3;i++){
System.out.println("外层for循环:"+i);
//内层for循环
for(int j=0;j<3;j++){
System.out.println("***内层for循环:"+j);
}
}
结果:
5 跳转语句(break/continue)
定义：跳转语句用于实现循环语句执行过程中程序流程的跳转。
分类：在Java中的跳转语句有break语句和continue语句。
(1)continue语句
使用场景：continue语句用在循环语句中。
作用效果：它的作用是终止本次循环，执行下一次循环。
例如:
for(int i=1;i<=10;i++){
if(i == 3){ //当i的值等于3
continue; //跳到下一次循环
}
System.out.println(i); // 输出i的值
}
结果:
(2)break语句
使用场景：在switch条件语句和循环结构语句中都可以使用break语句。
作用效果：
当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构；
当它出现在循环结构语句中时，作用是跳出当前循环结构语句，执行后面的代码。
例如:
for(int i=1;i<=5;i++){
if(i == 3){ //当i的值等于3
break; //结束当前循环语句
}
System.out.println(i); // 输出i的值
}
结果:
例如:
//外层for循环
for(int i=0;i<3;i++){
System.out.println("外层for循环:"+i);
//内层for循环
for(int j=0;j<3;j++){
System.out.println("***内层for循环:"+j);
break;//结束当前所在循环:内层for循环
}
}
结果:
注意:
break结束的当前所在循环,也就是内层循环,不会影响外层for循环
如果想要在内层for循环中结束外层for循环,可以给for循环取名字
//外层for循环,取名outer
outer:for(int i=0;i<3;i++){
System.out.println("外层for循环:"+i);
//内存for循环,取名inner
inner:for(int j=0;j<3;j++){
System.out.println("***内存for循环:"+j);
break outer; //结束外层for循环
}
}
结果:
6 循环嵌套案例
例1:
//外层控制行
for(int i=0;i<5;i++){
// 内层循环控制列
for(int j=0;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
结果:
例2:
//外层控制行
for(int i=0;i<5;i++){
// 内层循环控制列
for(int j=0;j<5-i;j++){
System.out.print("*");
}
System.out.println();
}
结果:
六 数组
假设如下场景：
现在需要统计某公司100名员工的工资情况，例如计算平均工资、最高工资等。
可能的办法：
用前面所学的知识，程序就需要声明100个变量来分别记住每位员工的工资（这样的话非常麻烦）。
解决办法：
可以使用一个数组来记住这100名员工的工资，然后对数组的元素进行操作。
定义：数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。
分类：一维数组和多维数组。
1 格式:
数组类型[] 数组名 = new 数组类型[数组长度];
数组类型[] 数组名 = new 数组类型[]{数组元素0,数组元素1,...};
数组类型[] 数组名 = {数组元素0,数组元素1,...};
例如:
int[] ids = new int[100];
String[] names = new String[]{"张三","tom",...};
Object[] object = {"张三","tom",...};
2 数组内存图
3 不同类型元素的初始值
| 数据类型 | 默认初始值 |
|---|---|
| byte、short、int、long | 0 |
| float、double | 0.0 |
| char | 一个空字符，即’\u0000’ |
| boolean | false |
| 引用数据类型 | null，表示变量不引用任何对象 |
注意问题
①每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错（ArrayIndexOutOfBoundsException，即数组角标越界异常）。
②在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现错误（NullPointerException，即空指针异常）。
4 数组常见操作
在程序开发中，数组的应用非常广泛，灵活地使用数组对实际开发很重要。接下来，本节将针对数组的常见操作，如数组的遍历、最值的获取、数组的排序等，进行详细地讲解。
(1)遍历数组
int[] arr = {6,9,2,1,5}; //定义一个数组
//使用for循环遍历数组
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
结果:
(2)找最大值
int[] arr = {6,9,2,1,5}; //定义一个数组
//找最大值
int max = arr[0];//假设数组中第一个数是最大值
//遍历出第一个数后的所有数
for(int i=1;i<arr.length;i++){
if(arr[i]>max){//如果遍历出来的数比max大
//把max改成较大的数
max = arr[i];
}
}
System.out.println("最大值是:"+max);
结果:
(3)冒泡排序
int[] arr = {6,9,2,1,5}; //定义一个数组
// 冒泡排序
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
//从小到大
if(arr[j]>arr[j+1]){//如果前面的数大于后面的数
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
// 打印排好序的数组
System.out.println(Arrays.toString(arr));
结果:
(4)二分查找法(有序数组)
int num = 9;//定义一个要查找的数据
int[] arr = {1,2,5,6,9}; //定义一个数组
int min = 0; // 最小索引值
int max = arr.length-1;//最大索引值
int mid = (min+max)/2;//中间索引值
while(true){ // 不确定要找多少次,所以使用while循环
if(num > arr[mid]){ // 如果num比中间数大
min = mid + 1; // 最小索引值min = mid+1
}else if(num < arr[mid]){//如果num比中间数小
max = mid - 1; // 最大索引值max = mid-1
}else{// 如果num等于中间数
System.out.println(num+"在数组中,索引值是:"+mid);//num在数组中
break;//结束循环,不找了
}
mid = (min+max)/2; // 由于min和max在变化,所以每次都要修改mid的值
if(min>max){ // 如果min>max,说明没找到
System.out.println(num+"不在数组中");
break; // 结束循环,不找了
}
}
结果:
5 多维数组
在程序中可以通过一个数组来保存某个班级学生的考试成绩，试想一下，如果要统计一个学校各个班级学生的考试成绩，又该如何实现呢？
上面这种场景就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。而在程序中，比较常见的多维数组是二维数组。
(1)二位数组的格式:
数据类型[][] 数组名 = new 数据类型[二维数组长度][每个数组元素个数];
例如:
int[][] arr = new int[3][4];
说明：上面的代码相当于定义了一个3*4的二维数组，这个二维数组的长度为3，可以将它看成3个int[]类型的一维数组，每个一维数组中的元素又是一个长度为4的一维数组。
例如:
int[][] arr = new int[3][];
说明：第二种方式和第一种类似，只是数组中每个元素的长度不确定。
例如:
int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
说明：上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9} 。
(2)二维数组的使用
arr[0][1]; // 获取二维数组中第一个元素组的第二个元素 arr[0][1]=1; // 对二维数组中第一个元素组的第二个元素赋值或修改
说明：对二维数组中元素的操作也是通过角标的方式来完成的。
例如:
统计公司3个销售小组中每个小组的总销售额以及整个公司销售额
int[][] arr = new int[3][];//定义一个长度为3的二维数组,保存3个小组的销售额
arr[0] = new int[]{11,22}; //第一个小组每个人的销售额
arr[1] = new int[]{12,15,16};//第二个小组每个人的销售额
arr[2] = new int[]{13,14,10,11};//第三个小组每个人的销售额
int sum = 0 ;//定义一个变量,保存所有小组的总销售额
for(int i=0;i<arr.length;i++){
//求每组的总销售额
int groupSum = 0;//定义一个变量,保存每个组的总销售额
for(int j=0;j<arr[i].length;j++){
groupSum += arr[i][j]; // 累计相加求和i
}
System.out.println((i+1)+"组的销售总额是:"+groupSum);
//把当前小组的总销售额保存到sum中
sum += groupSum; // 累计相加求和
}
System.out.println("公司所有小组总销售额是:"+sum);
结果:
七 方法(函数)
1 什么是方法
方法就是一段可以重复调用的代码.
假设有一个游戏程序,程序在运行过程中,要不断的发射炮弹.发射炮弹的动作需要编写100行代码,在每次发射炮弹的地方都需要重复的写这100行代码,程序会变得很臃肿,可读性也非常差.
为了解决上述问题,通常会将发射炮弹的代码提取出来,然后放在一个方法中,并给这个方法取名,这样在每次发射炮弹的地方,只需要通过方法名字来调用方法,即可完成发射炮弹的动作.
在有些书中也会把方法称为函数,这两者本身并没有什么区别,是同样的概念,只是称呼方式不一样.
2 方法的语法格式
修饰符 返回值类型 方法名(参数列表){
//方法体,方法中具体要执行的代码
return 返回值;
}
修饰符:可以使用public/private等
返回值类型:用于限定方法返回值的数据类型
方法名:定义方法的名字,满足标识符的规则
参数列表:变量列表,用于接收调用方法时传入的数据
return:关键字,用于结束方法以及返回方法指定类型的数据
返回值:被return语句返回的值,该值会返回给调用者
注意:
参数列表可以为空,即()中不写任何内容
方法的返回值必须和方法的返回值类型保持一致
如果方法没有返回值,返回值类型要声明为void
3 方法案例
例如:定义一个方法,打印10次"hello world"
public void printMsg(){
for(int i=1;i<=10;i++){
System.out.println("hello world");
}
}
例如:定义一个方法,求1-n之和,返回求和结果
public int getSum(int n){
int sum = 0;
for(int i=1;i<=n;i++){
sum += i;
}
return sum;
}
例如:定义一个方法,求矩形面积:宽*高
public int getArea(int x,int y){
return x*y;
}
注意:
方法不会自己执行,需要去调用
4 方法的调用
方法名(实参列表);
注意:
实参列表要和调用方法的参数列表一一对应
如果调用的方法有返回值,一般会定义一个变量保存返回值
数据类型 变量名 = 方法名(实参列表);
例如:
//调用printMsg方法 printMsg(); //调用getSum方法 int sum = getSum(10); //调用getArea方法 int area = getArea(3,4);
5 方法的重载
假设要在程序中实现一个对数字求和的方法,由于参与求和数字的个数和数据类型都不确定,因此要针对不同的情况去设计不同的方法.
例如:
//对2个整合求和
public int add1(int a,int b){
return a+b;
}
//对3个整数求和
public int add2(int a,int b,int c){
return a+b+c;
}
//对2个小数求和
public double add3(double a,double b){
return a+b;
}
问题:
程序需要对每一种求和的情况都定义一个方法名,如果方法名称都不相同,调用时就很难分清哪种情况该调用哪个方法.
为了解决这个问题,java允许在一个程序中定义多个名称相同的方法,但是参数的类型或个数必须不同,这就是方法的重载.
例如:
//方法的重载
//对2个整合求和
public int add(int a,int b){
return a+b;
}
//对3个整数求和
public int add(int a,int b,int c){
return a+b+c;
}
//对2个小数求和
public double add(double a,double b){
return a+b;
}
调用:
add(1,2); add(1,2,3); add(3.14,1.1);
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
