Notes 20180308 : 语句

时间 2019-11-30

标签 notes 语句繁體版

原文原文链接

　　在讲解流程控制语句以前，咱们先来讲一下语句的问题。Java中的语句分为声明和赋值语句，条件和循环语句，调用和返回语句；咱们之因此每两个放在一块儿是有深意的，咱们大体将语句分为这三块，并以此为纲来讲一下，重点在流程控制语句（条件和循环语句）。html

　　程序就是由一系列的声明、赋值、条件、循环、调用和返回语句组成的。通常来讲代码的结果都是嵌套的：一个条件或循环语句中也能够嵌套条件语句或循环语句。而一个函数中能够由若干各类语句组成，若干的函数组成类，正式这样的组合才造成了功能丰富的软件。下面咱们从声明和赋值语句讲起；java

1.1 声明与赋值语句

　　声明语句将一个变量名和一个类型在编译时关联起来。Java须要咱们在声明语句的时候指定变量的名称和类型。这样咱们才能清楚的明白可以对其进行的操做。Java是一种强类型语言，由于Java编译器会检查类型的一致性（例如，它不会容许boolean类型和浮点类型的变量相乘）。变量能够声明在第一次使用以前的任何地方，通常咱们会在首次使用时声明它，变量的做用域就是定义它的地方（成员或局部），通常由相同代码段中声明以后的全部语句组成。程序员

　　赋值语句（由一个表达式定义的）将某个数据类型的值（能够是具体值，也能够是一个引用）和一个变量关联起来。在Java中，咱们进行赋值操做，咱们表达的不是数学中的等于“=”，而是将一个地址与该变量名绑定，让该变量名指向这个内存地址。面试

package cn.assignment;

public class Test {
    //声明语句由数据类型与变量名称构成，--这里的数据类型能够是基本数据类型，也能够是引用类型--对象
    static int i;
     /*int ii;
    ii = 89;*///不容许在赋值语句声明完后再赋值，要在一块儿操做,可是能够成员声明,函数中进行赋值的操做
    static int a1;
    public static void main(String[] args) {
        i = 23;
        System.out.println(i);//23
        System.out.println(a1 = 90);//90
    }
}

咱们在开发中每每建议将声明和赋值放在一块儿操做，即声明的同时给语句赋值。算法

1.2 调用和返回语句

　　咱们对Java最大的印象只怕就在面向对象了，咱们写的全部类的最大做用就是在于为有须要的类提供可供解决的方法。这就是调用的的思想。例如咱们写一个加法的运算，那么之后凡是遇到加法的运算，那么就均可以经过调用这个方法来解决了，这就是调用的思想，而有些方法是具备返回值的，返回值的语句是返回语句；举例以下：数据库

//简单的加法运算
    public static int add(int a,int b){
        return a+b;//返回语句
    }

　　经过上面咱们发现语句并不固定于单类型语句的使用，而是花样百出的嵌套，组合使用，这也是高级编程语言的灵活所在。在返回语句中咱们发现有一个关键字return，这里咱们很少作介绍，咱们放在流程语句和continue和break一块儿介绍。express

1.3 流程控制语句

　　了解完声明和赋值语句、调用和返回语句，那么咱们就进入今天的重头戏--流程控制语句了，咱们在本节中会叙述流程控制语句的功能，同时还会附以案例增强，最后会深刻探讨流程控制语句。编程

　　作任何事情都要遵循必定的原则。例如，到图书馆去借书，就必须有借书证，而且借书证不能过时，这两个条件缺一不可。程序设计也是如此，须要有流程控制语言来实现与用户的交流，并根据用户的输入决定程序要“作什么”、“怎么作”等。数组

　　流程控制语言对于任何一门编程语言来讲都是相当重要的，它提供了控制程序步骤的基本手段。若是没有流程控制语句，整个程序将按照线性的顺序来执行，不能根据用户的输入来决定执行的序列。咱们大略的将流程控制语句分为如下这么几类，复合语句、条件语句、循环语句。须要说明的一点是Java的控制流程结构与C、C++的控制流程结构同样，只有不多的例外状况。没有goto语句，可是经过break+标签，能够实现从内层跳出的目的，另外，JDK1.5提供了一种变形的for循环，这是在C、C++中没有出现过的。相似于C#中的foreach循环。多线程

1.3.1 复合语句

　　与C语言及其它语言相同，Java语言的复合语句是以整个区块为单位的语句，因此又称块（block）语句。块是指由一堆大括号括起来的若干条简单的Java语句。块语句以整个块为单位，能够用在任何一个单独语句能够用到的地方，块肯定了变量的做用域。一个块能够嵌套在另外一个块中。在前面的学习中已经解触到了这种块语句。例如在定义一个类或方法时，类体就是以“{}”做为开始与结束的标记，方法体一样也是以“{}”做为标记。对于块语句中的每一个语句都是从上到下的执行。

　　在使用复合语句时特别要注意，复合语句为局部变量建立一个做用域，该做用域为程序的一部分，在该做用域中某个变量被建立并可以被使用，若是某个变量的做用域外使用该变量，则会发生错误。同时，不能在嵌套的两个块中声明同名的变量，这也是不被容许的。

【例5.1】建立CompoundStatementPractice类，进行复合语句的一些验证；

class CompoundStatementPractice{
    public static void main(String[] args){
        int a = 23 ;
        System.out.println("a的值是:"+a);
        {
            int b = 24 , c = 25 ;
            System.out.println("b的值是:"+b);
            boolean boo ;        //咱们必定要注意变量的做用域,也就是它的生命周期
            {
                boo = b > c ;
                System.out.println("复合语句中的嵌套语句:"+boo);
            }
            // int a = 20 ; 若是在main方法中已经声明成员变量,复合语句中再次声明相同名字的成员变量会出现错误
            a = a++ + 1 ;
        }
        //System.out.println("在变量的做用域外使用变量会出现错误:"+b);  会提示找不到符号
        System.out.println("咱们必定要注意变量的做用域,和语句的线性顺序:"+a);
    }
}

1.3.2 条件语句

　　条件语句可根据不一样的条件执行不一样的语句。条件语句包括if条件语句和switch多分支语句。

1.3.2.1 if条件语句

　　If条件语句是一个重要的编程语句，它用于告诉程序在某个条件成立的状况下执行某段程序，而在另外一种状况下执行另外的语句。

　　使用if条件语句，可选择是否要执行紧跟在条件以后的那个语句。关键字if以后是做为条件的“布尔表达式”，若是该表达式返回的结果是true，则执行其后的语句；若为false，则不执行if条件以后的语句。If条件语句可分为简单的if条件语句、if...else语句和if...else if多分支语句。if语句在开发过程当中可能会出现Dead Code状况,咱们平时可能较少遇到,可是要知道这种状况,而且明白这是编译器多作的优化.

1.3.2.1.1 简单的if语句

　　语法格式以下：

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

