Java-v14

Java-V14路线

---

02-Java基础

​

​ ↓↓↓ 以下Java基础语法

---

1 关键字

关键字的特点：

    - 具有特殊含义
    - 小写
    - 蓝色

2.2 字面量 （常量）

2.3 变量

定义格式：
	数据类型 变量名 = 数据值;
	
	数据类型： 四类八种

2.4 数据类型

四类八种:						  所占字节数
	- 整数 byte,short,int,long	1,2,4,8
	- 小数 float,double			4,8
	- 字符 char					2
	- 布尔 boolean				1

数据类型默认值：
	- 整数默认 int 
	- 小数默认 double

• 每一个字符，底层都有一份数值的表现形式
  

2.5 标识符

1. 命名规则

• 由数字，字母 ，下划线（_）和美元符号（$）组成

• 不能以数字开头

• 不能是关键字

• 区分大小写

2. 命名规范

• 小驼峰（变量）

• • 一个单词
  • 多个单词时，第一个单词的首字母小写，其余单词的首字母大写

• 大驼峰（类）

• • 每个单词的首字母大写

2.6 工具包的使用

使用三步骤：
	- 导包 import
	- 创建 new
	- 使用 .

1. 键盘录入

2. 产生随机数

​ ↑↑↑ 以上Java基础语法完结

---

​ ↓↓↓ 以下 运算符

---

2.7 算术运算符

	+  - * 	:	简单的简单的加减乘除
	/ 		:	整数相除结果只能是整数，要想有小数，至少需要一个小数参与运算
	%		:	取余数 

2.8 自增自减运算符

单独使用:
	++ ： 让变量自身的值自加一
	-- ： 让变量自身的值自减一
参与操作使用:
	++ / -- 的位置
		若前 先自增/自减 一,再 使用
		若后 先使用，再 自增/自减 一

2.9 类型转换

1. 隐式转换（自动转换）：

1. 将取值范围小的数据或变量，给取值范围大的变量赋值，允许直接赋值
    - 简单记： 小转大，直接赋值
    
2. 小的和大的在一起运算时，小的会现将自己提升为大的，然后再算

3. byte short char 三个在运算的时候，会直接提升为int类型
    - char ---> int 是通过ASCII表

2. 强制转换：

1. 将取值范围大的数据或变量，给取值范围小的变量赋值，不允许直接赋值，需要强转
    - 简单记： 大的给小的，不允许直接给，需要强转

注意： 今后尽量【减少强转】的使用，因为【有可能】造成精度损失

2.10 赋值运算符

    赋值运算符：
    
        1. 基本赋值运算符
            = ： 将等号右边的数据，赋值给左侧的变量
                int num = 20;
        2. 扩展赋值运算符
            += ：将符号两边的数据，做加法运算，将结果赋值给左边的变量
            -= ：将符号两边的数据，做减法运算，将结果赋值给左边的变量
            *= :
            /= :
            %= :
            	a/=b; 等价 a = a/b;
            	
    注意事项：以上扩展运算符，自带强转操作

2.11 关系运算符

关系运算符(比较运算符):
    >
    >=
    <
    <=
    ==
    !=
总结： 比较运算符，无论简单复杂结果只能是boolean类型的 true false

注意： 
	= 和 == 是有区别的
        = 赋值运算符
        == 比较运算符

2.12 逻辑运算符

1. 逻辑运算符

逻辑运算符：

    1. 代码层面：用于连接 boolean 类型的表达式，或者是值
    2. 理解层面：可以整合多个条件，为一段整体的逻辑

 分类：
     &（与）：并且，遇false则false
            伪代码：不能运行，仅供理解
            场景： 适用于范围性的判断查找
            需求：键盘录入一个学生成绩，【判断成绩是否在90~100之间
                int score = 95;
                如果（score>=0 & score<=100）{
                }

     |（或）：或者，遇true则true
            伪代码：不能运行，仅供理解
            场景：多个条件，任选其一
            需求：键盘录入一个学生的学号，学号只要 3 11 21
            int id = 3;
            如果(id == 3 | id == 1 | id==21){
            }

     !（非）：取反
            场景：可以对一段整体的逻辑，做取反操作
            需求：键盘录入一个学生的学号，学号除了 3 11 21都要
            int id = 3;
            如果(!（id == 3 | id == 1 | id==21）){
            }

     ^(异或)：相同为false，不同为true

2. 短路逻辑运算符

