Java 语言基础 02

语言基础·二级

顺序结构语句

* A:什么是流程控制语句
    * 流程控制语句：可以控制程序的执行流程。

* B:流程控制语句的分类
    * 顺序结构
    * 选择结构
    * 循环结构

* C:执行流程：
    * 从上往下，依次执行。

* D:案例演示
    * 输出几句话看效果即可

选择结构if语句格式

* A:选择结构的分类
    * if语句
    * switch语句

* B:if语句有几种格式
    * 格式1
    * 格式2
    * 格式3

* C:if语句的格式1
        if(比较表达式) {
            语句体;
        }

* D:执行流程：
    * 先计算比较表达式的值，看其返回值是true还是false。
    * 如果是true，就执行语句体；
    * 如果是false，就不执行语句体；

* A:if语句的格式2
        if(比较表达式) {
            语句体1;
        }else {
            语句体2;
        }

* B:执行流程：
    * 首先计算比较表达式的值，看其返回值是true还是false。
    * 如果是true，就执行语句体1；
    * 如果是false，就执行语句体2；

* C:案例演示
    * a:获取两个数据中较大的值
    * b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数

    * 注意事项：else后面是没有比较表达式的，只有if后面有。

* A:if语句的格式3：
        if(比较表达式1) {
            语句体1;
        }else if(比较表达式2) {
            语句体2;
        }else if(比较表达式3) {
            语句体3;
        }
        ...
        else {
            语句体n+1;
        }

* B:执行流程：
    * 首先计算比较表达式1看其返回值是true还是false，
    * 如果是true，就执行语句体1，if语句结束。
    * 如果是false，接着计算比较表达式2看其返回值是true还是false，
    
    * 如果是true，就执行语句体2，if语句结束。
    * 如果是false，接着计算比较表达式3看其返回值是true还是false，    
    * 如果都是false，就执行语句体n+1。

* C:注意事项:最后一个else可以省略,但是建议不要省略,可以对范围外的错误值提示

if语句的格式2和三元的相互转换

* A:案例演示
    * if语句和三元运算符完成同一个效果

* B:案例演示
    * if语句和三元运算符的区别
    * 三元运算符实现的，都可以采用if语句实现。反之不成立。    
    * 什么时候if语句实现不能用三元改进呢?
        * 当if语句控制的操作是一个输出语句的时候就不能。
        * 为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。

选择结构if语句格式3练习

* A:练习1
        需求：键盘录入一个成绩，判断并输出成绩的等级。
        90-100 优
        80-89  良
        70-79  中
        60-69  及
        0-59   差

* B:练习2
    * 需求：
        * 键盘录入x的值，计算出y的并输出。
        * x>=3    y = 2 * x + 1;
        * -1<x<3    y = 2 * x;
        * x<=-1    y = 2 * x - 1;

选择结构switch语句的格式及其解释

* A:switch语句的格式
        switch(表达式) {
              case 值1：
                语句体1;
                break;
                case 值2：
                语句体2;
                break;
                …
                default：    
                语句体n+1;
                break;
        }

* B:switch语句的格式解释

* C:面试题
    * byte可以作为switch的表达式吗?
    * long可以作为switch的表达式吗?
    * String可以作为switch的表达式吗?

* C:执行流程
    * 先计算表达式的值
    * 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句

选择结构switch语句的注意事项

* A:案例演示
    * a:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的

* b:default可以省略吗?
        * 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
        * 特殊情况：
            * case就可以把值固定。
            * A,B,C,D

* c:break可以省略吗?
        * 最后一个可以省略,其他最好不要省略
        * 会出现一个现象：case穿透。
        * 最终我们建议不要省略

* d:default一定要在最后吗?
        * 不是，可以在任意位置。但是建议在最后。

* e:switch语句的结束条件
        * a:遇到break就结束了
        * b:执行到switch的右大括号就结束了

选择结构switch语句练习

* A:看程序写结果：
        int x = 2;
        int y = 3;
        switch(x){
            default:
                y++;
                break;
            case 3:
                y++;
            case 4:
                y++;
        }
        System.out.println("y="+y);
    
* B:看程序写结果：
        int x = 2;
        int y = 3;
        switch(x){
            default:
                y++;
            case 3:
                y++;
            case 4:
                y++;
        }
        System.out.println("y="+y);

选择结构if语句和switch语句的区别

* A:总结switch语句和if语句的各自使用场景
*     switch建议判断固定值的时候用
*     if建议判断区间或范围的时候用

* B:案例演示
    * 分别用switch语句和if语句实现下列需求：
        * 键盘录入月份，输出对应的季节

循环结构概述和for语句的格式及其使用