布尔表达式：必要参数，表示它最后返回的结果必须是一个布尔值。它能够是一个单纯的布尔变量或常量，或者使用关系或布尔运算符的表达式。
语句序列：可选参数。能够是一条或多条语句，当表达式为true时执行这些语句。若是语句序列中仅含有一条语句，则能够省略条件表达语句中的大括号。若是咱们本身编程时书写了大括号，同时语句序列中只有一条语句，那么编译器在编译时会自动帮咱们去除大括号。

【例5.2】建立IfPractice类，进行简单if条件语句的练习

class IfPractice{
    public static void main(String[] args){
        int a = 23 , b = 24 ;
        boolean boo = true ,aoo = false ;
        if(! false == boo || (5 == 6)){
            System.out.println("表达式的形式能够多样但其结果必须为boolean类型");
        }
        if(5 == 6);{
            System.out.println("若是if条件语句后即()后直接跟;则该条if简单语句语句不管是否成立都继续下面代码");
        }
        if(a < b){
            if( a < b){
                System.out.println("If语句能够像复合语句同样嵌套语句!");
            }
            System.out.println("简单if语句的标准形态;");
        }
        if(aoo) System.out.println("简单if语句序列中若只有一条语句则能够省略{}这时并没有语法错误,而且if语句的做用范围也可覆盖,但不支持,为了加强阅读性");
            System.out.println("if语句若省略{},那么其做用范围只是紧随其后的一条语句,其余的语句会线性执行,不会受其表达式的影响!");
        if(boo){}//当简单if语句序列中没有内容时能够省略{},末尾加;,固然也能够保留,
        if(a < b && boo){
            System.out.println("简单if语句中的条件必定要是布尔表达式,也就是结果必须是布尔型,格式不限制");
        }
        /*if(3 = 3){
            System.out.println("咱们必定要肯定if语句条件表达式的数据类型,如上3是int型,结果也是int型,会爆出错误之外的类型");
        }*/
    }
}

If语句注意点：

a,每一种格式都是单条语句。

b,第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：能够写在其余表达式中。

c,条件表达式不管写成什么样子，只看最终的结构是不是true 或者 false;

D.if语句同复合语句同样能够嵌套语句

If语句流程运行图：

1.3.2.1.2 if...else语句

If....else语句和三元运算符的区别

If ....else语句的执行行程图

对于if...else语句可使用三元运算符对语句进行简化,以下面的代码 if(a > 0) b = a ; else b = -a;

能够简化成: b = a>0?a:-a ；上面代码为求绝对值的语句，若是a > 0，就把a的值赋给b,不然将-a赋值给b。也就是“？”前面的表达式为真，则将问号和冒号之间的表达式的计算结果赋值给变量b，不然将冒号后面的计算结果赋值给b，使用三元运算符的好处是可使代码简洁，而且有一个返回值。

图3.4 if...else语句的执行过程图

　　在第一种简单if语句中条件不成立时if语句不能给出任何反馈,这是出现了第二种if语句当条件表达式的结果为true则执行语句1,不然执行语句2.

注意事项:

A.else没有条件表达式

B.else必须和if组合使用,else不能单独使用会报错

C.一个if语句只能有一个else

　　else是能够省略的,当知道条件表达式成立时,能够省略else,这时就至关于1.1if语句

　　if语句和else联合使用时,if若是控制多行语句就必定要加{},不然出现B错误,这时状况为if语句+输出语句+else,B状况产生,若是if控制一行else控制一行时大括号能省,这时若是条件表达式为true则进行紧挨if语句的输出,反之输出else,当if控制一行else控制多行时若是条件表达式为true则进行紧挨if语句的输出,else中输出除去紧挨else的语句反之else中输出,因此Java中无论什么状况不要省略{},避免错误

【例5.3】建立IfElsePractice类，并针对if....else的一些特性进行验证

class IfElsePractice{
    public static void main(String[] args){
        /*else{
            System.out.println("else必须和if语句连用,不能单独使用,不然会错误,有'if',可是没有'else'");
        }*/
        if(5 > 6){
            System.out.println("咱们能够看到简单if语句条件不成立时,if语句不能出现任何反馈,那么咱们怎么知道是条件不成立仍是程序错误呢,这时就出现了if...else语句");
        }
        if(5 > 6){
            System.out.println("为补充if语句而出现的if...else语句");
        }else/*(5 < 6)*/{
            System.out.println("if...else语句中else语句后不能有条件语句直接跟随{},若是跟随(),会发出错误,提示在()后加;");
        }/*else{
            System.out.println("一个if语句只能和一个else语句连用,不然会错误,有'if',可是没有'else'");
        }*/
        if(5 < 6){
            System.out.println("当if后面只控制一条语句时,能够省略{},它会直接输出,不然不支持,由于它只会输出紧跟他的一条");
        }else{
            System.out.println("当else后面只控制一条语句时,能够省略{},它会直接输出,不然不支持,由于它只会输出紧跟他的一条");
        }
    /*if(5 > 6)
        System.out.println("{}省略");  当if...else...语句中，if后边控制多条语句时，{}不可
        以省略，不然会报错“有if没有else”
        System.out.println("{}省略");
        else{
        System.out.println("{}省略时,");
        }*/
        //嵌套语句在if...else语句中的应用
        if(true){
            if(false){
                System.out.println("嵌套语句在if...else中的使用");
            }else{
                System.out.println("嵌套语句在if...else中的使用");
            }
        }else{
            System.out.println("嵌套语句在if...else中的使用");
        }
        /*三元运算符和if...else语句的区别,
        If--else语句与三元运算符的区别:三元运算符运算完要有值出现。好处是：能够写在其余表达式中,而if----else语句则没有这种限制,可是能够写在其余方法中,不能写在表达式中*/
        //求 a的绝对值和b的和
        int a = 7 , b = 3 , sum ;
        if(a > 0){
            System.out.println("您所求的两个数的和为:"+(a+b));
        }else
            System.out.println("您所求的数的绝对值为:"+(-a+b));
        sum = (a > 0 ? a : (-a))+b;    
        System.out.println("您所求的两个数的和为:"+sum);
    }
}

面试题：问下面一段代码是否会正常输出?

