【Java零基础入门篇】第 ② 期 - Java语言基础（四）

博主：命运之光
专栏：JAVA入门

学习目标
掌握变量、常量、表达式的概念，数据类型及变量的定义方法；
掌握常用运算符的使用；
掌握程序的顺序结构、选择结构和循环结构的使用；
掌握数组的定义及使用方法；
掌握基本的输入输出方法；

流程控制语句

• 顺序结构
• 选择结构
• 循环结构

这三种不同的结构有一个共同点，就是它们都只有一个入口，也只有一个出口。程序中使用了上面这些结构到底有什么好处呢？这些单一入、出口可以让程序易读、好维护，也可以减少调试的时间。

顺序结构

程序至上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾。

选择（分支）结构

根据条件的成立与否，再决定要执行哪些语句的一种结构。
这种结构可以依据判断条件的结构，来决定要执行的语句。当判断条件的值为真时，就运行“语句1”；当判断条件的值为假，则执行“语句2”。不论执行哪一个语句，最后都会再回到“语句3”继续执行。

🍓 if 语句 ： 如果

• if语法：

if (布尔表达式) {
    条件满足时执行的程序 ;
}

• if…else语法：

if (布尔表达式) {
    条件满足时执行的程序 ;
} else {
    条件不满足时执行的程序 ;
}

• if…else if…else语法：

if (布尔表达式1) {
    条件满足时执行的程序 ;
} else if (布尔表达式2) {
    条件满足时执行的程序 ;
} ... else {
    所有条件都不满足时执行的程序 ;
}

🍓🍓例1：使用if语句判断。

public class text1 {
    public static void main(String args[]) {
        double score = 90.0;        // 定义变量
        if (score > 60.0) {        // 设置判断条件
            System.out.println("及格了！");
        }
    }
}

🍓🍓例2：使用if…else语句判断。

public class text1 {
    public static void main(String args[]) {
        double score = 30.0;     // 定义变量
        if (score > 60.0) {     // 条件判断满足
            System.out.println("及格了！");
        } else {             // 条件判断不满足
            System.out.println("小白的成绩！");
        }
    }
}

🍓🍓例3：使用if…else if…else语句判断。

public class text1 {
    public static void main(String args[]) {
        double score = 91.0;         // 定义变量
        if (score < 60.0) {        // 条件判断
            System.out.println("小白的成绩！") ;
        } else if (score >= 60 && score <= 90) {// 条件判断
            System.out.println("中等成绩") ;
        } else if (score > 90 && score <= 100) {// 条件判断
            System.out.println("优秀成绩") ;
        } else {            // 条件判断都不满足
            System.out.println("你家的考试成绩这么怪异！") ;
        }
    }
}

🍓switch语句
对于多条件判断使用if…else if…else是可以判断布尔条件的，如果是多数值判断，可以通过switch完成，语法格式如右所示：

switch(整数 | 字符 | 枚举 | String) {
    case 内容 : {
        内容满足时执行 ;
        [break ;]
    }
    case 内容 : {
        内容满足时执行 ;
        [break ;]
    }
    case 内容 : {
        内容满足时执行 ;
        [break ;]
    } ... 
    [default : {
        内容都不满足时执行 ;
        [break ;]
    }]
}

🍓🍓例1：使用switch语句判断。

public class text1 {
    public static void main(String args[]) {
        int ch = 1;
        switch (ch) {        // 判断的是数字
            case 2: {    // 判断内容是否是2
                System.out.println("内容是2");
                break;
            }
            case 1: {    // 判断内容是否是1
                System.out.println("内容是1");
                break;
            }
            case 3: {    // 判断内容是否是3
                System.out.println("内容是3");
                break;
            }
            default: {    // 判断都不满足
                System.out.println("没有匹配内容");
                break;
            }
        }
    }
}

• case子句中的值必须是常量，不能是变量名或不确定的表达式值；
• 同一个switch语句，所有case子句中的常量值互不相同；
• break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾；
• default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default。

🍓🍓例2：使用字符串判断。

public class text1 {
    public static void main(String args[]) {
        String str = "HELLO";
        switch (str) {     // 判断的是字符串
            case "HELLO": {
                System.out.println("内容是HELLO");
                break;
            }
            case "hello": {
                System.out.println("内容是hello");
                break;
            }
            case "mldn": {
                System.out.println("内容是mldn");
                break;
            }
            default: {
                System.out.println("没有匹配内容");
                break;
            }
        }
    }
}