* A:循环结构的分类
    * for,while,do...while

* B:循环结构for语句的格式：
* 
        for(初始化表达式;条件表达式;循环后的操作表达式) {
            循环体;
        }

* C执行流程：
    * a:执行初始化语句
    * b:执行判断条件语句,看其返回值是true还是false
        * 如果是true，就继续执行
        * 如果是false，就结束循环
    * c:执行循环体语句;
    * d:执行循环后的操作表达式
    * e:回到B继续。

* D:案例演示
    * 在控制台输出10次"helloworld"

循环结构while语句的格式和基本使用

* A:循环结构while语句的格式：         
        while循环的基本格式：
        while(判断条件语句) {
            循环体语句;
        }
        
        完整格式：
        
        初始化语句;
        while(判断条件语句) {
             循环体语句;
             控制条件语句;
        }

* B:执行流程：
    * a:执行初始化语句
    * b:执行判断条件语句,看其返回值是true还是false
        * 如果是true，就继续执行
        * 如果是false，就结束循环
    * c:执行循环体语句;
    * d:执行控制条件语句
    * e:回到B继续。

* C:案例演示
    * 需求：请在控制台输出数据1-10

循环结构do...while语句的格式和基本使用

* A:循环结构do...while语句的格式： 
        do {
            循环体语句;
        }while(判断条件语句);
        
        完整格式；
        初始化语句;
        do {
            循环体语句;
            控制条件语句;
        }while(判断条件语句);

* B:执行流程：
    * a:执行初始化语句
    * b:执行循环体语句;
    * c:执行控制条件语句
    * d:执行判断条件语句,看其返回值是true还是false
        * 如果是true，就继续执行
        * 如果是false，就结束循环
    * e:回到b继续。

* C:案例演示
    * 需求：请在控制台输出数据1-10

循环结构三种循环语句的区别

* A:案例演示
    * 三种循环语句的区别:
    * do...while循环至少执行一次循环体。
    * 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。

* B:案例演示
    * for循环和while循环的区别：
        * A:如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用谁就用for循环。因为变量及早的从内存中消失，可以提高内存的使用效率。

控制跳转语句break语句

* A:break的使用场景
    * 只能在switch和循环中

控制跳转语句continue语句

* A:continue的使用场景
    * 只能在循环中

控制跳转语句标号

* 标号:标记某个循环对其控制
* 标号组成规则:其实就是合法的标识符

---

方法概述和格式说明

* A:为什么要有方法
    * 提高代码的复用性

* B:什么是方法
    * 完成特定功能的代码块。

* C:方法的格式
        修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
            方法体语句;
            return 返回值; 
        }

* D:方法的格式说明
    * 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
    * 返回值类型：就是功能结果的数据类型。
    * 方法名：符合命名规则即可。方便我们的调用。
    * 参数：
        * 实际参数：就是实际参与运算的。
        * 形式参数；就是方法定义上的，用于接收实际参数的。
    * 参数类型：就是参数的数据类型
    * 参数名：就是变量名
    * 方法体语句：就是完成功能的代码。
    * return：结束方法的。
    * 返回值：就是功能的结果，由return带给调用者。

方法的注意事项

* A:方法调用(有具体返回值)
    * a:单独调用,一般来说没有意义，所以不推荐。
    * b:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。
    * c:赋值调用,推荐方案。

* B:案例演示
    * a:方法不调用不执行
    * b:方法与方法是平级关系，不能嵌套定义
    * c:方法定义的时候参数之间用逗号隔开
    * d:方法调用的时候不用在传递数据类型
    * e:如果方法有明确的返回值，一定要有return带回一个值

方法重载概述和基本使用

* A:方法重载概述
    * 求和案例
        * 2个整数
        * 3个整数
        * 4个整数

* B:方法重载：
    * 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。    
    * 参数列表不同：
        * A:参数个数不同
        * B:参数类型不同
        * C:参数的顺序不同(算重载,但是在开发中不用)

数组概述和定义格式说明

* A:为什么要有数组(容器)
    * 为了存储同种数据类型的多个值

* B:数组概念
    * 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
    * 数组既可以存储基本数据类型，也可以存储引用数据类型。

* C:数组定义格式
    数据类型[] 数组名 = new 数据类型[数组的长度];

数组的初始化动态初始化

* A:什么是数组的初始化
    * 就是为数组开辟连续的内存空间，并为每个数组元素赋予值

* B:如何对数组进行初始化
    * a:动态初始化 只指定长度，由系统给出初始化值
        * int[] arr = new int[5];     
    * b:静态初始化 给出初始化值，由系统决定长度

* C:动态初始化的格式：
    * 数据类型[] 数组名 = new 数据类型[数组长度];