短路逻辑运算符：

$（|） 逻辑与运算符：
     - 没有短路效果，左右都必须执行
     
&&（||） 短路逻辑 与（或） 运算符：
     - 具有短路效果，
         当 && 符号左边为 false 时，右边不执行
         当 || 符号左边为 true  时，右边不执行

​ 今后逻辑运算符，最常用的 && || !

2.13 三元运算符

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

    介绍： 根据一个判断条件，打成二者选其一的效果
    --------------------------------------

    格式： 判断条件 ？ 值1 ：值2;
    
    执行流程：
        1. 执行判断条件，看起返回结果是true、false
        2. true ：值1就是最终的结果
        3. false： 值2就是最终的结果

2.14 运算符优先级

​ ↑↑↑以上运算符结束

---

​ ↓↓↓以上流程控制语句

---

2.15 顺序结构

默认的执行顺序，从main开始从上往下依次执行

2.16 分支结构

1. if

格式1:

    if语句的第一种格式：

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

    执行流程：
        执行（）中的判断条件，看其返回的结果是 true ，false
            - true 执行{} 中的语句体
            - false 不执行{}中的语句体

格式2:

	if语句的第二种格式：

        if（判断条件）{
        	语句体1；
        }else{
        	语句体2；
        }
        
     执行流程:
            执行（）判断条件，看其返回结果是true，false
                - true ：执行语句体1
                - false ： 执行语句体2

格式3: 
	
	if语句的第三种格式：
	
        if（判断条件1）{
        	语句体1；
        }else if（判断条件2）{
        	语句体2；
        }else if(判断条件3){
        	语句体3；
        }else{
        	语句体n+1;
        }

     执行流程：
            1. 执行判断条件1，看其返回的结果是true、 false
                - true 执行语句体1，结束整个if语句
                - false 进入第二步
            2. 执行判断条件2，看其返回结果是true，false
                - true 执行语句体二，结束整个if
                - false 进入第三步
                ...
           3. 如果给出的所哟的判断条件，都是false、将会执行最后的false、语句体n+1

注意事项：

• if语句（）与{}之间不要写任何符号
• if语句 {} 中如果只有一条语句，{}可以省略不写，但是不建议！
• if语句（）中，无论简单还是复杂，只要给一个true，false，就符合语法规则

2. switch

switch语句格式：

    switch(将要匹配的值){
        case 值1：
            语句体1；
            break；
        case 值2：
            语句体2；
            break；
        case 3值：
            语句体3；
            break；
        ...
       default：
            语句体n+1；
            break；
    }

执行流程：

    1. 拿着switch()中给出的值，跟case后面给出的选项，
        匹配成功，就会执行对应的语句体，随后由break、结束整个switch
    2. 如果给出的所有case，全部匹配失败，将会执行default中的代码

注意事项：

• case 后面的值不允许重复

• case 后面的值只能是常量

• switch语句中（）中可以接收的类型有哪些
  - 基本数据类型 byte short char int
  - 引用数据类型 jdk5 版本可以是 枚举， jdk7版本开始可以是String字符串

• 如果省略break，与开启case穿透现象

2.17 循环结构

1. for

语句格式：

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

    - 初始化语句：定义变量，用这个变量来控制循环
    - 判断条件： 决定循环是否要继续的条件
    - 循环语句： 重复执行的代码任务
    - 条件控制语句： 改变变量的值
    
执行流程：

    1. 执行初始化语句，在整个循环过程中只执行一次
    2. 执行判断条件，看其返回的结果是true，false
        - true 进入第三步
        - false 循环结束
    3. 执行循环体语句
    4. 执行条件控制语句
    5. 回到2继续...

注意事项：

1. for循环（）和{}之间不要写;
2. for循环 {} 中定义的变量，在每一轮循环结束后，都会从内存中释放
3. for循环 （） 中定义的变量，在整个循环结束后，会从内存中释放（消失）
4. 因为马虎造成的无限循环（死循环）

​ - 排查循环条件

嵌套for循环，外循环一次，内循环一圈

2. while

while循环格式：

    初始化语句；
    while（判断条件）{
        循环体语句；
        条件控制语句；
    }

执行流程：

        1. 执行初始化语句
        2. 执行判断条件，看其返回 ture false
            - false 循环结束
            - true 进入第三步
        3. 执行循环体语句
        4. 执行条件控制语句
        5. 回到2继续

3. do…while

do···while循环格式：

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