从JDK 1.7开始switch支持 字符串的直接判断，即：可以利用switch判断是否是某一个字符串内容。但是在字符串的判断中是严格 区分字母大小写的。

循环结构

循环，即事物周而复始的变化。 循环结构，使一部分代码按照次数或一定的条件反复执行的一种代码结构。对于循环结构有三种循环：while循环、for循环和do-while循环。
循环语句的四个组成部分：

• 循环初值(init_statement)
• 循环条件部分(test_exp)
• 循环体部分(body_statement)
• （修改循环条件）迭代部分(alter_statement)

while循环：

while (循环条件) {
    循环语句 ;
    修改循环结束条件 ;
}

do...while循环：

do {
    循环语句 ;
    修改循环结束条件 ;
} while (循环条件) ;

🍓🍓例1：使用while语句实现求解1~100的累加和。

public class text1 {
    public static void main(String args[]) {
        int sum = 0;         // 保存总和
        int current = 1;         // 循环的初始化条件
        while (current <= 100) {     // 循环结束条件
            sum += current;     // 累加
            current++;    // 改变循环条件
        }
        System.out.println(sum);
    }
}

🍓🍓例2：使用do-while语句实现求解1~100的累加和。

public class text1 {
    public static void main(String args[]) {
        int sum = 0;         // 保存总和
        int current = 1; // 循环的初始化条件
        do {     // 循环结束条件
            sum += current; // 累加
            current++;    // 改变循环条件
        } while (current <= 100); // 循环结束判断
        System.out.println(sum);
    }
}

for循环：已经明确的知道了循环次数，语法如下：

for ( ① 循环初始化条件; ②循环条件; ④迭代部分) {
    ③循环语句 ;
}

执行过程：
①-②-③-④-②-③-④-②-③-④-.....-②
说明：
②循环条件部分为boolean类型表达式，当值为false时，退出循环；
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔；
④可以有多个变量更新，用逗号分隔。

for循环执行演示

🍓🍓例3：使用for语句实现求解1~100的累加和。

public class text1 {
    public static void main(String args[]) {
        int sum = 0;         // 保存总和
        // 设置循环初始化条件current，同时此变量作为累加操作使用
        // 每次执行循环体前都要进行循环判断（current <= 100）
        // 循环体执行完毕后会自动执行“current++”改变循环条件
        for (int current = 1; current <= 100; current++) {
            sum += current;    // 循环体中实现累加操作
        }
        System.out.println(sum);
    }
}

🍓🍓例4：输出乘法口诀表（循环嵌套）。

public class text1 {
    public static void main(String args[]) {
        for (int x = 1; x <= 9; x++) { // 控制循环的行数
            for (int y = 1; y <= x; y++) {// 控制列数
                System.out.print(x + "*" + y + "=" + (x * y) + "\t");
            }
            System.out.println();// 换行
        }
    }
}

跳转语句

🍓🍓正常情况下只要执行了循环，那么只要循环条件满足，循环体的代码就会一直执行，但是在程序之中也提供有两个循环停止的控制语句：continue（退出本次循环）、break（退出整个循环）。此类的语句在使用时往往要结合分支语句进行判断。
🍓🍓例： 观察break语句。

public class text1 {
    public static void main(String args[]) {
        for (int x = 0; x < 10; x++) {
            if (x == 3) {
                break; // 退出整个循环
            }
            System.out.print("x = " + x + "、");
        }
    }
}

🍓🍓例： 观察continue语句。

public class text1 {
    public static void main(String args[]) {
        for (int x = 0; x < 10; x++) {
            if (x == 3) {
                continue; // 之后的代码不执行，直接结束本次循环
            }
            System.out.print("x = " + x + "、");
        }
    }
}

## 数组
### 数组概述
为什么需要数组？
如果说现在要想定义100个整型变量，按照传统的思路，可能这样定义：
int i1,i2 ,... i100，一共写100个变量。

以上的形式的确可以满足技术要求，但是有一个问题，这100多个变量没有任何的逻辑的控制关系， 完全独立，就会出现对象不方便管理的情况，那么在这种情况下就可以利用 数组来解决此类问题。

为了存储多个数据值

什么是数组（Array）？
数组是用来存储同一种数据类型多个元素的容器。
容器：比如教室、衣柜、纸箱等，可以存放多个事物。

• 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
• 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
• 数组的长度一旦确定，就不能修改。
• 可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。

• 数组的分类：

  • 按照维度：一维数组、二维数组、三维数组、…
  • 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

一维数组

数组的声明：
🍓🍓例如：

