java SE 入门之控制语句&方法&递归算法(第五篇)

一 控制语句（选择结构）

 在学习控制语句之前，我们要先明确两件事情，什么是顺序结构（也叫做顺序执行），什么是选择结构 （分支结构或分支执行或选择执行），我们的代码执行是分为先后顺序的，就像我们之前写的代码，从入口执行到结束，这叫做顺序结构。如果之间有选择，执行或者不执行，就叫做选择结构。

这句话很难理解吧。我们举一个列子：小明的妈妈说小明考试一百分，就给小明买一个玩具但是就不去游乐园完了或者就领小明去游乐园完但是不能买玩具，这种二选一或者多选一就是选择结构。也就是我们将要学习的控制语句。

看下面的代码前，需要了解下什么是布尔表达式，布尔表达式，就是返回的布尔值的运算等式。

1、if 语句选择结构 

 语法1： if (Boolean 表达式){

当布尔表达式为真 执行java 代码 块

}  

含义 ：如果布尔表达式为真，就执行java代码块。如果为false就不执行了。看代码：

import java.util.Scanner;

public class Hello {
     public static void main(String[] args ) {
     Scanner input =new Scanner(System.in);
     System.out.println("如果您是男孩请输入1，否则输入其他数字");
     int  sex=input.nextInt();
     if (sex==1) {
        System.out.println("让我猜一猜，如果我们猜错，你是一名女孩吧");
    }
      
    }
}

如果您输入的是1，就会输出“让我猜一猜，如果我们猜错，你是一名女孩吧” ，输入其他数字，就不会执行，这就是选择结构。下面来学习下复杂点的

 语法2： if (Boolean 表达式){

当布尔表达式为真 执行java 代码块1

}  else {

当布尔表达式为 假  执行java 代码块2

}

 含义 ：如果布尔表达式为真，就执行java代码块1。如果为false就执行java 代码块2。

import java.util.Scanner;

public class Hello {
public static void main(String[] args ) {
Scanner input =new Scanner(System.in);
System.out.println("如果您是男孩请输入1，否则输入其他数字");
int sex=input.nextInt();
if (sex==1) {
System.out.println("让我猜一猜，如果我们猜错，你是一名女孩吧");
}else{

System.out.println("让我猜一猜，如果我们猜错，你是一名男孩吧");
}
System.out.println("我猜测的准确率相当高的");
}
}

 其实上诉代码，我们可以用我们的三目运算符去实现；如：System.out.println(true?"男"：“女”);

语法3： if (Boolean 表达式1){

当布尔表达式为真 执行java 代码块1

}  else  if (Boolean 表达式2){

当布尔表达式为 假  执行java 代码块2

}

......

else

{

当布尔表达式为 假  执行java 代码块n

}

含义 ，当布尔表达式1为 真，执行代码块1，如果布尔表达式1为假、验证布尔表达式2，如果布尔表达式2为真执行代码块2，一直到n个长度，看代码

import java.util.Scanner;

public class Hello {
     public static void main(String[] args ) {
     Scanner input =new Scanner(System.in);
     System.out.println("请输入您的数学考试成绩，输入完成按回车");
     double  surce=input.nextDouble();
     if (surce<60) {
        System.out.println("请再接再厉，考试成绩不及格");
    }else if(  surce<75){
        System.out.println("您的成绩还可以，没有达到良好，清继续努力，争取下次考好");
    }else if(  surce<85){
        System.out.println("您的数学成绩距离高分只擦一点点了，争取下次那个高分");
    }else if(surce<95){
        System.out.println("您距离优秀只差一顶点了，继续啊");
        
    }else{
        System.out.println("您真是太棒了，数据居然考这么多分");
        
    }
  }
}
 

上面的代码，不满足第一个if,就会跑到第二个里面，一直到最后。这种写法，如果需要判断的分流太多，太麻烦了，增加了时间和空间的复杂度。下边学习新的选择结构。

2、switch 语句选择结构  

语法：

switch(表达式){
 case 值1:
java语句1；
 break;
case 值2：
java语句2；
break;
case 值3：
 java语句3；
break;
 case 值4：
 java语句4；
break;
 case 值5：
 java语句5；
 break;
case 值6：
....
*default:
java语句n;

}