* D:案例演示     * 输出数组名称和数组元素

Java中的内存分配以及栈和堆的区别

* A:栈(掌握)
    * 存储局部变量

* B:堆(掌握)
    * 存储new出来的数组或对象

* C:方法区
    * 面向对象部分讲解

* D:本地方法区
    * 和系统相关

* E:寄存器
    * 给CPU使用

详见类一篇随笔，java虚拟机

数组操作的两个常见小问题越界和空指针

* A:案例演示
    * a:ArrayIndexOutOfBoundsException:数组索引越界异常
        * 原因：你访问了不存在的索引。

* b:NullPointerException:空指针异常
        * 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
        * int[] arr = {1,2,3};
        * arr = null;
        * System.out.println(arr[0]);

数组的操作1遍历

* A:案例演示
    * 数组遍历: 就是依次输出数组中的每一个元素。
    * 数组的属性: arr.length数组的长度
    * 数组的最大索引: arr.length - 1;
     
            public static void print(int[] arr) {
                for (int i = 0;i < arr.length ;i++ ) {
                    System.out.print(arr[i] + " ");
                }
            }

数组的操作2获取最值

* A:案例演示
    * 数组获取最值(获取数组中的最大值最小值)
        
            public static int getMax(int[] arr) {
                int max = arr[0];
                for (int i = 1;i < arr.length ;i++ ) {            //从数组的第二个元素开始遍历
                    if (max < arr[i]) {                            //如果max记录的值小于的数组中的元素
                        max = arr[i];                            //max记录住较大的
                    }
                }
        
                return max;
            }

数组的操作3反转

* A:案例演示
    * 数组元素反转(就是把元素对调)
            
            public static void reverseArray(int[] arr) {
                for (int i = 0;i < arr.length / 2 ; i++) {
                    //arr[0]和arr[arr.length-1-0]交换
                    //arr[1]和arr[arr.length-1-1]交换
                    //arr[2]和arr[arr.lentth-1-2]
                    //...
        
                    int temp = arr[i];
                    arr[i] = arr[arr.length-1-i];
                    arr[arr.length-1-i] = temp;
                }
            }

数组的操作4查表法

* A:案例演示
    * 数组查表法(根据键盘录入索引,查找对应星期)
    
            public static char getWeek(int week) {
                char[] arr = {' ','一','二','三','四','五','六','日'};        //定义了一张星期表
                return arr[week];                                            //通过索引获取表中的元素
            }

数组的操作5基本查找

* A:案例演示
    * 数组元素查找(查找指定元素第一次在数组中出现的索引)
    
            public static int getIndex(int[] arr,int value) {
                for (int i = 0;i < arr.length ;i++ ) {                //数组的遍历
                    if (arr[i] == value) {                            //如果数组中的元素与查找的元素匹配
                        return i;
                    }
                }
                return -1;
            }

二维数组概述和格式1的讲解

* A:二维数组概述

* B:二维数组格式1
    * int[][] arr = new int[3][2];

* C:二维数组格式1的解释

* D:注意事项
    * a:以下格式也可以表示二维数组
        * 1:数据类型 数组名[][] = new 数据类型[m][n];
        * 2:数据类型[] 数组名[] = new 数据类型[m][n];

* b:注意下面定义的区别
            int x;
            int y;
            int x,y;
            int[ ] x;

int[ ] y[ ];
            int[ ] x,y[ ];    x是一维数组,y是二维数组

* E:案例演示
    * 定义二维数组，输出二维数组名称，一维数组名称，一个元素

二维数组练习1遍历

* A:案例演示
    * 需求：二维数组遍历

    * 外循环控制的是二维数组的长度，其实就是一维数组的个数。
    * 内循环控制的是一维数组的长度。

            int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
    
            for (int i = 0;i < arr.length ;i++ ) {            //获取到每个二维数组中的一维数组
                for (int j = 0;j < arr[i].length ;j++ ) {    //获取每个一维数组中的元素
                    System.out.print(arr[i][j] + " ");
                }
   
                System.out.println();
            }

二维数组练习2求和

* A:案例演示
        需求：公司年销售额求和
        某公司按照季度和月份统计的数据如下：单位(万元)
        第一季度：22,66,44
        第二季度：77,33,88
        第三季度：25,45,65
        第四季度：11,66,99
        
        int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

        int sum = 0;                                    //定义变量,记录每次相加的结果
        for (int i = 0;i < arr.length ;i++ ) {            //获取每一个一维数组
            for (int j = 0;j < arr[i].length ;j++ ) {    //获取每一个一维数组中的元素
                sum = sum + arr[i][j];                    //累加
            }
        }

        System.out.println(sum);