• int[ ] array ;
• double b[ ];
• String[ ] str;

注意：Java语言中声明数组时 不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

数据类型[ ] 数组名;
或 数据类型 数组名[ ];

数据类型：即数组中存储元素的数据类型，可以是基本数据类型，也可以是引用数据类型;
[ ] ：表示数组;
数组名： 数组的变量名，遵循标识符命名规范;
静态初始化：在 定义数组的 同时就为数组元素 分配空间并 赋值。

例如： int[ ] array = new int[ ]{3, 9, 8};

或int[ ]  array = {3, 9, 8};    （简化写法）
给出初始化值，由系统决定数组长度。

例如：
String names[ ] = new String[ ] {“李四光”, “茅以升”, “华罗庚”}；
或String names[ ] = {“李四光”, “茅以升”, “华罗庚”}；
new：创建数组的关键字，通过new开辟内存空间;

动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行。
数组元素的引用
定义并用new为数组分配空间后，才可以引用数组中的每个元素；
数组元素的引用方式：数组名[数组元素下标]

• 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
• 数组元素下标从0开始；长度为n的数组,合法下标取值范围: 0 —>n-1;
  如int a[ ]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
• 每个数组都有一个属性length指明它的长度;
  例如：a.length 指明数组a的长度(元素个数)
• 数组一旦初始化，其长度是不可变的;

数组元素的默认初始值
数组是引用类型，数组一经分配空间，其中的每个元素就被隐式初始化(默认值)。

内存的简化结构

二维数组

动态初始化：数据类型 数组名称 = new 数据类型行的个数；

例如：int arr = new int3;

• 定义了名称为arr的二维数组；
• 二维数组中有3个一维数组；
• 每一个一维数组中有2个元素；
• 一维数组的名称分别为arr[0], arr[1], arr[2]；
• 给第一个一维数组，索引为1的元素，赋值78的写法是：arr0 = 78 ；

注意： 若定义二维数组int[][] arr = new int[3][];

• 二维数组中有3个一维数组；
• 每个一维数组都是默认初始化值null （数组本身为引用类型）；
• 可以对这三个一维数组分别进行初始化：
  arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2] ；
• int[][] arr = new int[][3]; //非法，声明时可以省略列数，不能省略行数

静态初始化：数据类型 数组名称 = new 数据类型 { {值,值,值…},{值,值,值…},… }

例如：int arr = new int { {3,8,2} , {2,7} , {9,0,1,6} };

• 定义一个名称为arr的二维数组，二维数组中有三个一维数组;
• 每一个一维数组中具体元素也都已初始化; 第一个一维数组 arr[0] = {3,8,2}; 第二个一维数组 arr[1] = {2,7}; 第三个一维数组 arr[2] = {9,0,1,6} ;
• 第三个一维数组的长度表示方式：arr[2].length ;
• 二维数组的长度（行的个数）表示方式：arr.length;

数组使用中常见异常

• 数组索引值越界异常

• 空指针异常

  Java标准输入输出

  🍓标准输出流System.out
  System.out是进行屏幕输出的操作对象，是一个PrintStream类的实例化对象，向标准输出设备输出数据，有2个常用的成员方法：

  public void print(参数)：输出各种常见数据类型;

public void println(参数) ：输出各种常见数据类型，并回车换行;

🍓标准输入流System.in （了解）

读取标准输入设备数据（一般是键盘），是InputStream类的实例化对象，常用的成员方法：
int read():从输入流中读取数据的一个字节，返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1，说明没有读取到任何字节，读取结束。

System.in读入数据并不方便，我们通常使用java.util.Scanner类通过封装System.in实现读入数据，能够很方便的读入不同的数据类型。

🍓Scanner类——如何从键盘获取不同类型的变量

具体实现步骤：

1、导包 ： import java.util.Scanner;
2、Scanner的实例化：Scanner scan = new
Scanner(System.in);

3、调用Scanner类的相关方法，来获取指定类型的变量；

Scanner类提供了以下常用方法用于读取数据：

boolean nextBoolean():读取下一个boolean数据;
byte nextByte()：读取下一个byte数据 ;
short nextShort()：读取下一个short数据 ;
int nextInt() ：读取下一个double数据 ;
long nextLong() ：读取下一个long数据 ;
float nextFloat() ：读取下一个double数据;
double nextDouble() ：读取下一个double数据;
String next() ：读取下一个字符串数据 ;
String nextLine() ：读取下一行数据;
void close():关闭Scanner;