3.1 选择结构

在还没有知道Java 选择结构的时候，我们编写的程序总是从程序入口开始，顺序执行每一条语句直到执行完左后一条语句结束。但是生活中经常需要进行条件判断，根据判断结果决定是否做一件事情，这就需要选择语句。

选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。
主要的选择结构有： if 选择结构和 switch 多选择结构。有如下结构：

if 单选择结构
if - else 双选择结构
if -else if - else 多选择结构
switch 结构

3.1.1 if 单选择结构

语法结构

if(布尔表达式){
    语句块
}

if语句对布尔表达式进行一次判定，若判定为真，则执行}{}中的语句块，否则跳过该语句块。流程图：

在这里插入图片描述
【示例3-1】if 单选择结构

public class Test1 {
    public static void main(String[] args) {
        //通过掷三个骰子看看今天的手气如何？
        int i = (int)(6 * Math.random()) + 1;//通过Math.random()产生随机数
        int j = (int)(6 * Math.random()) + 1;
        int k = (int)(6 * Math.random()) + 1;
        int count = i + j + k;
        //如果三个骰子之和大于15，则手气不错
        if(count > 15) {
            System.out.println("今天手气不错");
        }
        //如果三个骰子之和在10到15之间，则手气一般
        if(count >= 10 && count <= 15) { //错误写法：10<=count<=15
            System.out.println("今天手气很一般");
        }
        //如果三个骰子之和小于10，则手气不怎么样
        if(count < 10) {
            System.out.println("今天手气不怎么样");
        }
        System.out.println("得了" + count + "分");

在这里插入图片描述

Math类的使用

java.lang 包中的Math 类提供了一些用于数学计算的方法。
Math.random() 该方法用于产生一个0到1区间的double 类型的随机数，但是不包括1.
int i= (int)(6 * Math.random()); // 产证：[0,5]之间的随机参数

新手雷区

如果if 语句不写{}，则只能作用于后面的第一条语句。
强烈建议，任何时候都写上{}，即使里面只有一句话！

3.1.2 双选择结构

语法结构：

if(布尔表达式){
 语句块1
}else{
       语句块2
}

当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else 部分。流程图：

在这里插入图片描述
【示例3-2】if - else 结构

public class Test2 {
    public static void main(String[] args) {
        //随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长
        double r = 4 * Math.random();
       //Math.pow(r, 2)求半径r的平方
        double area = Math.PI * Math.pow(r, 2);
        double circle = 2 * Math.PI * r;
        System.out.println("半径为： " + r);
        System.out.println("面积为： " + area);
        System.out.println("周长为： " + circle);
        //如果面积>=周长，则输出"面积大于等于周长"，否则，输出周长大于面积
        if(area >= circle) {
            System.out.println("面积大于等于周长");
        } else {
            System.out.println("周长大于面积");
        }
    }
}

在这里插入图片描述
条件运算符有时候可以用于代替 if - else ，如：

public class Test3 {
    public static void main(String[] args) {
        int a=2; 
        int b=3;
        if (a<b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

public class Test4 {
    public static void main(String[] args) {
        int a=2;
        int b=3;
        System.out.println((a<b)?a:b);
    }
}

在这里插入图片描述

3.1.3 if-else if-else 多选择结构

语法结构

if(布尔表达式1) {
语句块1;
} else if(布尔表达式2) {
语句块2;
}……
else if(布尔表达式n){
    语句块n;
} else {
    语句块n+1;
}

当布尔表达式1 为真时，执行语句块1；否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2；否则，继续判断布尔表达式3 、、、、；如果1~n 个表达式均判定为假时，则执行语句块 n+1，也就是 else 部分，流程图：

在这里插入图片描述

【示例3-5】if-esle if-else 多选择结构

public class Test5 {
    public static void main(String[] args) {
        int age = (int) (100 * Math.random());
        System.out.print("年龄是" + age + "， 属于");
        if (age < 15) {
            System.out.println("儿童， 喜欢玩！");
        } else if (age < 25) {
            System.out.println("青年， 要学习！");
        } else if (age < 45) {
            System.out.println("中年， 要工作！");
        } else if (age < 65) {
            System.out.println("中老年， 要补钙！");
        } else if (age < 85) {
            System.out.println("老年， 多运动！");
        } else {
            System.out.println("老寿星， 古来稀！");
        }
    }
}

在这里插入图片描述

switch 多选择结构

语法结构：

switch (表达式) {
case 值1: 
语句序列1;
[break];
case 值2:
 语句序列2;
[break];
     … … …      … …
[default:
 默认语句;]
}

switch 语句会根据表达式的值从相匹配的case 标签处开始执行，一直执行到 break 语句处或者是switch语句的末尾。如果表达式的值与任一case 不匹配，则进入default 语句（如果存在default 语句的情况）。

根据表达式值的不同可以执行许多不同的操作。switch语句中 case 标签在JDK 1.5 之前必须是整数（long类型除外）或者枚举，不能是字符串，在JDK 1.7 之后允许使用字符串（String）。

大家要注意的是，当布尔表达式是等追判断的情况，可以使用 if -else if -else 多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else 多选择结构。

switch 多选择结构的流程图：

在这里插入图片描述
【示例3-6】switch结构

public class Test6 {
    public static void main(String[] args) {
        char c = 'a';
        int rand = (int) (26 * Math.random());
        char c2 = (char) (c + rand);
        System.out.print(c2 + ": ");
        switch (c2) {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
            System.out.println("元音");
            break;
        case 'y':
        case 'w':
            System.out.println("半元音");
            break;
        default:
            System.out.println("辅音");
        }
    }
}

在这里插入图片描述

3.2 循环结构

循环结构分为两个大类，一类是当型，一类是直到型。

当型
当布尔表达式条件为true时，反复执行某语句，但布尔表达式的值为false 时才停止循环，比如：while 与 for 循环

直到型
先执行某语句，再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false 时才停止循环，比如do-while 循环。

3.2.1 wihle 循环

语法结构：

while (布尔表达式) {
    循环体;
}

在循环刚开始的，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。

语句中应有使循环趋向结束的语句，否则会出现无限循环——“死”循环。

while 循环结构流程图：

在这里插入图片描述

【示例3-7】 while 循环结构：求1到100之间的累加和

public class Test7 {
    public static void main(String[] args) {
        int  i = 0;
        int  sum = 0;
        // 1+2+3+…+100=?
        while (i <= 100) {
            sum += i;//相当于sum = sum+i;
            i++;
        }
        System.out.println("Sum= " + sum);
    }
}

在这里插入图片描述

3.2.2 do-while循环

语法结构：

do {
        循环体;
     } while(布尔表达式) ;

do-while 循环结构会先执行循环体，然后在判断布尔表达式的值，若条件为真，执行循环体他，条件为假时结束循环。do-while 循环体至少执行一次。do-while 循环流程图：

在这里插入图片描述
【示例3-8】do-while 循环结构：1-100之间的累加和

public class Test8 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do {
            sum += i; // sum = sum + i
            i++;
        } while (i <= 100);//此处的；不能省略
        System.out.println("Sum= " + sum);
    }
}

在这里插入图片描述
【示例3-9】while 和 do-while 的区别

public class Test9 {
    public static void main(String[] args) {
        //while循环：先判断再执行
        int a = 0;
        while (a < 0) {
            System.out.println(a);
            a++;
        }
        System.out.println("-----");
        //do-while循环：先执行再判断
        a = 0;
        do {
            System.out.println(a);
            a++;
        } while (a < 0);
    }
}

在这里插入图片描述
从运行效果中可以看出do-while 总是保证循环体至少会被执行一次！

3.2.3 for 循环

语法结构：

for (初始表达式; 布尔表达式; 迭代因子) {
      循环体;
}

for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for 循环在第一次反复之前要进行初始化，即执行初始化表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

初始化部分设置循环变量的初值
条件判断部分在任意布尔表达式
迭代因子控制循环变量的增减

for循环在执行条件判定之后，先执行的循环部分，在执行步进。

for循环结构的流程图：

在这里插入图片描述

【示例3-10】for 循环

public class Test10 {
    public static void main(String args[]) {
        int sum = 0;
        //1.求1-100之间的累加和
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("Sum= " + sum);
        //2.循环输出9-1之间的数
        for(int i=9;i>0;i--){
            System.out.print(i+"、");
        }
        System.out.println();
        //3.输出90-1之间能被3整除的数
        for(int i=90;i>0;i-=3){
            System.out.print(i+"、");
        }
        System.out.println();
    }
}

在这里插入图片描述

Java 里能用到逗号运算符的地方屈指可数，其中一处就是for 循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可以使用一系列由逗号分隔的表达式，而且哪些表达式会独立执行。

【示例3-11】逗号运算符

public class Test11 {
    public static void main(String[] args) { 
        for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
            System.out.println("i= " + i + " j= " + j); 
        } 
    }
}

在这里插入图片描述

无论在初始化还是在步进部分，语句都是顺序执行的。
尽管初始化部分可设置任意数量的定义，但都属于同一类型。
约定：只在for语句的控制表达式中写入与循环变量初始化，条件判断和迭代因子相关的表达式。

初始化部分、条件判断部分和迭代因子可以为空语句，但必须以“;”分开：

【示例3-12】无限循环

public class Test12 {
    public static void main(String[] args) { 
        for ( ; ; ) {    // 无限循环: 相当于 while(true)
            System.out.println("北京尚学堂");
        }
    }
}

编译器将 while（true）与 for（;;）看做同一回事，都指的是无限循环。

在 for 语句的初始化部分声明的变量，其作用域为整个for 循环体，不能在循环体外部使用该变量：

【示例3-13】初始化变量的作用域

在这里插入图片描述

3.2.4 嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while 与 for 循环可以任意嵌套多层。

【示例3-14】嵌套循环

public class Test14 {
    public static void main(String args[]) {
        for (int i=1; i <=5; i++) {
            for(int j=1; j<=5; j++){
                System.out.print(i+"  ");
            }
            System.out.println();
        }
    }
}

在这里插入图片描述

【示例3-15】使用嵌套循环实现九九乘法表

public class Test15 {
    public static void main(String args[]) {
        for (int i = 1; i < 10; i++) { // i是一个乘数
            for (int j = 1; j <= i; j++) { // j是另一个乘数
                System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + "  ");
            }
            System.out.println();
        }
    }
}

在这里插入图片描述

3.2.5 break语句和continue 语句

在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循环，不执行循环中剩余的语句。

【示例3-16】 break 语句

在public class Test16 {
    public static void main(String[] args) {
        int total = 0;//定义计数器
        System.out.println("Begin");
        while (true) {
            total++;//每循环一次计数器加1
            int i = (int) Math.round(100 * Math.random());
            //当i等于88时，退出循环
            if (i == 88) {
                break;
            }
        }
        //输出循环的次数
        System.out.println("Game over， used " + total + " times.");
    }
}

在这里插入图片描述

continue 语句用在循环体重，用于终止某次循环过程，即跳过循环体重尚未执行的语句，接着进行下一次是否执行循环判定。

注意事项

continue 用在 while、 do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。
continue 用在 for 循环中，跳到 for 循环的迭代因子部分。

【示例3-17】continue 语句：把100~150之间不能被3整除的数输出，并且每行输出5个

public class Test17 {
    public static void main(String[] args) {
        int count = 0;//定义计数器
        for (int i = 100; i < 150; i++) {
            //如果是3的倍数，则跳过本次循环，继续进行下一次循环
            if (i % 3 == 0){
                continue;
            }
            //否则（不是3的倍数），输出该数
            System.out.print(i + "、");
            count++;//没输出一个数，计数器加1
            //根据计数器判断每行是否已经输出了5个数
            if (count % 5 == 0) {
                System.out.println();
            }
        }
    }
}

在这里插入图片描述

3.2.6 带标签的break 和 continue

goto 关键字很早就在程序设计语言中出现。尽管 goto 仍是Java 的一个保留关键字，但并未在Java 语言中得到正式使用；Java没有goto语句。然而，在break 和 continue 这两个关键字的身上，我们仍然能看出一些 goto 的影子——带变迁的 break 和 continue。

“标签” 是指后面很一个冒号的标识符，例如：“label：”。对Java 来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break 和continue 关键字通常只中断当前循环，但若随同标签使用，它们就会中断在存在标签的地方。

在 goto 有害论中，最有问题的就是标签，而非 goto，随着标签在一个程序里数量的增多，产生错误的机会也越来越多。但Java 变迁不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。

【示例3-18】带标签 vreak 和 continue ：控制前台循环跳转（打印101 ~ 150 之间所有的质数）

public class Test18 {
    public static void main(String args[]) {
        outer: for (int i = 101; i < 150; i++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0){
                    continue outer;
                }
            }
            System.out.print(i + "  ");
        }
    }
}

