四、控制语句、方法、递归算法

1.控制语句

1. “顺序结构”代表“先执行 a，再执行 b”的逻辑。

2. “条件判断结构”代表“如果…，则…”的逻辑。

3. “循环结构”代表“如果…，则重复执行…”的逻辑。

a.条件判断结构（选择结构）

1.if单分支结构

语法结构：

​ if(布尔表达式){

​ 语句块

​ }

Math 类的使用

• Math.random()该方法用于产生 0 到 1 区间的 double 类型的随机数，但是不包括 1。

int i = (int) (6 * Math.random()); //产生：[0，5]之间的随机整数。

2.if-else双分支结构

语法结构：

​ if(布尔表达式){

​ 语句块 1

​ }else{

​ 语句块 2

​ }

if-else 与条件运算符的比较：

//使用条件运算符
int a=3;
int b=4;
int c=a<b?b:a;		//返回a和b的最大值
System.out.println(c);


//使用 if-else
int a = 3;
int b = 4;
int c2 = 0;
if(a<b){c2 = b;
}else{c2 = a;
}
System.out.println(c2);

3.if-else if-else多分支结构

/**
 * 测试if-else双分支结构
 * 随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长
 * 并将周长与面积进行比较
 */
public class Testif02 {
    public static void main(String[] args) {
        //随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长
        double r=4*Math.random();
        //Math.pow(r,2)求半径r的平方
        double area=3.14*Math.pow(r,2);
        double circle=2*Math.PI*r;
        System.out.println("半径为"+r);
        System.out.println("面积为"+area);
        System.out.println("周长为"+circle);
        if(circle<area){
            System.out.println("周长小于面积");
        }else if(circle==area){
            System.out.println("周长与面积相等");
        }else{
            System.out.println("周长大于面积");
        }
    }
}

4.switch多分支结构（多值情况）

语法结构：

​		switch (表达式) {

​				case 值 1: 

​						语句块 1;

​						[break];

​				case 值 2:

​						语句块 2;

​						[break];

​				 … … … … …

​				[default:

​						默认语句块;]

​		}

• switch 会根据表达式的值从相匹配的 case 标签处开始执行，一直执行到 break 处或者是 switch 的末尾。如果表达式的值与任一 case 值不匹配，则进入 default 语句。
• switch 中表达式的值，是 int(byte、short、char 也可，long 不行)、枚举，字符串。

public class TestSwitch02 {
    public static void main(String[] args){
        int month = 2; //1 表示 1 月，2 表示 2 月，....
        if(month==1||month==2||month==3){
            System.out.println("春季");
        }else if(month==4||month==5||month==6){
            System.out.println("夏季");
        }else if(month==7||month==8||month==9){
            System.out.println("秋季");
        }else{
            System.out.println("冬季");
        }
        System.out.println("========使用 switch 改造上面的代码，switch 特别适合多值判断=============");
        
        switch (month){
            case 1:
            case 2:
            case 3:
                System.out.println("春季");
                break;
            case 4:
            case 5:
            case 6:
                System.out.println("夏季");
                break;
            case 7:
            case 8:
            case 9:
                System.out.println("秋季");
                break;
            default:
                System.out.println("冬季");
        }
    }
}

b.循环结构（while)

语法结构：

​		while (布尔表达式) {

​				 循环体; 

​		}

/**
 * 测试while语句
 */
public class Testwhile {
    public static void main(String[] args) {
        /*int a=0;      //初始化部分
        while(a<4){     //  布尔表达式
            System.out.println(a); //循环体
            a++; //迭代因子
        }
        System.out.println(a);
        int a=3;
        a=++a;

        System.out.println(a);*/
        /**while求1-100的累加和  */
        int i=0;
        int sum1=0;
        //1+2+3+4+...+100=?
        while(i<=100){
            sum1+=i;
            i++;
        }
        System.out.println("sum1="+sum1);


        /**do-while求1-100的和  */
        int n=0;
        int sum2=0;
        do{
            sum2+=n;
            n++;
        }while(n<=100);
        System.out.println("sum2="+sum2);

    }
}

输出结果：
sum1=5050
sum2=5050

c.循环结构（for)

语法结构：

​ for (初始表达式; 布尔表达式; 迭代因子) {

			循环体; 

​ }

for循环里定义的变量不能在for循环外使用

/**
 * 测试for循环
 */
public class Testfor {
    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);
        //2.循环输出9-1之间的数
        for (int x=1;x<=9;x++){
            System.out.print(x+" ");
        }
        System.out.println();
        //3.输出90-1之间能被3整除的数
        for (int n=1;n<=90;n++){
            if (n%3==0){
                System.out.print(n+" ");
            }
        }
        System.out.println();

    }
}

d.循环结构（do-while)

语法结构：

​ do {

​ 循环体;

​ } while(布尔表达式) ;

while 与 do-while 的区别

• while 循环：先判断再执行

• do-while 循环：先执行再判断

运行结构，可以看出 do-while 总是保证循环体至少会被执行一次！

e.嵌套循环

1.braek语句和continue语句