使用代码案列

 Scanner input =new Scanner(System.in);
     System.out.println("如果您是男性请输入0女性输入1；输入完成按回车键");
     int  sex=input.nextInt();
     
     switch (sex) {
    case 0:
        System.out.println("您是男性吗");
        break;
    case 1:
        System.out.println("您是女性吗");
        break;
    default:
        System.out.println("您输入的无法匹配");
        break;
    }

 上面案列中的break是用于结束本次跳出，不在进行下一次跳出。如果没有default  的语句，可以吗？答案是肯定的，如果没有就不会执行默认的代码。那么没有break可以吗？答案也是肯定的，没有就会穿透执行。case穿透和break：当switch 结构中如果两个或多个 case 之间没有break 结束本次判断，就会两个代码块都会执行.其中break 是结束本次判断的意思。

总结：Switch 特点： 

1. Switch 中没有default语句也是可以的。

2.break也可以没有，如果没有会发生case穿透
 
 看案列，什么是穿透：

import java.util.Scanner;

public class Hello {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入1~12的数字判断季节");
        int num = input.nextInt();
        switch (num) {
        case 3:
        case 4:
        case 5:
            System.out.println("春季");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println("夏季");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println("秋季");
            break;
        case 12:
        case 1:
        case 2:
            System.out.println("冬季");
            break;
        }
    }
}

当输入3、4和5任何一个数字，都会显示春季，这就是穿透。

本文所采用的JDK版本为1.8，其实在jdk1.5以前的版本里面，jdk是只支持int 类型的表达式，(byte,short,char会自动转换成int)，但是在JDK1.5以后的版本，开始支持 enum 枚举（后续我们会学习枚举的），在JDK1.7以后的版本，才开始支持String 字符串。

 二 控制语句（循环结构）

通过上面的控制语句学习，我们知道了什么是选择结构，那什么是循环结构呢？首先我们要了解什么是循环。

循环：以环形、回路或轨道运行;沿曲折的路线运行;特指运行一周而回到原处就成为循环，如果循环没有停止点，称为死循环。

就好比你在运动场跑圈，当跑一圈，就完成了1次循环，当跑10圈，就完成了10次循环.如果你不知道饿，一直跑下去，就是死循环。

 

在java中主要有两种循环，一种叫while  循环一种叫做 for 循环..

1. While循环

语法:

 while(boolean表达式){
循环体;
}
 
 先判断，满足条件就执行，不满足就停止 ，总共执行次数 0-N 次

看下图

上诉代码就是一个死循环,这个死循环如果想停止，我们可以点击停止看牛就停止。现在我不想输出这么多变了，就像输出10变要怎么去完善，去编写呢？？
 

 
public class WhileTest {
    public static void main(String[] args) {
        System.out.println("我的文章写得详细不详细");
        int count=0;
         while (count<10) {
             System.out.println("写得好详细啊");
             count++;
        }
         
    }
}

这个代码是怎么执行的呢，当第一次的时候，布尔表达式成立为true,执行，到第十一次的时候，count 值为10,布尔表达式不成立，所以跳出循环。

那么我们可以总结了：当while 的布尔表达式不成立的时候，就不会执行，满足了，可以执行到n次，也就是我们介绍语法的时候说的，执行0次到n次。现在问题来了，我想要最少执行一次。怎么办呢？？

 

2. do While循环

语法：
do{
循环体；
 }while(boolean表达式);

特点： 先执行，在判断 执行次数 1——N次

 
public class WhileTest {
    public static void main(String[] args) {
        System.out.println("我的文章写得详细不详细");
        int count=0;
         while (count<10) {
             System.out.println("写得好详细啊"+count);
             count++;
        }
         int num=0;
         do {
             System.out.println("你好啊-->"+num);
            ++num;
        } while (num<10);
    }
}

2. for 循环

 for循环

语法：

for(表达式1；表达式2；表达式3){
循环体；
}
表达式1：初始化表达式，最先执行，只执行一次
表达式2：条件表达式，必须是boolean类型。
表达式3：增量表达式(也可以增-加-1)也就是说，不一定++，有可能是--

我们了解了循环的定义，循环是分为死循环的，那么我们看下for循环的死循环。

  for (;;) { System.out.println("Hellt word"); } 

就是任何表达式都没有，我们默认为条件表达式为true，就会一直循环下去。

 //输出1到10 for(int i=1;i<=10;i++){ System.out.println(i); }