if(5 > 6)

    System.out.println("{}省略”);

    System.out.println("{}省略");

else{

    System.out.println("{}省略时,");

  }

答:不会,代码会出现错误,当代码判断条件语句不成立时,会自动跳过紧跟他的一条语句,这是它的做用范围,而后编译下一条代码,这时由于没有发现else,会将他认为是简单if语句,再往下执行时发现了else语句,这是编译会将其做为不合法代码跳出”错误:有’if’没有’else’”

1.3.2.1.3 if...else if语句

注意事项:

A.else if必须和if组合使用，else if语句末尾能够（意味着非必须）是一条单独的else语句
B.else不能有条件表达式
C.咱们if语句第三种格式,任何一个条件表达式成立,if语句直接结束.

【例5.4】建立IfElseIfPractice类，进行对IfElseIf语句的特性进行一些验证

class IfElseIfPractice{
    public static void main(String[] args){
        if(false){
            System.out.println("1");
        }else if(false){
            System.out.println("2");
        }else if(true){//当发现if条件语句为true时,只执行这条语句,其余的就再也不执行,
            System.out.println("3");//跳出这个if..else..if语句,执行其余程序
        }else if(true){
            System.out.println("4");
        }else{
            System.out.println("5");
        }
    }
}

1.3.2.1.4 if条件语句练习

【例5.5】学生考试成绩出来了请对其进行划分等级,要求90--100 A等 80--89 B等 70--79 C等 60--69 D等 60分如下叫家长,谈人生

分析：咱们初看到这道题目时，要注意这么几点

考试成绩大于等于0小于等于100,因此咱们要考虑输入错误的状况!
因为成绩是一个变量，因此这里咱们须要一个变量来表明这个成绩
等级对于成绩来讲是一个区间，而且这是一个条件语句，因此咱们须要应用到比较运算符，和逻辑运算符。
因为咱们在这里须要比较不少区间，因此咱们须要考虑用哪一种语句，在这里很明显选择第三种if语句

class GradePractice{
    public static void main(String[] args){
        int score = 178 ;
        if(score <= 100 && score >= 90){
            System.out.println("您的成绩是:"+score+",相对应的成绩等级为:A等");
        }else if(score < 90 && score >= 80){
            System.out.println("您的成绩是:"+score+",相对应的成绩等级为:B等");
        }else if(score < 80 && score >= 70){
            System.out.println("您的成绩是:"+score+",相对应的成绩等级为:C等");
        }else if(score < 70 && score >= 60){
            System.out.println("您的成绩是:"+score+",相对应的成绩等级为:D等");
        }else if(score >=0 && score < 60){
            System.out.println("您的成绩是:"+score+",叫家长,谈人生!");
        }else{
            System.out.println("成绩输入错误请检查后从新输入!");
        }
    }
}

【例5.6】给出月份,判断它所处的季节 3-5 春季 6-8 夏季 9-11 秋季 12-2 冬季

分析：咱们首先来看需求

首先咱们须要定义一个变量来表明月份，咱们用这个变量来在区间中比较；
第二这个变量要符合咱们的要求，即大于等于1，小于等于12，因此咱们要考虑输入错误的状况；
第三咱们要选择合适的语句，在这里咱们有不少种方法，下面一一介绍

方法一：一个个比较,使用简单if语句。

class SeasonPractice1{
    public static void main(String[] args){
        int month = 9 ;        //声明一个表明月份的变量
        if( month == 1){
            System.out.println("这个月份属于冬季!");
        }
        ......
        if( month == 3){
            System.out.println("这个月份属于春季!");
        }
        ......
        if( month == 6){
            System.out.println("这个月份属于夏季!");
        }
        ......
        if( month == 9){
            System.out.println("这个月份属于秋季!");
        }
        ......
         if( month == 12){
            System.out.println("这个月份属于冬季!");
        }else{
            System.out.println("您输入的数据储存在问题,请检查后从新输入!");
        }
    }
}

方法2：使用逻辑运算符加上if语句。

class SeasonPractice2{
    public static void main(String[] args){
        int month = 2 ;
        if(month == 12 || month == 1 || month == 2){
            System.out.println("这个月份属于冬季!");
            //咱们在这里使用if...else.if语句,须要明白语句的一个特性当有else.if语句为真时即跳出语句再也不进行if.else语句,进行其余语句
        }else if(month == 3 || month == 4 || month == 5){
            System.out.println("这个月份属于冬季!");
        }else if(month == 6 || month == 7 || month == 8){
            System.out.println("这个月份属于冬季!");
        }else if(month == 9 || month == 10 || month == 11){
            System.out.println("这个月份属于冬季!");
        }else {
            System.out.println("对不起,您输入的数据存在问题,请检查后从新输入!");
        }
    }
}

方法三：使用比较运算符,逻辑运算符和if语句；

class SeasonPractice3{
    public static void main(String[] args){
        int month = 17 ;
        if(month == 1 || month == 2 || month == 12){
            System.out.println("这个月份属于冬季!");
        }else if(month >= 3 && month <= 5){
            System.out.println("这个月份属于春季!");
        }else if(month >= 6 && month <= 8){
            System.out.println("这个月份属于夏季!");
        }else if(month >= 9 && month <= 11){
            System.out.println("这个月份属于秋季!");
        }else{
            System.out.print("对不起,您输入的数据错误,请检查后从新输入!");
        }
    }
}

方法四：精简代码，从上面的三种方法咱们能够看出代码的相同性有这么几点，（变量的判断比较，结果的输出，逻辑运算符的运用），咱们将这相同的几点进行精简以下！

class SeasonLastPractice{
    public static void main(String[] args){
        int month = 7 ;
        String str ;
        if(month == 1 || month == 2 || month == 12){
            str = "这个月份属于冬季!";
        }else if(month >= 3 && month <= 5){
            str = "这个月份属于春季!";
        }else if(month >= 6 && month <= 8){
            str = "这个月份属于夏季!";
        }else if(month >= 9 && month <= 11){
            str = "这个月份属于秋季!";
        }else{
            str = "对不起,您输入的数据错误,请检查后从新输入!";
        }
        System.out.print(str);
    }
}

【例5.7】比较三个数的大小(if语句的嵌套使用)

package cn.if_else;

public class ComparePractice {
    public static void main(String[] args) {
        test(7, 7, 7);
        test(1, 2, 3);
        test(2, 1, 3);
        test(3, 2, 1);
        test(1, 3, 2);
    }
    
    public static void test(int a,int b,int c){
        if(a>=b){
            if(b>=c)
                System.out.println("这三个数的大小为:"+"a>=b>=c");
            else if (a>=c) {
                System.out.println("这三个数的大小为:"+"a>=c>b");
            }else {
                System.out.println("这三个数的大小为:"+"c>a>=b");
            }
        }else {
            if(b<=c)
                System.out.println("这三个数的大小为:"+"a<b<=c");
            else if(a<=c){
                System.out.println("这三个数的大小为:"+"a<=c<b");
            }else {
                System.out.println("z这三个数的大小为:"+"c<a<b");
            }
        }
    }
}

【例5.8】求三个数中的最值；（这里本人作出了一种测试，实际能够有多重方法，不一一赘述，详细的能够参见CSDN的一篇文章，代码赘述在下面）

package cn.if_else;

public class MaxPractice {
    public static void main(String[] args){
        max(7, 6, 9);
        min(7, 6, 9);
    }
    public void test(){
        int a = 2 , b = 8 , c = 6 , max = 0;
        //若是只是求最大值,那么咱们只用拿出大的那个值同最后一个值比较
        if(a > b){
            if(a > c){
                max = a ;
            }else{
                max = c ;
            }
        }else{
            if(b > c){
                max = b ;
            }else{
                max = c ;
            }
        }
        System.out.print("三个数的最大值为:"+max);
    }
    /**
     * 求最大值
     */
    public static void max(int a,int b,int c){
        if(a>=b&&a>=c)
            System.out.println("最大值为:"+"a");
        else if (c>=b&&c>=a) {
            System.out.println("最大值为:"+"c");
        }else if(b>=a&&b>=c) {
            System.out.println("最大值为:"+"b");
        }
    }
    /**
     * 求最小值
     */
    public static void min(int a,int b,int c){
        if(a<=b&&a<=c){
            System.out.println("最小值为:"+"a");
        }else if (b<=a&&b<=c) {
            System.out.println("最小值为:"+"b");
        }else if (c<=a&&c<=b) {
            System.out.println("最小值为:"+"c");
        }
    }
}

1、if语句嵌套

int a = 10;
int b = 30;
int c = 20;

int max;
if (a > b) {
if (a > c) {
max = a;
} else {
max = c;
}
} else {
if (b > c) {
max = b;
} else {
max = c;
}

}


2、if语句

int a = 10;
int b = 30;
int c = 20;

int max;
if (a > b) {
max = a;
} else {
max = b;
}

if (max < c) {
max = c;
}


3、if语句（假定a最大，b,c与a比较，若是比a大，则赋值给max）

int a = 10;
int b = 30;
int c = 20;

int max = a;
if (b > max) {
max = b;
}
if (c > max) {
max = c;
}


4、三元运算符

int a = 10;
int b = 30;
int c = 20;

int max = (a > b) ? a : b;
max = (max > c) ? max : c;

或者

int max = ((a > b ? a : b) > c) ? (a > b ? a : b) : c;（建议不用这种）


五、if语句 + 逻辑运算符 &&（a,b,c三个数，若是不是a最大，或者b最大，就是c最大）

int a = 10;
int b = 30;
int c = 20;

int max;
if (a > b && a > c) {
max = a;
} else if (c > a && c > b) {
max = c;
} else
max = b;

1.3.3 选择语句

　　在JDK 1.6及之前的版本中，switch语句中表达式的值必须是整型或字符型，常量值1~n必须也是整型或字符型，可是在JDK 1.7中，switch语句的表达式的值除了整型和字符型，还能够是字符串类型，这是JDK1.7 新添的特性。

switch语句:

A.当咱们看到switch的时候,这就是一个选择语句
B.表达式:是一个常量或者变量,byte,short,int,char,因此case取值其实与表达式的类型一致
jdk1.5之后支持枚举， jdk1.7之后支持String
C.case:表示的就是一个选项,取值就是选项的值
D.执行语句:功能代码.
E.break:switch语句的结束符.
F.default:默认值,至关于if语句的else

【例5.9】根据指定的日期（1~7），输出相应的星期；

class SwitchWeekPractice{
    public static void main(String[] args){
        int day = 9 ;
        switch(day){
            default:    //若没有一个常量的值与表达式的值相同则默认执行default,
            System.out.println("请检验您的输入数字是否正确!");
            //若是没有发现break,则继续执行下面的case语句直到发现break
            case 1:
            System.out.println("根据您输入的数字能够肯定是:星期一");
            break;
            /*default:    一个switch语句中只能有一个default,不然会提示标签重复
            System.out.println("请检验您的输入数字是否正确!");*/
            case 2:
            System.out.println("根据您输入的数字能够肯定是:星期二");
            break;
            case 3:
            System.out.println("根据您输入的数字能够肯定是:星期三");
            break;
            case 4:
            System.out.println("根据您输入的数字能够肯定是:星期四");
            break;
            case 5:
            System.out.println("根据您输入的数字能够肯定是:星期五");
            break;
            case 6:
            System.out.println("根据您输入的数字能够肯定是:星期六");
            break;
            case 7:
            System.out.println("根据您输入的数字能够肯定是:星期日");
            break;
        }
    }
}

Switch语句的执行过程：

【例5.10】根据输入的城市名字，查询出城市所在的省；

class ProvincePractice{
    public static void main(String[] args){
        String str = "洛阳";
        switch(str){
            case "石家庄":
            System.out.println("这是河北省会;");
            break;
            case "济南":
            System.out.println("这是山东省会;");
            break;
            case "郑州":
            System.out.println("这是河南省会;");
            break;
            case "洛阳":
            System.out.println("这是河南地级市;");
            break;
            default:
            System.out.println("对不起您所查找的城市在数据库中没有发现,请检查后输入!");
        }
    }
}

【例5.11】根据给定的月份，判断所属的季节；冬季（12,1,2）春季（3，4，5）夏季（6，7，8）秋季（9,10,11）

class SwitchMonthPractice{
    public static void main(String[] args){
        int month = 9 ;
        String str = "";
        switch(month){
        //运用Switch的省略,将break适当省略,将共性放在一处源代码
            case 1:
            str = "冬季";
            case 2:
            str = "冬季";
            case 12:
            str = "冬季";
            break;
            case 3:
            str = "春季";
            case 4:
            str = "春季";
            case 5:
            str = "春季";
            break;
            case 6:
            str = "夏季";
            case 7:
            str = "夏季";
            case 8:
            str = "夏季";
            break;
            case 9:
            str = "秋季";
            case 10:
            str = "秋季";
            case 11:
            str = "秋季";
              break;
            default:
            System.out.println("请检查您所输入的数字是否在范围中!");
        }
        System.out.print("根据您所输入的月份判断季节为:"+str);
    }
}

　　总结：选择语句的功能经过判断语句也是能够实现的，实际上这两个语句在功能上类似，可是在进行选择操做时，switch语句可以更加清楚明了，咱们在进行多项选择操做的时候，且具备明确的选择项，那么switch是个很好的选择，但每每咱们在程序中并无明了的选择项，因此if语句是常见的操做。

1.3.4 循环语句

注意：循环语句是和if语句同样常见的语句，须要重点关注一下；

1.3.4.1 while循环

【例5.12】将1到100的全部奇数都打印出来，并对他们进行求和运算；

分析：首先咱们要明白这是一个累加的运算，咱们在代码中涉及到的是两个变量，奇数和累加的和；对于奇数，咱们对他的判断应该是除2取余为1,下面咱们经过代码来分析；

class OddPractice{ public static void main(String[] args){ int i = 0 ,sum = 0;    //定义一个表明1到100的变量和奇数和的变量
        while(i <= 100){ if(i%2==1){ System.out.print(i+"、"); sum += i; } i++;//省略的话死循环,由于i值不变while后边的条件表达式永远为真
 } System.out.println("咱们所求的奇数和为:"+sum); } }

While语句的执行过程

下面再看一个例子，计算多长时间可以存储必定数量的退休金，假定的是每一年存入相同数量的金额，并且利率是固定的。

package cn.while_statement;

import java.util.Scanner;

/**
 * 例子来源于   Java核心技术_卷1
 * @author Yorick
 * @date   2018年3月5日
 * @ver    1.0
 */
public class Retirement {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("让你退休须要多少钱:");
        //目标钱
        double goal = in.nextDouble();
        System.out.println("每一年你准备存多少钱:");
        double payment = in.nextDouble();
        System.out.println("年利率%:");
        double interestRate = in.nextDouble();
        //帐户余额
        double balance = 0;
        //须要时间-年
        int years = 0;
        while (balance < goal) {
            balance += payment;
            double interest = balance * interestRate/100;
            balance += interest;
            years++;
        }
        System.out.println("你能够在几年后退休:"+years+"years.");
    }
}

