Java笔记-04 控制语句

控制语句

• 流程控制语句是用来控制程序中各语句执行顺序的语句， 可以把语句组合成能完成一定功能的小逻辑模块。
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构， 即： 顺序结构、 分支结构和循环结构

选择语句

• if 单选择
• if…else 双选择
• if…else if…else多选择

public class TestIf {
    public static void main(String[] args) {
        int a = (int)(6 * Math.random()) + 1 ; //[0,1)区间内的数
        int b = (int)(6 * Math.random()) + 1 ;
        int c = (int)(6 * Math.random()) + 1 ;
        int sum = a+b+c;
        //单选择
        if (sum >= 15){
            System.out.println("手气不错");
        }
        if (sum >= 9 && sum < 15){
            System.out.println("手气一般");
        }
        //双选择
        if(sum >= 15){
            System.out.println("不错");
        }else{
            System.out.println("凑合");
        }
        //多选择
        if(sum <= 6){
            System.out.println("小");
        }else if(sum <= 9){
            System.out.println("中");
        }else{
            System.out.println("大");
        }
    }
}

• switch，表示多值相等的判断,switch可以是整数，枚举，字符串

public class TestSwitch {
    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("辅音");
                break;
        }
    }
}

循环语句

• 当型和直到型
• while，for，do…while

package MyPro03;
public class TestWhile {
    public static void main(String[] args) {
        // while
        int sum = 0;
        int i = 1;
        while(i <=100){
            sum += i;
            i++;
        }
        System.out.println(sum);
        //for
        int sum2 = 0;
        for(int j = 0;j<=100;j++){
            sum2 += j;
        }
        System.out.println(sum2);
        //for多个条件，逗号分隔
        for(int i1 = 0, j1 = 0;i1<=5;i1++,j1+=i1){
            System.out.println(i1+","+j1);
        }
        //do...while
        int sum3 = 0;
        int k = 1;
        do{
            sum3 += k;
            k++;
        }while (k<=100);
        System.out.println(sum3);
    }
}

• 嵌套循环，循环里面有循环

package MyPro03;

public class TestMFor {
    public static void main(String[] args) {
        //打印一行重复数字
        System.out.println("数字：");
        for(int i = 1;i<=5;i++){
            for(int j = 1;j<=5;j++){
                System.out.print(i+"\t");
            }
            System.out.println();
        }
        System.out.println("\n乘法表:");
        //乘法表
        for(int k = 1;k<10;k++){
            for(int j =1;j<=k;j++){
                System.out.print(j+"*" + k +"="+k*j+"  ");
            }
            System.out.println();
        }
        //1000以内被5整除的数的
        System.out.println("\n被5整除的数：");
        int count = 0;
        for(int h = 0;h<=1000;++h){
            if(h % 5 ==0){
                System.out.print(h+"\t");
                count++;
                if(count % 10 == 0){
                    System.out.println();
                }
            }

        }
    }
}

break continue

• break 结束整个循环
• continue 结束本次循环，并开始下一个

public class TestBreak {
    public static void main(String[] args) {
        System.out.println("break");
        for(int i = 0;i<6;++i){
            if(i == 3){
                break;
            }
            System.out.println(i);
        }
        System.out.println("continue");
        for(int i = 0;i<6;++i){
            if(i == 3){
                continue;
            }
            System.out.println(i);
        }
    }
}

• 带标签的break continue。for之前添加标签outer冒号，后面使用break outer或continue outer

//带标签的for示例，两个数相加，如果和为11就终止本次循环
public class TestLabelFor {
    public static void main(String[] args) {
        outer:for(int i = 1 ; i < 10;i++){
        inner:for(int j = 1; j <= i;j++){
            System.out.print(i+"+"+j+"="+(i+j)+"  ");
            if(i+j == 11){
                System.out.println();
                continue outer;
            }

        }
            System.out.println();
        }
    }
}

语句块和方法

• 语句块，花括号里的内容是一个语句块，语句块的变量只在当前语句块有效。语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块
• 方法：带名字的语句块。方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
• 定义：

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

• 对象名.方法名(实参列表)
• 方法的详细说明， 1. 形式参数：在方法声明时用于接收外界传入的数据。 2. 实参：调用方法时实际传给方法的数据。 3. 返回值：方法在执行完毕后返还给调用它的环境的数据。 4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
• return的两个作用，结束方法，返回值；
• Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本). 基本类型传递的是该数据值的copy值。引用类型传递的是该对象引用的copy值，但指向的是同一个对象

方法的重载

• 一个类多个同名方法
• 重载的方法，实际是完全不同的方法，只是名称相同而已!
  构成方法重载的条件：
  1.不同的含义：看参数类型数量和顺序，形参类型、形参个数、形参顺序不同
  2.只有返回值不同不构成方法的重载，参数名称不同不重载

public class TestOverload {
    static double add(int x,double y){
        return x + y;
    }
    static double add(double x,int y){
        return x * y;
    }
    public static void main(String[] args) {
        System.out.println(add(3.0,5));
        System.out.println(add(3,4.6));
    }
}

递归

• 递归结构包括两个部分：
  1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
  2.递归体。解答：什么时候需要调用自身方法
• 简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

package MyPro03;

public class TestRecursion {
    public static void main(String[] args) {
        long t1 = System.currentTimeMillis();
        System.out.println(factorial(40));
        long t2 = System.currentTimeMillis();
        System.out.println("Time:"+(t2 - t1));
    }
    //阶乘
    static double factorial(int n){
        if(n == 1){
            return 1;
        }else{
            return n * factorial(n - 1);
        }
    }
}