• break 用于强行退出整个循环

/**
 *测试break语句
 * 产生100以内的随机数，直到随机数为88时终止循环
 */
public class TestBreak {
    public static void main(String[] args) {
        int total = 0; //定义计数器
        System.out.println("Begin");
        while(true) {
            total++; //每循环一次计数器加1
            int i = (int)(100*Math.random());
            //当i=88时，退出循环
            if (i == 88) {
                break;
            }
        }
        //输出循环的次数
        System.out.println("Game over,used"+total+"times.");
    }
}

• continue 用于结束本次循环，继续下一次

/**
 * 测试continue语句
 */
public class TestContinue {
    //把100-150之间不能被3整除的数输出，并且每行输出5个
    public static void main(String[] args) {
        int count=0; //定义计数器
        for(int i=100;i<=150;i++){
            if(i%3==0){
                continue;
            }
            //否则（不是3的倍数），输出该数
            System.out.print(i+" ");
            count++; //每输出一个数，计数器加1
            //根据计数器判断每行是否已经输出了5个数
            if (count%5==0){
                System.out.println();
            }
        }
    }
}

• 带标签的continue语句

2.方法

1.语句块

语句块（也叫复合语句）。语句块中定义的变量只能用于自己，外部不能使用。

语句块可以使用外部的变量，而外部不能使用语句块的变量；

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

2.方法

1.方法(method)：一段用来完成特定功能的代码片段，类似于其它语言的函数(function)。

2.方法用于定义该类或该类的实例的行为特征和功能实现。

3.面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。

4.面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法声明格式：

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

​ Java 语句；… … …

​ }

方法的调用方式：

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

public class TestMothod1 {
    /**
     * 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("KZY最cool");
    }
}

3.方法的重载

重载：一个类中可以定义多个名称相同，但形式参数列表不同的方法。

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

构成方法重载的条件：

1. 形参列表不同的含义：形参类型、形参个数、形参顺序不同

2. 只有返回值不同不构成方法的重载

如：int a(String str){}与 void a(String str){}不构成方法重载

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

如：int a(String str){}与 int a(String s){}不构成方法重载

3.递归

递归的基本思想就是“自己调用自己”。

递归是一种常见的算法思路，在很多算法中都会用到。比如：深度优先搜索

（DFS:Depth First Search）等

五、一些练习

1.打印出实心 10×10 正方形、空心 10×10 正方形

/**
 * 　打印出实心 10*10 正方形、空心 10*10 正方形
 */
public class homework6 {
    public static void main(String[] args) {
        //实心
        for(int m=0;m<10;m++){   //十行
            for(int n=0;n<10;n++){  //每行十个
                System.out.print("*  ");
            }
            System.out.println();
        }
        System.out.println("-----------------------------------");
        //空心
        for(int a=0;a<10;a++){  //共十行
            for(int b=0;b<10;b++) {  //每行十位(十列）
                if (a == 0 | a == 9) {   //
                    System.out.print("*  ");
                } else{
                    if (b == 0 | b == 9) {
                    System.out.print("*  ");
                    } else {
                    System.out.print("   ");
                    }
                }
            }
            System.out.println();
        }

    }
}

2.*薪水计算器

• 通过键盘输入用户的月薪，每年是几个月薪水。
• 输出用户的年薪
• 输出一行字“如果年薪超过 10 万，恭喜你超越 90%的国人”，“如果年薪超过 20 万，恭喜你超越 98%的国人”。
• 直到键盘输入数字 88，则退出程序（使用 break 退出循环）
• 键盘输入 66，直接显示“重新开始计算…”，然后算下一个用户的年薪。

/**
 * 薪水计算器
 * (1)通过键盘输入用户的月薪，每年是几个月薪水。
 * (2)输出用户的年薪
 * (3)输出一行字“如果年薪超过 10 万，恭喜你超越 90%的国人”，“如果年薪超过 20 万，恭喜
 * 你超越 98%的国人”。
 * (4)直到键盘输入数字 88，则退出程序（使用 break 退出循环）
 * (5)键盘输入 66，直接显示“重新开始计算...”，然后算下一个用户的年薪。
 */
import java.util.Scanner;
public class SalaryCalulator {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        System.out.println("**************薪水计算器********************");
        System.out.println("1.输入88，退出程序\n2.输入66，计算下一个年薪");
        while(true){
            System.out.println("请输入月薪：");
            int monthSalary=s.nextInt();
            System.out.println("请输入一年几个月薪资：");
            int months=s.nextInt();
            int yearSalary=monthSalary*months;  //年薪
            System.out.println("年薪是："+yearSalary);
            if (yearSalary>=200000){
                System.out.println("恭喜你超越98%的国人");

            }else if(yearSalary>=100000){
                System.out.println("恭喜你超越 90%的国人");
            }

            System.out.println("输入88，退出系统；输入66，继续计算");
            int comm=s.nextInt();
            if(comm==88){
                System.out.println("系统退出");
                break;
            }
            if(comm==66){
                System.out.println("重新计算下一个人的薪资");
                continue;
            }

        }
    }

}