1.3.4.2 do...while循环

【例5.13】比较while和do...while;

class CompareWhilePractice{ public static void main(String[] args){ int a = 100 , b = 100 ; //鲜明的比较while和do...while的区别
        while(a == 60){ System.out.println("Ok"+a); a--; } do{ System.out.println("Ok"+b); b--; }while(b == 60); } }

咱们对while循环中的退休金问题进行改编，首先计算帐户余额，而后询问是否要退休；

package cn.while_statement;

import java.util.Scanner;

public class Retirement2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("你每一年要存多少钱:");
        double payment = in.nextDouble();
        System.out.println("年利率%:");
        double interestRate = in.nextDouble();
        double balance = 0;
        int year = 0;
        String input;
        do {
            balance += payment;
            double interest = balance*interestRate/100;
            balance += interest;
            year++;
            System.out.printf("After year %d,your balance is %,.2f%n",year,balance);
            System.out.println("Ready to retire?(Y/N)");
            input = in.next();
        } while (input.equals("N"));//不退休就继续循环
    }
}

1.3.4.3 for循环

1.3.4.3.1 for语句

小结：

关键字:for
固定格式:for(初始化表达式(3);循环条件表达式(1);循环后的操做表达式(4))(2){执行语句(5)}
运行顺序: 循环条件为true时 3--1--5--4--1--5

