控制语句，方法，递归算法

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

条件判断结构有：if结构和switch结构。而if结构又可以分为if单分支结构、if-else双分支结构、if-else if-else多分支结构。

if单分支结构

 1.如果if语句不写{}，则只能作用于后面的第一条语句。

2.强烈建议，任何时候都写上{}，即使里面只有一句话！

/**
 * 测试if单分支，写个掷色子游戏
 */
public class TestIf01 {
    public static void main(String[] args) {
        int a =(int)(Math.random()*6+1);
        int b =(int)(Math.random()*6+1);
        int c =(int)(Math.random()*6+1);
        int count = a+b+c;
        System.out.println("第一个："+a);
        System.out.println("第二个："+b);
        System.out.println("第三个："+c);
        if(count>=14){
            System.out.println("手气不错，很牛");
        }
        if(count>=10&&count<14){
            System.out.println("手气一般");
        }
        if(count<10){
            System.out.println("回家吧");
        }
        System.out.println("得分："+count);

    }
}

if-else双分支结构

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

/**
 *测试If else双分支结构
 **/
public class Ifelse {
    public static void main(String[] args) {
        double r = 4*Math.random();
        double area = Math.PI*r*r;
        double circle =2*r*Math.PI;

        System.out.println("半径："+r);
        System.out.println("面积："+area);
        System.out.println("周长："+circle);
        if(area>=circle){
            System.out.println("面积的数值大于周长！");
        }else{
            System.out.println("周长的数值大于面积！");
        }
        //条件运算符
        int a =3, b=4;
        int c = a<b?b:a;   //把a和b中较大的数返回
        if(a<b){
            c=b;
        }else{
            c=a;
        }
        System.out.println(c);
    }
}

if-else if-else多分支结构

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

/**
 *测试多分枝结构
 */
//生成[0,100]之间的分数。如果 90以上(含 90)则输出“A+”，如果 80-89输出“A”，
// 如果 70-79输出“B”,60-69之间“C”，60以下是“D”。
public class ifelseif {
    public static void main(String[] args) {
        int i = (int)(Math.random()*100+1);//随机生成0-100的整数
        if(i>=90) {
            System.out.println("A+");
        }else if(i>=80){
            System.out.println("A");
        }else if(i>=70){
            System.out.println("B");
        }else if(i>=60){
            System.out.println("C");
        }else {
            System.out.println("D");
        }
    }
}

switch语句

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

2.switch中表达式的值，是int(byte、short、char也可，long不行)、枚举，字符串。

//测试swich并且与if else对比
public class Swich {
    public static void main(String[] args) {
        //i表示月份
        int i =(int)(Math.random()*12)+1;
        if(i==1||i==2||i==3){
            System.out.println("春");
        }else if(i==4||i==5||i==6){
            System.out.println("夏");
        }else if(i==7||i==8||i==9){
            System.out.println("秋");
        }else {
            System.out.println("冬");
        }
        //swich语句（swich特别适合多值判断）
        switch (i){
            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("冬");
        }
    }
}

循环结构

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

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

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

while循环

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

2.语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

//测试while
public class While {
    public static void main(String[] args) {
        //计算0-100相加的和
        int i = 0;
        int sum = 0;
        while (i<=100){
            sum = sum+i;
            i++;
        }
        System.out.println(sum);
    }
}

while和do while区别 do while 至少被执行一次；

//使用while/for 循环：计算 0-100之间所有数字的和，所有偶数的和，所有奇数的和。
// 2.使用 while/for 循环 0-130之间的数字，每行显示 5个数字。
public class Test {
    public static void main(String[] args) {
        int i =0;
        int sum =0;
        int p = 0;
        for(i=0; i<=100;i++){
            if(i%2==0){//偶数和
                sum += i;
            }
            if(i%2-1==0){//奇数和
                p +=i;
            }
        }
        System.out.println(sum);
        System.out.println(p);
        while(i<=100){
            if(i%2==0){//ou数
                sum+=i;
            }
            if(i%2-1==0){
                p =+ i;
            }

                i++;
        }
        System.out.println(sum);
        System.out.println(p);
        //第二个
        for(i=0;i<131;i++){
            if(i%5==0){
                System.out.println();
            }
            System.out.print(" "+i);

        }
    }
}

嵌套循环

public class qianTao {
    public static void main(String[] args) {
        for(int m=1;m<=9;m++) {
            for (int n = 1; n<=m; n++) {
                System.out.print(n + "*" + m + "=" + n * m + "\t");
            }
            System.out.println();
        }
    }

}

break语句和continue语句

1.break用于强行退出整个循环

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

/**
*产生100以内的随机数，直到随机数为88时终止循环,并打印循环次数
 */
public class Break {
    public static void main(String[] args) {
        int count = 0;//计数
        while(true){
            int i = (int)(Math.random()*100+1);
            count++;//循环一次记一次
            System.out.println(i);
            if(i==88){
                break;
            }
        }
        System.out.println("循环次数："+count);
    }
}

3.带标签的tinue，从内部循环跳到外部循环

 方法

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

方法的调用方式：

普通方法：对象名.方法名(实参列表)

静态方法：类名.方法名(实参列表)

方法的详细说明

形式参数：在方法声明时用于接收外界传入的数据。（方法定义时）

实参：调用方法时实际传给方法的数据。(方法调用时)

返回值：执行完毕后，返还给调用它的环境的数据。

返回值类型：事先约定的返回值的数据类型，如无返回值，则为void。

注意事项

实参必须和形参列表匹配。

return：终止方法运行，并返回的数据。

Java中传递参数，遵循值传递的原则(传递的都是数据的副本)：

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

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

方法的重载(overload)

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

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

构成方法重载的条件：

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

2.只有返回值不同不构成方法的重载如：int a(String str){}与void a(String str){}不构成方法重载

3.只有形参的名称不同，不构成方法的重载如：int a(String str){}与int a(String s){}不构成方法重载

递归结构

1.递归是一种常见的算法思路，在很多算法中都会用到。比如：深度优先搜索（DFS:Depth First Search）等。

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

递归结构包括两个部分：

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

递归体。解决：什么时候需要调用自身方法。

递归的缺陷

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

package com.itbaizhan;
/**
 *测试递归
 */
public class Testdigui {
    public static void main(String[] args) {
        long d1 = System.currentTimeMillis();//开始时间
         long result = factorial(5);
        long d2 = System.currentTimeMillis();//结束时间
        System.out.println(result);
        System.out.println("用时："+(d2-d1));
    }
    public static long factorial(long n) {
        if(n==1){//递归头
            return 1;
        }else{//递归体
            return n*factorial(n-1);
        }
    }
}