执行流程：

    1. 执行初始化语句
    2. 执行循环体语句
    3. 执行条件控制语句
    4. 执行判断条件，看其返回 true，false
        - false 结束循环
        - true 回到2继续

特点：

• do…while循环，无论判断条件是否满足，都至少执行一次循环体

2.18 跳转控制语句

1. break

• 用在 循环，switch 中，结束（终止）循环

2. continue

• 只能用在循环中，结束当前循环，执行下次循环

注意：

• break，continue如果遇到了嵌套循环，默认操作的是内部循环

• 使用循环标号技术，控制break，continue操作指定一层的循环[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

break 与 continue 后面不允许书写任何语句

​ ↑↑↑以上流程控制语句结束

---

​ ↓↓↓以下数组

---

2.19 数组的介绍

数组	介绍
一维数组	是一种用来存储 同种数据类型 的容器
二维数组	是一种用来存储 一维数组 的容器

2.20 初始化

数组	静态初始化	动态初始化
一维数组	完整格式：数据类型 [] 数组名 = new 数据类型[]{元素1,元素2,元素3} 简化格式：数据类型 [] 数组名 = {元素1,元素2,元素3}	数据类型[] 数组名= new 数据类型[长度]；
二维数组	完整格式： 数据类型 [] [] [][] 数组名 = new 数据类型[] []{{一位数组1},{一维数组2}}; 简化格式： 数据类型 [] [] [][] 数组名 = {{一位数组1},{一维数组2}};	数据类型 [] [] 数组名=new 数据类型[m索引] [n索引]； m : 这个二维数组可以存放 m 个一维数组 n ： 每一个以为数组中，可以存放 n 个元素

两种初始化的区别：

• 动态： 手动指定数组长度
• 静态： 手动指定元素，根据元素计算出数组长度

2.21 数组元素的访问

数组	数组的访问
一维数组	数组名[索引]； 索引：数组容器中，空间所对应的编号
二维数组	数组名 [m索引] [n索引] - m 索引：要访问哪一个一维数组 - n 索引：要访问的一维数组中的哪一个元素

2.22 数组遍历操作

数组	数组遍历
一维数组	将数组中的每一个元素，取出来进行操作 遍历时每个数组都存在一个属性 length 使用方式 ：数组名.length --> 动态的获取到数组的长度 长度 ： 数组中元素的个个数
二维数组	1. 遍历二维数组，获取到每一个一维数组 2. 继续遍历一维数组，获取具体的元素

2.23 数组内存图

1. 一维数组内存图

2. 二维数组内存图

2.24 数组常见问题

1. 数组越界（ArrayIndexOutOfBoundsException）

• 访问了不存在的索引元素

2. 空指针异常(NullPointerException)

• 栈到堆之间的地址（联系）断了

3. 直接打印数组名

 [I@4554617c ：数组的十六进制内存地址
                - @ 分隔符
                - [ 当前的空间，是数组类型
                - I 数组的类型，是int类型
                - 4554617c 十六进制内存地址

​ ↑↑↑以上数组结束

---

​ ↓↓↓以下方法

---

2.25 方法介绍

• 介绍： 一段具有独立功能的代码块，不调用不执行
• 特点：
  • 可将代码分类管理
  • 提高代码复用性

2.26 方法的定义和调用格式

方法的定义格式：

    public static 返回值类型 方法名(形参列表){
        方法体;
        return 数据;
    }
    
方法的调用格式：

    1. 单独调用（不推荐）
    	方法名(参数);
    2. 赋值调用（推荐）
    	数据类型 变量名 = 方法名(参数);
    3. 输出调用（偶尔）
   	    System.out.println(方法名(参数));

注意事项：

    - 方法名，小驼峰命名
    - return 用于结束方法，用于给调用者返回结果
    - 方法与方法之间需要保证平级关系，不允许嵌套定义
    - 方法不调用不执行
    - 方法的编写顺序，和执行顺序无关，只和调用关系有关
    
    - 形参方法定义时，实参方法调用时

2.27 方法常见问题

• 方法不调用不执行
• 方法之间平级关系，不允许嵌套
• 方法的编写顺序与执行顺序无关
• 方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写，如果要编写return，后面不能跟任何数据。
• return后面不允许写代码

2.28 方法重载

• 同一个类中，方法名相同，参数（个数，类型，顺序）不同

2.29 方法的调用流程 - 内存图解

2.30 方法的通用定义格式