循环条件为false时 3--1 当循环条件为false时,循环终止

注意事项:

一、变量做用域问题：

- 若是后边要使用这个变量，须要定义在for循环前
- 　若是后边不使用这个变量，须要定义在for循环中
- 变量做用域在一对大括号之间，两个嵌套的for循环中不能声明同名的变量，两个独立的for循环中能够声明同名的变量，可是注意仍然遵循块嵌套。

第一个表达式能够放置在循环体前，能够为空
第三个表达式能够放置在循环体中，能够为空
第二个表达式能够为空，不报错，可是为死循环。除非特殊业务或算法需求，不然不会出现该种状况
尽管Java容许在for循环的各个部分放置任何表达式，可是有一条不成文的规矩：for循环的三个部分应该对同一个计数器变量进行初始化、检查和更新。若不遵循这一规则，编写的循环可能晦涩难懂。
循环中对两个浮点数进行判断要格外当心，浮点数的操做，存在舍入的偏差，可能得不到精确值，如：for(double x = 0; x != 10;x += 0.1)[x将从9.99999999999998跳到10.09999999999998]

【例5.14】计算1到100相加的和；

class SumPractice{
    public static void main(String[] args){
        int sum = 0;
        for(int i = 1;i<101;i++){
            sum += i;
        }
        System.out.println("1到100的累计相加的和为:"+sum);
    }
}

注意：在编程时，有时会使用for循环的特殊语法格式来实现无限循环，语法格式为：

For（；；）{

......

}

对于这种无限循环能够经过break语句跳出循环，例如：

For（；；）{
If(i<20){
System.out.println(“无限循环”);
}
Break；
}

package cn.for_test;

public class Test {
    public static void main(String[] args) {
        int i = 20;
        for (; ; i++) {
            if(i > 25){
                System.out.println("经过break关键字跳出死循环!" + "--i = " + i);
                break;
            }
        }
    }
}

　　咱们在这里,看一个抽奖的问题,这是for循环的典型示例.这个程序用来计算抽奖中奖的几率。例如，若是从1~50之间的数字中取6个数字来抽奖，那么会有（50*49*48*47*46*45）/（1*2*3*4*5*6）种可能的结果，因此中奖的概率是1/15890700。通常状况下，若是从n个数字中抽取k个数字,可使用下列公式获得结果:

　　　　　　　　　　　　　　　　　　　　　　　　　　　　n*(n-1)*(n-2)*...*(n-k+1)/{1*2*3*...*k}

下面咱们经过for循环来实现一下：

package cn.for_test;

import java.util.Scanner;

public class LotteryOdds {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("有多少个数字须要抽取:");
        int k = in.nextInt();
        System.out.println("你能抽到的最大的数字:");
        int n = in.nextInt();
        int lotteryOdds = 1;
        //注意循环不能从0开始,应该从1开始,这是由于除数不能为0,因此这里i = 1
        /*for (int i = 0; i < k; i++) {*/
        for (int i = 1; i <= k; i++) {
            lotteryOdds = lotteryOdds*(n - i + 1)/i;
        }
        System.out.println("Your odds are 1 in" + lotteryOdds + ". Good luck");
    }
}

1.3.4.3.2 foreach语句

　　foreach语句是for语句的特殊简化版本，foreach语句并不能彻底取代for语句，然而任何foreach语句均可以改成for语句版本。foreach并非一个关键字，习惯上将这种特殊的for语句格式称之为foreach语句。foreach语句在遍历数组等方面为程序员提供了很大方便（在数组中咱们将会讲到）。foreach语句也叫加强for循环，加强for循环是for的一种新用法！用来循环遍历数组和集合。编译器在编译时会将增强for转换为底层迭代操做，外观上看起来加强了for的语法,其实是经过迭代器来实现的。关于foreach循环咱们在这里很少作介绍，我会在一篇文章“扒掉foreach的外衣中详细探讨foreach的底层运做”！

语法格式以下

for（元素变量x:遍历对象 obj）{ 　　引用了x的Java语句； }

x的值从数组的第一个元素一直到最后一个元素！

foreach语句中的元素变量x，没必要对其进行初始化。下面经过一个小例子来讲明；

【例5.15】建立一个一维数组，对其进行遍历，经过两种for循环；

public class Repetition{
    public static void main(String args[]){
        int arr[] = {1,2,3,4,5};
        System.out.print("数组中的元素为：");
        /*标准for循环
        for(int i = 0;i<5;i++){
            System.out.print(arr[i]+",");
        }*/
        for(int x:arr){
            System.out.print(x+",");
        //foreach语句，元素变量x为遍历数组的元素值    
        }
    }
}

加强for的冒号左边是定义变量，右边必须是数组或集合类型。例如上例中循环遍历的arr这个int数组，加强for内部会依次把arr中的元素赋给变量i。

加强for

* 1. 只是语法简单了一点点！

* 2. 它没有老for增大！

特色：

* 1. 只能遍历数组、集合...

* 2. 在遍历时不能使用下标

* 3. 遍历只能从头至尾

* 4. 对数组和集合只能作读操做，不能作写操做！

语法：

* 1. for(元素类型变量名 : 集合或数组对象)

* 2. 每次循环，获取一个数组中的元素给左边的变量了。

加强for到底能够遍历什么：

* 1. 能够遍历任何的实现了Iterable接口的实例

* 2. 加强for底层是Iterator

1.3.4.4 循环语句小结

为了完成重复的事情，咱们一般要使用循环来完成需求

3.1 while循环 3.2 do while 3.3 for循环

While语句格式 do{执行语句} for(初始化表达式;循环

条件表达式;循

While(条件表达式){ while(条件表达式); 环后的操做表达式){

执行语句 } 执行语句 }

for条件相对复杂，可是最经常使用,while/do while 简单易懂--具备明确的判断条件时使用

