JAVA基础
注释
注释就是对代码的解释和说明，其目的是让人们能够更加轻松地了解代码。注释是编写程序时，写程序的人给一个语句、程序段、函数等的解释或提示，能提高程序代码的可读性。注释只是为了提高可读性，不会被计算机编译。
- 单行注释 //
注意：//后面跟的不会被计算机编译- 多行注释 /* */
注意： / *中间写的不会被计算机编译 */
常量及其分类
常量：在程序运行期间，固定不变的量。
常量的分类：
- 字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例如：“abc”,“Hello”,“123”
- 整数常量:直接写上的数字，没有小数点。例如： 100 、200、0、-100
- 浮点数常量：直接写上的数字，有小数点。 例如： 2.5、-3.14、0.0
- 字符常量：凡是用单引号引起来的单个字符，叫字符常量。两个单引号中间必须有且只能有一个字符。例如：‘a’、‘3’、‘你’
- 布尔常量：只有两种取值。true，false。
- 空常量：null。代表没有任何数据。
数据类型
基本数据类型有八种
分为4类：整数型、浮点型、布尔型、字符型。
整数型：byte、short、int、long
浮点型：float.、double
布尔型：boolean
字符型：char
引用数据类型
字符串、数组、类、接口、Lambd
注意事项：
- 字符串不是基本类型，而是引用类型
- 浮点型可能是一个近似值，并非精确的值
- 数据范围与字节数不一定相关
- 浮点数当中默认类型是double。如果一定要使用float类型，需要加上一个后缀F
如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L。推荐使用大写字母后缀。
拓展：
对于byte\short\char三种类型来说，如果右侧赋值的数值没有超过范围，那么javac编译器会自动隐含的为我们补上一个(byte)(short)(char)。
如果右侧没有超过左侧的范围，编译器补上强转。
如果右侧超过左侧的范围，那么编译器报错。
例如：byte num1 = 30; 30是int类型，但是30没有超过byte的范围，编译器直接补上一个（byte）强转
byte num2 = 120; 120是int类型，但是120超过了左侧byte类型的范围，编译器直接报错。在给变量进行赋值的时候，如果右侧的表达式当中全是常量，没有任何变量，
那么编译器javac将会直接将若干个常量表达式计算得到结果。
short num1 = 5+8； //等号右边全都是常量，没有任何变量参与运算
编译之后，得到的.class字节码文件当中相当于【直接就是】
short num1 = 13；
右侧的常量结果数值，没有超过左侧范围，所以正确。
但是注意：一旦表达式当中有变量参与，那么就不能进行这种优化了。例：short num1 = 5+a+8；
变量
变量： 程序运行期间，内容可以发生改变的量。
格式:
1.数据类型 变量名称; / / 创建一个变量
2.变量名称 = 数据值; / / 赋值，将右边的数据值，赋值交给左边的变量3.一步到位的格式： 数据类型 变量名称 = 数据值; //在创建一个变量的同时，立刻放入指定的数据值
使用变量注意事项：
- 变量名不能重复
- 对于float和long类型来说，字母后缀F和L不要丢掉
- 如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型的范围
- 没有赋值的变量不能直接使用，一定要赋值之后使用
- 变量使用不能超过作用域的范围。
【作用域】：从定义变量的一行开始，一直到直接所属的大括号为止。（相当于局部变量，只能在所在的括号使用）
类型转换
自动类型转换：
- 特点：代码不需要进行特殊处理，自动完成
- 规则： 数据范围从小到大（右边的要比左边的小）
例如：long a=100;
左边是long类型，右边是默认的int类型，左右不一样
一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
int——>long 符合了数据范围从小到大的要求，这一行代码发生了自动类型转换
强制类型转换：
- 特点：代码需要进行特殊的格式处理，不能自动完成
- 格式：范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据；
例如： int num = (int)100L // 就是要转成什么类型 在前面加个括号，里面写上要转的类型
强制类型转换注意事项：
- 一般不推荐使用，因为有可能发生精度损失（小数转整数，所有小数位都会被舍弃掉），数据溢出（long转int,如果long超过int最大范围就会溢出）
- byte/short/char这三种类型都可以发生数学运算，例如‘+’。（一旦char发生数学运算，那么字符就会按照一定的规则翻译成为一个数字，ASCLL码表，Unicode码表）
48-‘0’ 0到9以此类推； 65-‘A’ A-Z以此类推； 97-‘a’ a-z以此类推 - byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后在计算。
- boolean类型不能发生数据类型转换
运算符
算术运算符
+， -， * ，/， % 。
% 两个数字相除取余数,例如：6%4，结果就等于6/4取余数，结果等于2
注意事项：
- 对与一个整数的表达式来说，除法用的是整数，整数除以整数，结果仍是整数不看余数。。只看商，
- 一旦运算当中有不同类型的数据，那麽结果将会是数据类型范围大的那种。
四则运算‘+’常见的三种用法：
- 对于数值来说，那就是加法。
- 对于字符char类型来说，在计算机之前，char会被提升为int，然后再计算。
char类型字符，和int类型数字，之间的关系对照表：ASCII、Unicde - 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串。
自增自减运算符
自增运算符：++
自减运算符：–
基本含义：
让一个变量涨一个数字1，或者让一个变量将一个数字1
使用格式：
写在变量名之前，或者写在变量名之后。例如：++num，也可以num–
使用方式：
1. 单独使用: 不和其他任何操作混合，自己独立成为一个步骤。 例如： num++
2.混合使用：和其它操作混合，例如与赋值混合，或者与打印操作混合，等。
使用区别:
1. 在单独使用的时候，前++和后++没有任何区别。也就是：++num；和num++；是完全一样的。
2. 在混合使用的时候，有重大区别
A. 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。【先加后用】
例：a=10; print（++a）; 那么变量先加1再打印 输出11 a为11
B. 如果是【后++】，那么首先使用变量本来的数据，【然后再让变量加一】。【先用后加】
例：a=10; print（a++）;那么先打印变量在加1，这时输出10，a为11
注意事项:
只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
赋值运算符
基本运算符:
就是一个等号“=”，代表将右侧的数据交给左侧的变量。 例：int a=30;
复合赋值运算符:
+= -= *= /= %=
例如： a+=3 相当于 a=a+3
例如：b-=4 相当于 b=b-4
例如：c**=5 相当于 c=c*5
例如：d/=6 相当于 d=d/6
例如：e%=7 相当于 e=e%7
注意事项:
- 只有变量才能使用赋值运算，常量不能进行赋值。
- 复合赋值运算符其中隐含了一个强制类型转换。
比较运算符
大于： >
小于： <
大于等于： >=
小于等于： <=
相等： == 【两个等号连写才是相等】 符号两边数据结果相等结果是true
不相等： != 如果符号两边的数据不相等，结果是true。
注意事项：
- 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false。
- 如果进行多次判断，不能连着写。
数学当中的写法，例如：1<x<3 程序当中不允许这种写法，不能连着写。
逻辑运算符
| 与（并且）&& | 全都是true，结果才是true；否则 就是false |
|---|---|
| 或（或者）|| | 至少一个是true，就是true；全都是false，结果才是false |
| （取反） ！ | 本来是true，变成false；本来是false，变成true； 只要唯一的一个boolean值即可，英文叹号写在它前面 |
&&，||，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定性能
例1：int a=10; System.out.println(3>4 && ++a<100)
可以看出第一个条件就不成立，结果一定是false，所以右边的条件不会执行，a不会自增加一
例2： int b=20; System.out.println(3<4 || ++b<100); 可以看出第一个条件就成立，结果一定是true，所以后面的条件将不再执行，b不会自增加一
注意事项
- 逻辑运算符只能用于boolean值。
- 与、或，需要左右各有一个booklean值，但是取反只要唯一的一个booklean值即可。
- 与、或两种运算符，如果多个条件可以连续写
两个条件：条件A && 条件B
多个条件：条件A && 条件B
对于1<x<3的情况，应该拆成两个部分，
int x=2；
1<x && x<3;
三元运算符
一元运算符： 只需一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--。
二元运算符： 需要两个数据才可以进行的操作的运算符。例如：加法+、赋值=
三元运算符： 需要三个数据才可以进行的操作的运算符。
三元运算符格式:
数据类型 变量名称 = 条件判断 ? 表达式a : 表达式b;
流程:
首先判断条件是否成立：
如果成立为true，那么将表达式a的值赋值给左侧的变量；
如果不成立为false，那么将表达式b的值赋值给左侧的变量；
二者选其一。
注意事项:
- 必须同时保证表达式a和表达式b都符合左侧数据类型的要求。
- 三元运算符的结果必须被使用。不能直接写 3>4 ? 5：6；要么按格式写 int num= 3>4 ? 5：6；将它结果赋值给num，要么直接打印 System.out.println(3>4 ? 5：6），这样它的结果也算使用了。
选择结构
选择结构分为：if语句，switch语句
if语句
if语句第一种格式：if
格式：
if (关系表达式) {
语句体；
}
执行流程：
首先判断关系表达式结果是ture还是false
如果是true就执行语句体
如果是false就不执行语句体
if语句第二种格式：if…else
格式：
if(关系表达式){
语句体1；
} else{
语句体2；
}
执行流程：
首先判断关系表达式看其结果是ture还是false
如果是true就执行语句体1
如果是false就执行语句体2
例：
int num=13;
if (num % 2 == 0 ) { //如果除以2能够余数为0，说明是偶数
System.out.println("偶数")
}else{
System.out.println("奇数")
}
if语句第三种格式：if…else if…else
格式：
if (判断条件1){
执行语句1;
} else if (判断条件2){
执行语句2；
}
...
} else if (判断条件n){
执行语句n;
} else {
执行语句n+1；
}
执行流程：
首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式...看其结果是ture还是fales
...
如果上面的ekse if 都没有符合条件的南那么就执行最后一个else。 else就是用来收尾的
三元运算符和if-else可以等效替换
选择语句–switch
语句格式：
switch（表达式）{ //表达式：他并不是booklan值，而是被检测量；如果是表达式，直接把表达式的值计算出来；如果是变量，直接把变量放进去就行
case 常量值1：
语句体1；
break；
case 常量值2：
语句体2；
break；
...
default:
语句体n+1；
break；
}
执行流程：
首先计算出表达式的值
其次，和case后面的常量值依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
switch语句使用的注意事项：
1. 多个case后面的数值不可以重复。
2. switch后面的小括号只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举
3. switch语句格式可以很灵活：前后顺序可以颠倒（case和default的顺序可以随意颠倒），
break语句还可以省略，”匹配哪一个case就从哪个位置向下执行，直到遇到了break或者整体结束为止“ （如果匹配到的这个case没有break，那么就继续执行下一个case，知道碰到break或者整体结束为止）
循环结构
循环结构的基本组成部分，一般可以分成四个部分：
- 初始化语句: 在循环开始最初执行，而且只做唯一一次。
- 条件判断： 如果成立，则循环继续；如果不成立，则循环退出。
- 循环体： 重复要做的事情内容，若干行语句。
- 进步语句： 每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。也就是结束循环的条件。
for循环
for循环语句格式：
for (初始化表达式1；布尔表达式2；进步语句4){
循环体3
}
执行流程：
-执行顺序：1234>234>234…2不满足为止。
-1负责完成循环变量初始化
-2负责判断是否满足循环条件，不满足则跳出循环体
-3 具体执行的语句
-4循环后，循环条件所涉及变量的变化情况
例子：
public class aabb{
public static void main (String[] args){
for (int i = 1; i<=100; i++){
System.out.println("你好你好");
}
System.out.println("你好你好");
}
}
While循环
While循环语句格式：
初始化表达式a
While(布尔表达式b){
循环体c;
步进表达式d;
}
执行流程：abcd>bcd>bcd…b不满足为止。
a负责完成循环变量初始化。
b负责判断是否满足循环条件，不满足则跳出循环。
c具体执行的语句。
d循环后，循环变量的变化情况。
例子：
public class aabb{
public static void main (String[] args){
int i =1; //a初始化条件语句
while (i<=100;){ //b条件判断
System.out.println("你好你好"); //c循环体
i++; //d步进语句
}
}
}
do…while循环
格式：
初始化表达式1;
do{
循环体3；
步进语句4；
}while(条件判断2);
执行流程：
执行顺序：134>234>234…2不满足为止
1负责完成循环变量初始化。
2负责判断是否满足循环条件，不满足则跳出循环。
3具体执行的语句。
4循环后，循环变量的变化情况。
只要有do，无脑执行一次它的大括号里面的代码一次，然后在看后面的判断语句，只要满足条件就一直继续执行do后面大括号的代码，不满足的话循环退出。
例子：
public class aaaa{
public static void main (String[] args){
int i =1; //a初始化条件语句
do{ /
System.out.println("你好你好"); //c循环体
i++; //步进语句
}whiln(i<=10); //条件判断
}
}
循环小练习
题目：求出1-100之间的偶数和。
思路：
1.既然范围已经确定，那么就从1-100之间这么多数字一个一个进行检查。
2.共100个数字，必须偶数才能用，判断（if语句）偶数：num%2==0
3.需要一个变量，用来进行累加操作，就好比一个存钱安罐。
例子：用的for循环，三种循环都可以做
public class aaaa{
public static void main (String[] args){
int sum = 0; //用来累加的存钱罐
for (int i= 1;i <=100;i++){
if (i%2==0){ //如果是偶数
sum+=1;
}
}
System.out.println("你好你好");
}
}
三种循环的区别
1.如果条件判断从来没有满足过过，那么for循环和while循环将会执行零次，但是do…while循环至少会执行一次（注意：尽管条件不满足，它也会执行一次，也就意味着里面的布加语句也会执行，外面的初始化语句就会改变）
2.For循环的变量在小括号当中定义，只有循环内部才可以使用。While和do…whiled的初始化语句本来就在外面，所以出来循环也可以继续使用。
3.关于循环的选择的小建议：凡是次数确定的场景多用for循环；否则多用while。
Break语句
常见的两种用法：
1.可以用在switch语句，一旦执行，整个switch语句立刻结束。
2.还可以用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。
例子：
Public class aaaa{
Public static void main(String[] arge{
for (int i = 1;i<=10;i++){
//如果希望从第四次开始，后续全都不要了，就要打断循环
If(i==4){
break;
}
System.out.println(“heal”);
}
}
}
Continue语句
一旦执行，立刻跳过当前次循环，马上开始下一次循环
例子：
Public class aaaa{
Public static void main(String[] arge{
for (int i = 1;i<=10;i++){
If(i==4){ //如果当前是四层
continue; // 那么跳过当前次循环，马上开始下一次（第五层）
}
System.out.println(“I + 层到了”);
}
}
}
死循环
永远停不下来的循环，叫死循环
死循环标准格式：
While(true){
循环体
}
循环嵌套
指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环。总共循环次数=外循环次数*内循环次数
例子：
public class aa{
public static void main(String[] args){
for (int hour = 0;hour<24;hour++){ // 外层控制小时
for(int miute = 0; miute<60; miute++){ // 内层控制小时之内的分钟
System,out,println(hour+”点”+miute+”分”);
}
}
}
}