在这里插入图片描述

3.3 语句块

语句块（有时叫做符合语句），使用花括号括起来的任意数量的简单Java 语句。块确定了局部变量的作用于。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。

【示例3-19】语句块

public class Test19 {
    public static void main(String[] args) {
        int n;
        int a;
        {
            int k;
            int n; //编译错误：不能重复定义变量n
        } //变量k的作用域到此为止
    }
}

3.4 方法

方法就是一段用来完成特定功能的代码片段，类似于其他语言的函数。

方法用定义该类或该类的实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法声明格式：

[修饰符1  修饰符2  …]   返回值类型    方法名(形式参数列表){
    Java语句；… … …
 }

方法的调用方式：

对象名.方法名称（实参列表）

方法的详细说明

形式参数：在方法声明时用于接收外界传入的数据。
实参：调用方法时实际传给方法的数据。
返回值：方法在执行完毕后返还给调用它的环境的数据。
返回值类型：实现约定的返回值的数据类型，如无返回值，必须显式地指定为 void。

【示例 3-20】方法的声明及调用

public class Test20 {
    /** main方法：程序的入口 */
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        //调用求和的方法：将num1与num2的值传给add方法中的n1与n2
        // 求完和后将结果返回，用sum接收结果
        int sum = add(num1, num2);
        System.out.println("sum = " + sum);//输出：sum = 30
        //调用打印的方法：该方法没有返回值
        print();
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;//使用return返回计算的结果
    }
    /** 打印的方法 */
    public static void print() {
        System.out.println("北京尚学堂...");
    }
}