Do while循环较少使用

循环须要的内容：

一、循环条件----循环条件表达式若是没有循环条件就会一直循环下去----存在死循环现象

二、循环体：执行语句----循环执行的代码语句

三、循环变量定义并初始化-----初始化表达式

四、循环变量的变化状况----循环后的操做表达式

　　若是已经能够判断出循环次数的话，使用for循环比较方便，若是不知道循环次数使用while循环比较合适。for循环只不过是while循环的一个简化形式。注意的一点是多线程中咱们使用while，而不建议使用if，这个稍后在多线程中介绍。

1.3.4.5 循环语句的练习

【例5.15】将1到100中的偶数打印出来，而且对他们进行求和；

class EvenPractice{
    public static void main(String[] args){
        int sum = 0;
        for(int i=1;i<101;i++){
            if(i%2==0){
                System.out.print(i+"、");
                sum += i;
            }
        }
        System.out.println("1到100的全部偶数的和为:"+sum);
    }
}

对比【例5.12】while语法计算奇数和

【例5.16】珠峰高度8848m , 一张纸厚度为0.1mm ,判断将一张纸对折多少次能够达到珠峰高度，但不超过珠峰高度,并输出打印对折次数,以及对折后的纸的厚度!分别使用For循环和While循环

class PaperPractice{
    public static void main(String[] args){
        int x = 88480000 , y = 1 ;//定义珠峰高度和纸的厚度
        int n = 0 ;//用n来表示折叠的次数
        /*for(;y<=x;n++){    //for循环的运行顺序: 没有折叠时n=0,纸的厚度小于珠峰高度,纸的厚度乘2加倍,折叠次数加1,此时表明折叠了一次
            y = y*2;    //折叠到倒数第2次时,纸的厚度小于珠峰高度,此时继续循环,纸的厚度超出珠峰高度,次数也会比实际需求大1
        }*/
        /*while(y<=x){
            n++;        //在原有折叠次数上再折叠一次
            y = y * 2 ;    //折叠一次后纸的厚度翻倍
        }*/
        do{
            y=y*2;
            n++;
        }while(y<=x);
        System.out.println("折叠"+n+"次后纸的厚度为:"+y);
        System.out.println("折叠的倒数第二次纸的厚度是:"+y/2);
    }
}

分析：当咱们折叠第一次时，n为1，厚度翻倍，当折叠到倒数第二次时，折叠后，此时纸的厚度仍小于珠峰高度，仍然知足循环条件，此时会再循环一次，但循环后纸的厚度超过珠峰高度，循环中止，因此若是咱们求纸折叠多少次才能达到珠峰高度时，并不超过期，应该为最后获得的折叠次数减去1。另外观察咱们也能够发现对于不知道循环次数的循环咱们使用while循环比较容易理解！

【例5.17】给出一个整数，计算出它的阶乘；使用for和while循环

分析：阶乘：正整数阶乘指从 1 乘以 2 乘以 3 乘以 4 一直乘到所要求的数

class FactorialPractice{
    public static void main(String[] args){
        int x = 12 ;//定义一个咱们要阶乘的数
        int p = 1;//定义一个阶乘后的结果,因为是从1开始,因此咱们将它定义为1
        int y=1;//定义一个乘法的开始数字
        /*for(;y<=x;y++){
            p = p*y;
        }*/
        while(y<=x){
            p = p*y;
            y++;
        }
        System.out.println("咱们所求的阶乘是:"+p);
    }
}

【例5.18】规则图形的打印，打印一个给定行数和给定列数的规则图形；

class FigurePractice{
    public static void main(String[] args){
        //打印一个给定行数给定列数的规则图形(行高9,列数12)
        int line = 9 , list = 12;
        for(int x=1;x<=line;x++){
        //行的循环里嵌套了列的循环换
            for(int y=1;y<=list;y++){
                System.out.print("* ");
            }
            //列尾咱们要注意换行
            System.out.println("");
        }
        //打印一个直角三角形
        for(int x=0;x<5;x++){
            for(int q=0;q<=x;q++){
                System.out.print("* ");
            }
            System.out.println("");
        }
        //打印一个倒立的正三角,实际上就是打印一个空格三角形和另外一个三角形
        for(int y=5;y>0;y--){//定义正三角形的边长,正三角形的边长和它的行数相同
            for(int s=5;s>y;s--){//打印空格的循环和打印*的循环要注意前后,打印空格实际上就是打印一个直角三角形
                System.out.print(" ");
            }
            for(int z=y;z>0;z--){
                System.out.print("* ");
            }    
            System.out.println("");
        }
        //另外一种方法
        int last = 5;
        for(int y=0;y<last;y++){
            for(int q=0;q<y;q++){
                System.out.print(" ");
            }
            for(int z=y;z<last;z++){
                System.out.print("* ");
            }
            System.out.println("");
        }
    //打印一个由数字构成的正三角形
    for(int i=1;i<10;i++){
        for(int j=1;j<10-i;j++){//最多的前面有八个空格
            System.out.print(" ");
        }
        for(int j=i;j>0;j--){//数字的打印咱们分两部分,第一部分从i倒序到1
            System.out.print(j);
        }
        for(int j=1;j<i;j++){//第二部分从2打印当i
            System.out.print(j+1);
        }
        System.out.println("");
    }
    }
}

【例5.19】打印一个正九九乘法表和一个倒立的九九乘法表

class TablePractice{
    public static void main(String[] args){
        for(int x=1;x<10;x++){    //咱们要注意这和大三角形的思想是一致的,可是咱们要打出来的是一些字符串的连接,
            for(int y=1;y<=x;y++){//而且这些连接中包含两个变量
                System.out.print(y+"*"+x+"="+x*y+" ");
            }
            System.out.println("");
        }
        for(int x=9;x>0;x--){
            for(int y=1;y<=x;y++){
                System.out.print(y+"*"+x+"="+x*y+" ");
            }
            System.out.println("");
        }
    }
}

【例5.20】有一对兔子,从第三个月开始产小兔子,每月产一对,小兔子在第三个月也开始生小兔子,假设无心外状况,20个月后有多少只小兔子

分析:发现规律,作以下计算:
第一个月有兔子1对,第二个月有兔子1对,第三个月有兔子2对,第四个月有兔子3对,第五个月有兔子5对,第六个月有兔子8对......从上面咱们能够看到有这么个规律“从第三个月开始腿子的对数是前两个月的兔子对数之和”，
由此咱们能够对所求兔子对数进行一个规律运算；
变量分析：
经过上面的规律咱们能够得出对于兔子对数咱们须要3个变量，即第一个月兔子对数M1，第二个月兔子对数M2，第三个月兔子对数M3，M3=M1+M2；除此以外咱们须要一个月份的变量，者用于循环；
class RabbitPractice{
    public static void main(String[] args){
        int M1 = 1 ,M2 = 1 ,M3 = 2 ;
        //经过规律咱们从第三个月开始按照规律差计算
        for(int month=3;month<=20;month++){
            M3 = M1 + M2;//经过前两个月兔子对数计算出第三个与兔子对数
            M1 = M2;    //此时向下循环的话,最先的第二个月变成了如今的第一个月,
            M2 = M3;    //第三个月变成了第二个月,再下次循环中的第三个月就是前两个月之和
        }
        System.out.print("20个月后咱们共有兔子"+M3+"对;");
    }
}