到这里，我们经典的几个循环已经学习完了，后续的文章会介绍foreach循环，迭代器等。学习循环了，有几个经典算法，我们不得不会。下面看循环算法。

 

算法一 99乘法表

下边的代码分别使用了for 循环和while 循环打印的。

 
public class WhileTest {
    public static void main(String[] args) {
        ///for 循环打印
         for (int i = 1; i <=9; i++) { //外层循环控制函数
            for (int j = 1; j <=i; j++) {//内层循环控制列数
                
                System.out.print(j+"x"+i+"="+i*j+"	");
            }
            System.out.println("
");
        }
         ///while 循环打印 
         int x, y;
            x = 1;
            while (x <= 9) {//外层循环控制行数
                y = 1;//每次循环都是从1开始
                while (y <= x) {//内层循环控制列数
                    System.out.print(y + "*" + x + "=" + y * x + "	");
                    y++;
                }
                System.out.println("
");
                x++;
            }
    }
}

 算法二 打印金字塔

 
public class WhileTest {
    public static void main(String[] args) {
        for(int x=1;x<=5;x++){
            for(int j=1;j<=(5-x);j++){
                System.out.print(" ");
            }
            for(int y=1;y<=(2*x-1);y++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

public class WhileTest {
    public static void main(String[] args) {
        int x,j,y;
        x=1;
        while(x<=5){
            j=1;
            while(j<=(5-x)){
                System.out.print(" ");
                j++;
            }
            y=1;
            while(y<=(2*x-1)){
                System.out.print("*");
                y++;
            }
            x++;
            System.out.println();
        }
    }
}

算法三 输入个正整数，输出大于0的所有的奇数

Scanner input =new Scanner(System.in);
        System.out.println("请输入一个正整数然后按回车键（Enter）");
        int num= input.nextInt();
        for (int i = 1; i < num; i+=2) {
            System.out.println(i);
        }

3 break 和continue

 先来看代码的执行，在分析。

int num= 10;
        for (int i = 1; i < num; i+=2) {
            System.out.println(i);
            break;
        }
        while(true){
            System.out.println("wbc");
            break;
        }

我们会发现上面的代码只输出了一次，当遇到break 就跳出了循环。所以break 跳出了当前循环。

如果遇到break，那么当前循环中break后面的代码将不执行，eclipse IDE 将会提醒错误。如上图。 在看代码。

 
public class BreakTest {
    public static void main(String[] args) {
         
 
        for (int i = 0; i < 3; i++) {
            int j=0;
            while (j<=i) {
                System.out.println(j);
                 j++;
                 break;
                
            }
        }
         
    }
}



 

我们会发现上面的代码输出的是3个0，不是说break退出终止循环吗.其实终止的是当前循环，外层循环不会被终止。那么如何终止外层循环呢，看代码

    aa:for (int i = 0; i < 3; i++) {
            int j=0;
            while (j<=i) {
                System.out.println(j);
                 j++;
                 break aa;
                
            }
        }

我们可以给外层循环取一个名字，这样我们break的时候，就可以终止这个外层循环，退出外层循环以后，就不在循环里层循环了，起名语法，字母或下划线开头加上：冒号。

总结：

break 作用：

1.退出当前循环
2. 如果遇到break，那么当前循环中break后面的代码将不执行。
3. 退出指定循环。

 

下边来学习下continue;

 
public class continueTest {
    public static void main(String[] args) {
         int num=0;
         while(num<5){
             num++;
             if(num==3){
                 continue;                 
             }
             System.out.println(num);
             
            
             
         }
         
    }
}

上诉代码输出的结果是 0,1,2,4,5，当执行到指定的位置，跳出了本次循环，continue具有跳出本次循环的意思，那么双层循环，会跳出吗？？还是只跳出里层循环？？？

 
public class continueTest {
    public static void main(String[] args) {
         int num=0;
         while(num<5){
             num++;
            for(int i=0;i<num;i++){
                
                 if(num==3){
                     continue;                 
                 }
                 System.out.println("i="+i+"~~~~~~~,num="+num);
            }
             
         }
         
    }
}

通过上面的例子，我们可以看出，他可以跳出，但是只跳出了当前的循环，没有跳出外层循环，那么可以退出指定的外层循环码？？。看列子

 
public class continueTest {
    public static void main(String[] args) {
        outher:for (int i = 0; i < 10; i++) {
             for (int j = 0; j < 10; j++) {
                if(j==5){
                    System.out.println();
                    continue outher;
                
                }    
                System.out.print(j);
            }
            System.out.println();
        }
    }
}

看了上面的代码的执行结果，你会发现，执行了10次01234，那么我们修改下代码，看看你有没有学会，在不执行看结果的前提下，你说说，下面代码输出的是什么，如果您没有答对，请仔细认真的看看本文。

 
public class continueTest {
    public static void main(String[] args) {
        outher:for (int i = 0; i < 10; i++) {
             for (int j = 0; j < 10; j++) {
                if(i==5){
                    System.out.println();
                    continue outher;
                
                }    
                System.out.print(j);
            }
            System.out.println();
        }
    }
}

总结：

continue特点：

1.跳出本次循环进入下一次循环
2.跳出指定循环进入下一次循环

三  方法

 java中的方法
  方法的语法：
 修饰符 返回值类型 方法名（形式参数列表）｛
 方法体
  ｝
 我们来看看java 的修饰符有哪些

public（公共控制符） 任何对象都可以访问

private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）

protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。

final，指定该方法不能被重载。

static，指定不需要实例化就可以激活的一个方法。

synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。

native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

 关于修饰符我们只要记住就可以，以后会经常写的，但是每一个对应的含义一定要懂，这个面试的时候会经常遇到。

在来看看返回值

返回值包含基本类型、引用类型 和无返回值 void，

基本类型  bool int short long byte double float,char等

引用类型有：class ,string 等 

方法名采用大驼峰命名规范，java 中的方法只能以下划线、“$”和字母开头命名。假如说，我要做100万次加法运算，每次加数和被加数都不同，难道我要写一百次System.out.println(a+b);看看用方法怎么实现

public class MeathedTest {
    public static void main(String[] args) {
         Add(100, 200);
         Add(2, 4);
         Add(3, 5);
         Add(4, 5);
    }
    public static void Add(int num1,int num2){
        
        System.out.println(num1+"+"+num2+"="+(num1+num2));
        
    }
}

四 递归算法

递归问题，可以划分为一个或多个子问题，而处理子问题的规则与处理原问题的规则是一样的。
在设计递归算法时，主要需考虑以下两方面的问题：
1.确定方法的目的
确定递归公式。把规模大的、较难解决的问题变成规模较小、易解决的同一问题，需要通过哪些步骤或等式来实现？这是解决递归问题的难点。
确定边界（终了）条件。在什么情况下可以直接得出问题的解？这就是问题的边界条件及边界值。 在下边的案列，我们输入一个整数，求出1到n之间的整数和。

import java.util.Scanner;

public class DiguiTest {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int num = input.nextInt();
        System.out.println(method(num));
    }

    public static int method(int n) {
        if (n == 1) {
            return 1;
        }
        return method(n - 1) + n;
    }

}

 1. 求出method(n) 前n项的和 

2. method(n-1) 前n-1项的和
3. 规律：method(n)=method(n-1)+n;
4.边界(不满足上面规律的n值) ，当n为1时候，1+（1-1）=1，所以当等于1的时候我们就直接返回1.

总结：

 递归算法
1.假设一个方法
2.找规律
3.找边界

递归的核心就是方法调用方法本身，也就是自己调用自己。

在练习一个，现有   1,1,2,3,5,8,13,21........N的一个数列，这个数列叫做斐波拉切数列，现在随便输入一个项数，输出这些项的数列。斐波拉切数列 是第三项等于前两项之和，求项数。。。

import java.util.Scanner;

public class DiguiTest {
    public static void main(String[] args) {
         Scanner input=new Scanner(System.in);
         System.out.println("请输入项数输出斐波拉切");
         int count=input.nextInt();
         for (int i = 1; i <=count; i++) {
             if(i%10==0){
                 System.out.println();                 
             }
             System.out.print($function(i)+"		");
        }
         
    }
public static int $function(int n){
    if(n==1||n==2){
        return 1;
        
    }
     return $function(n-1)+$function(n-2);
}
     

}

在此特别说明，return 是返回的意思，当在循环中使用return 是和break的效果一样的.