在这里插入图片描述

注意事项

实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
return 语句终止方法的运行并指定要返回的数据。
Java 中进行方法调用中传递参数时，遵循值传递的原则（传递的都是数据的副本）：

基本类型传递的是该数据值的 copy 值。

引用类型传递的是该对象引用的 copy 值，但指向的是同一个对象。

3.5 方法的重载（overload）

方法的重载是指一个类中可以定义多个方法名相同，但单数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。

雷区

重载的方法，实际是完全不同的方法，只是名称相同而已！

构成方法重载的条件：

不同的含义：形参类型、形参个数、形参顺序不同
只有返回值不同不构成方法的重载

如：

int a(String str){}与 void a(String str){}

只有形参的名称不同，不构成方法的重载

如：

int a(String str){}与int a(String s){}

【示例3-21】方法重载

public class Test21 {
    public static void main(String[] args) {
        System.out.println(add(3, 5));// 8
        System.out.println(add(3, 5, 10));// 18
        System.out.println(add(3.0, 5));// 8.0
        System.out.println(add(3, 5.0));// 8.0
        // 我们已经见过的方法的重载
        System.out.println();// 0个参数
        System.out.println(1);// 参数是1个int
        System.out.println(3.0);// 参数是1个double
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数个数不同，构成重载
    public static int add(int n1, int n2, int n3) {
        int sum = n1 + n2 + n3;
        return sum;
    }
    // 方法名相同，参数类型不同，构成重载
    public static double add(double n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数顺序不同，构成重载
    public static double add(int n1, double n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有返回值不同，不构成方法的重载
    public static double add(int n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有参数名称不同，不构成方法的重载
    public static int add(int n2, int n1) {
        double sum = n1 + n2;         
        return sum;
    }  
}

3.6 递归结构

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。

利用递归可以用简单的程序解决一些父爱的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。

递归结构包括两个部分：

定义递归头。就是：什么时候不调用自己方法。如果没有头，将陷入死循环，也就是递归的结束条件。
递归体。就是：什么时候需要调用自身方法。

【示例3-22】递归：计算 n！

public class Test22 {
    public static void main(String[] args) {
        long d1 = System.currentTimeMillis();  
        System.out.printf("%d阶乘的结果:%s%n", 10, factorial(10));
        long d2 = System.currentTimeMillis();
        System.out.printf("递归费时：%s%n", d2-d1);  //耗时：32ms
    }
    /** 求阶乘的方法*/
    static long  factorial(int n){
        if(n==1){//递归头
            return 1;
        }else{//递归体
            return n*factorial(n-1);//n! = n * (n-1)!
        }
    }
}

在这里插入图片描述

递归的缺陷

简单的程序是递归的有点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要谨慎。

用普通循环快得多：

【示例3-23】使用循环求 n！

public class Test23 {
    public static void main(String[] args) {
        long d3 = System.currentTimeMillis();
        int a = 10;
        int result = 1;
        while (a > 1) {
            result *= a * (a - 1);
            a -= 2;
        }
        long d4 = System.currentTimeMillis();
        System.out.println(result);
        System.out.printf("普通循环费时：%s%n", d4 - d3);
    }
}

在这里插入图片描述

注意事项

任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归；

在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

总结

从结构花程序设计角度出发，程序有单重结构：顺序结构、选择结构和循环结构
选择结构

if 单选择结构 if-else 双选择结构 if-else if-else 多选择结构

switch 多选择机构

多选择结构与 switch 的关系：当布尔表达式是等值判断的情况，可使用多重选择结构 switch 结构，如果布尔表达式区间判断的情况，则只能使用多重选择结构

循环结构：当型：while 与 for 直到型： do-while

while 和 do - while 的区别，在布尔表达式的值为false 时，while的循环体一次也不执行，而do-while 至少执行一次
break 可以在 switch 与循环结构中使用，而continue只能在循环结构中使用
方法就是一段用来完成特定功能的代码片段，类似于其他语言的函数
方法的重载是指一个类中可以定义多个方法名相同，但但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法
任何能递归解决的问题也能使用迭代解决。在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

Java 学习笔记：第三章控制语句

Java 学习笔记：第三章控制语句

3.1 选择结构

3.1.1 if 单选择结构

Math类的使用

3.1.2 双选择结构

3.1.3 if-else if-else 多选择结构

switch 多选择结构

3.2 循环结构

3.2.1 wihle 循环

3.2.2 do-while循环

3.2.3 for 循环

3.2.4 嵌套循环

3.2.5 break语句和continue 语句

3.2.6 带标签的break 和 continue

3.3 语句块

3.4 方法

方法声明格式：

方法的调用方式：

3.5 方法的重载（overload）

3.6 递归结构

递归的缺陷

总结

猜你喜欢

Java 学习笔记：第三章 控制语句

Java 学习笔记：第三章 控制语句

3.1 选择结构

3.1.1 if 单选择结构

Math类的使用

3.1.2 双选择结构

3.1.3 if-else if-else 多选择结构

switch 多选择结构

3.2 循环结构

3.2.1 wihle 循环

3.2.2 do-while循环

3.2.3 for 循环

3.2.4 嵌套循环

3.2.5 break语句和continue 语句

3.2.6 带标签的break 和 continue

3.3 语句块

3.4 方法

方法声明格式：

方法的调用方式：

3.5 方法的重载（overload）

3.6 递归结构

递归的缺陷

总结

猜你喜欢

Java 学习笔记：第三章控制语句

Java 学习笔记：第三章控制语句