【例5.21】要求一个五位数个位=万位十位=千位个位+十位+万位+千位=百位

分析：咱们从上面题目中分析出来当给定咱们一个五位数时咱们应该求出这个五位数的个十百千万位，而后进行运算，以一段代码为例：

int a = 98765;
System.out.println("这个数的个位是"+a%10);//整数%10,获得个位数
System.out.println("这个数的十位数是"+a/10%10);//除以10获得的结果,十位数变成了个位数,按照上面求出所需结果
System.out.println("这个数的百位数是"+a/10/10%10);
System.out.println("这个数的千位数是"+a/10/10/10%10);
System.out.println("这个数的万位数是"+a/10/10/10/10%10);

从上面咱们得出了个十百千位的算法，那么咱们就能够在循环中进行判断，而后输出结果；咱们在循环中最早开始比较的是最小的五位数直到最大的五位数；

class NumberPractice{
    public static void main(String[] args){
        int ud,td,hd,thd,md;//声明五个变量表明个十百千位
        //System.out.print();
        for(int num=10000;num<100000;num++){
            ud = num%10;
            td = num/10%10;
            hd = num/10/10%10;
            thd = num/10/10/10%10;
            md = num/10/10/10/10%10;
            //判断知足条件的数字
            if(ud==md&&td==thd&&ud+md+td+thd==hd){
                System.out.print(num+" ");
            }
        }
    }
}

【例5.22】水仙花问题；

1.什么是水仙花问题-----水仙花数是指一个 n 位数 ( n≥3 )，它的每一个位上的数字的n次幂之和等于它自己。
2.假定是一个三位数num,那么num%10得出的结果就是个位值g,num/10%10得出的结果就是十位值s,num/10/10%10得出的结果就是百位值b,根据需求,g*g*g+s*s*s+b*b*b==num
3.要了解什么是水仙花数，这样才能快速选择是用什么方式、方法，甚至算法来解决问题，在这里咱们来计算一下4位数的水仙花问题；
class DaffodilPractice{
    public static void main(String[] args){
        int ud,td,hd,thd;//声明个十百千位
        for(int num=1000;num<10000;num++){
            ud=num%10;
            td=num/10%10;
            hd=num/10/10%10;
            thd=num/10/10/10%10;
            if(ud*ud*ud*ud+td*td*td*td+hd*hd*hd*hd+thd*thd*thd*thd==num){
                System.out.print(num+" ");
            }
        }
    }
}

【例5.23】打印一个空心菱形和一个实心菱形

分析:打印菱形咱们知道,无非就是打印三角,那么打印空心菱形呢?咱们是否是能够按照一样的思路来分析呢?咱们能够将菱形分为打印直三角空格,打印星号,打印正三角空格,打印星号;

下面经过代码来实现;

package cn.practice; public class Diamond { public static void main(String[] args) { fun1(9); } public static void fun1(int hangshu){ //根据行数判断循环次数,若是行数是奇数那么循环此数就是column/2+1,若是是偶数,那么空心菱形只能打印奇数,要作出提示
         int yiban = hangshu / 2 + 1; int yibanduo = hangshu / 2; if(hangshu%2==1){ System.out.println("空心菱形："); for(int k = 1;k <= yiban;k++){ for(int i = 1;i <= (yiban - k);i++){ System.out.print(" "); } System.out.print("*"); for(int i = 1;i <= ( (k - 2) * 2 + 1);i++){ System.out.print(" "); } if(k != 1){ System.out.print("*"); } System.out.println(); } for(int k = yibanduo;k >=1;k--){ for(int i = 1;i <= (yiban - k);i++){ System.out.print(" "); } System.out.print("*"); for(int i = 1;i <= ( (k - 2) * 2 + 1);i++){ System.out.print(" "); } if(k != 1){ System.out.print("*"); } System.out.println(); } System.out.println("实心菱形："); for(int i = 1;i <= hangshu;i++){ if(i <= hangshu/2 + 1){ for(int k = 1;k <= hangshu/2 + 1- i;k++){ System.out.print(" "); } for(int k = 1;k <= i;k++){ System.out.print("* "); } System.out.println(); }else{ for(int k =1;k <= (i -(hangshu/2 + 1));k++){ System.out.print(" "); } for(int k = 1;k <= (2 *(hangshu/2 + 1) - i);k++){ System.out.print("* "); } System.out.println(); } } }else { System.out.println("对不起,空心菱形行数应该为大于0的奇数,请确认输出!"); } } }

【例5.24】打印杨辉三角；

分析:在代码实现以前咱们先来看一下什么是杨辉三角,

杨辉三角，是二项式系数在三角形中的一种几何排列。在欧洲，这个表叫作帕斯卡三角形。它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的优美结合。实现结果以下图所示:

　　分析:杨辉三角的规则是:每一行的第一个值为1,每一行的最后一个值为1,当前数=上一行的数+上一行的数的前一个数;明白了规则咱们就来分析一下,咱们看杨慧三角是否是很像一个二维数组呢?数组的长度为列数,二维数组中角标0对应的是一个长度为1的数组,二维数组角标1对应的是一个长度为2的数组;根据这个咱们下面来经过代码实现;

package cn.practice; public class YangHui { public static void main(String[] args) { fun1(8); } /** * 杨慧三角: * 1.每行的头一个数是1; * 2.每行的最后一个数是1; * 3.当前数是上一行的数+其前一个数 */
     public static void fun1(int column){ /*建立二维数组,来做为杨慧三角中的元素的容器,二维数组的长度是杨慧三角的列数, * 二维数组中的一维数组的长度是当前行的元素个数+空格数*/
         int[][] intArr = new int[column][column]; for (int i = 0; i < intArr.length; i++) { //动态开辟空间,每一行的空间大小和行号是相同的
              intArr[i] = new int[i+1]; } //为数组填充元素
         for (int i = 0; i < intArr.length; i++) { //每一行第一个是1,最后一个也是1
              intArr[i][0] = 1; intArr[i][i] = 1; //注意杨慧三角的运算是从第二行开始的
              for (int j = 1; j < i; j++) { //当前数是上一行的数+其前一个数,实际上只有到了第三行才会运算
                   intArr[i][j] = intArr[i-1][j]+intArr[i-1][j-1]; } } //循环过滤
         for (int j = 0; j < intArr.length; j++) { for (int j2 = 0; j2 < intArr[j].length; j2++) { System.out.print(intArr[j][j2]+"\t"); } //打印完一行换行
 System.out.println(); } } }

1.3.5 条件语句在计算机中的操做

　　咱们知道冯诺依曼提出的存储程序概念要求顺序执行程序,可若是全部的程序都按步照班的一条条的顺序执行,那么就缺乏了用户交互,程序缺乏了灵活性,因此出现了流程控制语句,那么程序在计算机中的执行又有什么不一样了呢?这其实就牵涉到了程序计数器,下面咱们经过了解程序计数器来了解一下"顺序执行";

　　程序计数器是用于存放下一条指令所在单元的地址的地方。当执行一条指令时，首先须要根据PC中存放的指令地址，将指令由内存取到指令寄存器中，此过程称为“取指令”。与此同时，PC中的地址或自动加1或由转移指针给出下一条指令的地址。此后通过分析指令，执行指令。完成第一条指令的执行，然后根据PC取出第二条指令的地址，如此循环，执行每一条指令。

　　在程序开始执行前，将程序指令序列的起始地址，即程序的第一条指令所在的内存单元地址送入PC，CPU按照 PC的指示从内存读取第一条指令（取指）。当执行指令时，CPU自动地修改PC的内容，即每执行一条指令PC增长一个量，这个量等于指令所含的字节数（指令字节数），使 PC老是指向下一条将要取指的指令地址。因为大多数指令都是按顺序来执行的，因此修改PC 的过程一般只是简单的对PC 加“指令字节数”。
　　当程序转移时(即流程控制语句)，转移指令执行的最终结果就是要改变PC的值，此PC值就是转去的目标地址。处理器老是按照PC 指向取指、译码、执行，以此实现了程序转移。

　　流程控制语句提升了程序的可操做性,使得程序更加灵活。对于咱们的开发颇有帮助，可是对于其中的陷阱，咱们也不能忽视！

1.4 break、continue和循环标号&&return

　　Java语句除了流程控制语句用于跳转外,还提供了3中跳转语句，分别是break语句、continue语句和return语句。下面对这三种跳转语句进行详细介绍。

1.4.1 break

　　break语句咱们应该都不会陌生,在介绍switch语句时已经应用过了。在switch语句中，break语句用于终止下面case语句的比较。实际上，break语句还能够应用在for、while和do...while循环语句,用于强行退出循环块，也就是忽略循环块体中任何其余语句和循环条件的限制。

　　break关键字它的常见做用在于跳出当前循环(即break所在的循环,若是存在for(){for(){break;}},那么break只是跳出内存循环,外层循环继续;)，应用范围为循环语句，选择语句。

【例5.25】计算1到100的全部偶数的和，要求当和大于250时跳出，并输出这个和；

class SumDemoPractice{
public static void main(String[] args){ int sum = 0 , i=1; for(;i<101;i++){ if(i%2==0){ sum+=i; } //当和大于250时，break语句跳出循环, if(sum>250){ break; } } //最后一次的相加和已经大于了250,在下面的输出中会体现出来 System.out.print("从1到"+i+"的偶数相加的和为:"+sum); } }

1.4.2 continue

　　Continue语句只能应用在for、while和do...while循环语句中，用于让程序直接跳过其后面的语句进行下一次循环。Continue关键字做用是跳出当前循环进行下次循环，整个循环不结束,那么break和continue有什么不一样呢?下面咱们来对比一下:

这两个语句离开应用范围，存在是没有意义的。
这两个语句单独存在下面都不能够有语句，由于执行不到。
Continue语句是结束本次循环执行下次循环，break是结束循环体进行循环后面的语句。
标号的出现，可让这两个语句做用于指定的范围。
Break只能用于循环和switch语句，continue使用于循环，普通函数这两个关键字不适用。

【例5.25】打印出1到20中的全部奇数，可是13被认为是一个不吉祥的数，不打印

class SumDemo1Practice{ public static void main(String[] args){ int sum = 0 , i = 0; while(i<=20){ i++; if(i%2==1){ if(i==13) continue; System.out.print(i+" "); } } } }

1.4.3 循环标号

　　Break和continue跳转语句它的做用范围仅在当前循环，那么若是多层循环中咱们想break跳出指定循环该怎么操做呢？这时就引出了标号的概念；标号是为循环起一个名字，或者叫作为循环作一个标记，能够经过break 标记达到直接跳出该标记循环的目的,注意标号是须要":"和循环在一块儿使用的。下面咱们举例说明；

【例5.26】打印一个矩形*；

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

打印一个矩形*，当出现一行里超过第三个*时，打印结束；

class RectanglePractice{ public static void main(String[] args){ int a = 4 , b = 5 ; out:for(int i=1;i<=a;i++){ inner:for(int j=1;j<=b;j++){ System.out.print("*"); if(j==3){ //当j==3时,它打印的是第三颗*,此时跳出循环,但他跳出的只是内循环, //咱们如何跳出外循环呢,这时就用到了标号,为循环标号,跳出标号循环 break out; } } System.out.println(""); } } }

1.4.4 return

　　return关键字有两个功能：1是结束函数，2是返回（值会对象）。有返回值的return和返回内容构成返回语句，若是没有返回值，那么就仅仅是中止该函数。return 语句可使其从当前方法中退出，返回到调用该方法的语句处，继续程序的执行。返回语句有两种格式。　　

　　 * return expression: 返回一个值给调用该方法的语句，返回值的数据类型必须与方法声明中的返回值类型一致。可使用强制类型转换来使类型一致。 = 　　

　　 * return: 当方法说明中用 void 声明返回类型为空时，应使用这种格式不返回任何值。此时return是能够省略的。

return语句一般用在一个方法体的最后，以退出该方法并返回一个值。在Java语言中，单独的return语句用在一个方法体的中间时，会产生编译错误【return语句后面不能有代码】，由于这样会有一些语句执行不到。但能够经过把return语句嵌入某些语句（如 if…else）来使程序在未执行完方法中的全部语句时退出，例如：

 void method(int iVar){ if( iVar>0 ){ return; 怪蜀黍 }else{ System.out.println(iVar); } }

Java中的return语句使用总结
一、return语句的做用：a、返回一个值，这个值能够是任意类型。b、使程序返回到操做系统（即终止程序）
二、java中对于一个函数，不论有没有返回值类型，均可以带有return 语句。可是区别在于，return语句是否能够返回一个值（这取决于该函数的返回值类型）。
　　a、若是函数有返回值类型（即返回值类型不为void ），则必须带有返回相应类型值的return 语句。
　　b、若是函数没有返回值（即返回值类型为void ），则函数中return 语句（若是存在return语句！）的后面不能加任何的变量。（该状况下的函数中也能够没有return 语句，可是若是有的话，return 只能做为返回操做系统的做用使用。）
例如：

一、有返回值

public int getAge(){ return age; //返回int 类型的变量age的值 }

二、无返回值 //函数不带return 语句

public void putAge(){ System.out.println(age); }

三、返回到操做系统

//函数无返回值，可是带有return语句public void put(int a) {
        if (a > 0)
            return;      //return语句后不带返回值，做用是退出该程序的运行         
        else
            System.out.println("fasfsa");
}

1.5 总结

　　咱们本节内容进行到了这里,也就进行到了尾声,关于语句总结了不少,其中大部分是例子,对于一些例子.初始写的时候须要思考,再次看的时候,仍不能很快又思路,因此都贴了出来,能够之后随时看看,本节内容也较为浅显,可是用于学习使用已是能够了,望各位阅读者,不吝指教,共同进步!