码迷,mamicode.com
首页 > 编程语言 > 详细

Java流程控制

时间:2016-05-12 14:02:32      阅读:179      评论:0      收藏:0      [点我收藏+]

标签:

不论哪一种编程语言,都会提供两种基本的流程控制结构:分支结构和循环结构。
一、顺序结构
       任何编程语言中最常见的程序结构就是顺序结构。
       顺序结构就是程序从上到下一行一行地执行,中间没有任何判断和跳转。
       如果main方法多行代码之间没有任何流程控制,则程序总是从上向下依次执行,排在前面的代码限制性,
       排在后面的代码后执行。如果没有流程控制,Java方法里的语句是一个顺序执行流,从上向下依次执行每条语句。
二、分支结构
       分支结构用于实现根据条件来选择性地执行某段代码。
       两种常见的分支控制结构:if语句和switch语句
       if语句使用布尔表达式或布尔值作为分支条件来进行分支控制。
       switch语句用于对整个整型值进行匹配,从而实现分支控制。
1,if语句
三种形式:
(1)第一种形式: if语句
if(logic expression)
{
    statements...
}
代码示例:
int age=30;
        if(age>20)
        //只有当age>20时,下面花括号括起来的语句块才会执行
        //花括号括起来的语句是一个整体,要么一起执行,要么一起不会执行
        {
            System.out.println("年龄已经大于20岁了");
            System.out.println("20岁以上的人应该学会承担责任");
        }
运行结果:
年龄已经大于20岁了
20岁以上的人应该学会承担责任
(2)第二种形式:if...else语句
if(logic expression)
{
    statements...
}
else
{
    statements...
}
代码示例:
        //定义变量a,并为其赋值
        int a =5;
        if(a>4)
             //如果a>4,执行下面的执行体,只有一行代码作为代码块
            System.out.println("a大于4");
        else
             //否则,执行下面的执行体,只有一行代码作为代码块
            System.out.println("a不大于4");

运行结果:
a大于4
通常不建议省略if、else、else if后执行块的花括号,即使条件执行体只有一行代码,因为保留花括号会有更好的可读性,而且保留花括号会减小发生错误的可能。
(3)第三种形式:if...else if语句
if(logic expression)
{
    statements...
}
else if(logic expression)
{
    statements...
}
...//可以有零个或多个else if语句
else //最后的else语句也可以省略
{
    statement...
}
代码示例:
int age=45;
if(age>60)
{
    System.out.println("老年人");
}
else if(age>40)
{
    System.out.println("中年人");
}
else
{
    System.out.println("青年人");
}
if...else语句基本规则:
        总是优先把包含范围小的条件放在前面处理。如age>60和age>20这两个条件,明显age>60的范围更小,
所以应该先处理age>60的情况。

2,switch语句
        switch语句由一个控制表达式和多个case标签组成,switch语句后面的控制表达式的数据类型只能是整型,
不能是boolean型。case后紧跟一个代码块,case标签作为这个代码块的标识。
switch语句的语法格式:
switch (expression) {
        case condition1:
            statement(s);
            break;
        case condition2:
            statement(s);
            break;
        ...
        case conditionN:
            statement(s);
            break;

        default:
            break;
        }
       这种分支语句的执行是先对expression求值,然后一次匹配condition1、condition2...conditionN等值,
遇到匹配的值即执行对应的执行体;如果所有case标签后的值都不与expression表达式相等,则执行default标签后的代码块。
代码示例:
        int x=9;
        int y=1;
        int oper=‘-‘;
        switch(oper){
        case ‘+‘:
            System.out.print("x+y"+"="+(x+y));
            break;
        case ‘-‘:
            System.out.print("x-y"+"="+(x-y));
            break;
        case ‘*‘:
            System.out.print("x*y"+"="+(x*y));
            break;
        default:
        {

        }
运行结果:x-y=8
        switch语句先求出expression表达式的值,然后拿这个表达式和case标签后的值进行比较,一旦遇到相等的值,程序开始执行
这个case标签后代码,不再判断与后面case、default标签的条件是否匹配,除非遇到break;才会结束。
注意:
switch语句后的expression表达式的数据类型只能是byte、short、char和int类型;
如果省略了case后代码块的break;所引入的陷阱。

三、循环结构
       循环结构用于根据循环条件重复执行某段代码。
1,while循环语句
语法格式:
[init_statements]
while(test_expression)
{
    statements;
    [iteration_statements]
}
while循环每次循环执行体之前,先对test_expression循环条件求值,如果循环体条件为true,则运行循环体部分,如果循环条件为false,则循环体部分将永远不会执行。
代码示例:
int a=0;
        while(a<9)
        {
            //迭代语句
            a++;
            System.out.print(a);
        }
运行结果:
123456789
2,do...while循环
         do...while循环与while循环的区别在于:while循环是先判断循环条件,如果循环体哦啊见为真才执行循环体;
         而do...while循环则先执行循环体,然后判断循环条件,如果循环条件为真,则执行下一次循环,否则中止循环。
do...while循环的语法格式:
[init_statements]
do
{
    statements;
    [iteration_statements]
}
while(test_expression);
代码示例:
        int x=0;
        do
        {
            x++;
            System.out.print(x);
        }while(x<9);
运行结果:
123456789
3,for循环
for循环是更加简洁的循环语句,大部分情况下,for循环可以代替while循环、do while循环。
for循环基本语法格式:
for([init_statements];[test_expression];[iteration_statement])
{
    statements
}
        程序执行for循环时,先执行循环的初始化语句init_statements,初始化语句只在循环开始前执行一次。每次执行循环体之前,
先计算test_expression循环条件的值,如果循环条件返回true,则执行循环体部分;循环体部分执行结束后执行循环迭代语句。
因此,对于for循环而言,循环条件总比循环体要多执行一次,因为最后一次执行循环条件返回false,将不再执行循环体。
注意:
        for循环的循环迭代语句并没有与循环体放在一起,因此不管是否使用continue来结束本次循环,循环迭代语句一样会获得执行。
代码示例:
        int sum=0;
        for(int a=0;a<=10;a++)
        {
            sum+=a;
            System.out.print(sum);
        }
        System.out.println();
运行结果:
013610152128364555
注意:选择循环变量时,习惯选择i、j、k来作为循环变量。

4,嵌套循环
        如果把一个循环放在另一个循环体内,那么就可以形成嵌套循环,嵌套循环既可以是for循环嵌套while循环,也可以时while
循环嵌套do while循环...即各种类型的循环都可以作为外层循环,各种累心的循环也可以作为内层循环。
代码示例:
    /*
        *****
        ****
        ***
        **
        *
发现图形有很多行,每一个行有很多列。
要使用嵌套循环。原理:形象说法:大圈套小圈
*/
        for (int i = 0; i < 5; i++) {
            for (int j = i; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        for(int x=0;x<5;x++)
        {
            for(int y=0;y<=x;y++)
            {
                System.out.print("*");
            }
            System.out.println();
        }

       

        /*
         * -----*
           ----* *
           ---* * *
           --* * * *
           -* * * * *
         * */
        for(int x=0;x<5;x++)
        {
            for(int y=x+1;y<5;y++)
            {
                System.out.print("-");
            }
            for( int z=0;z<=x;z++)
            {
                System.out.print("*");
            }
            System.out.println();
        }


        /*
         * 九九乘法表
        1*1=1
        1*2=2 2*2=4
        1*3=3 2*3=6 3*3=9
         * */
        for (int i = 1; i <=9; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            System.out.println();
        }

四、控制循环结构
       Java语言没有提供goto语句来控制程序的跳转,这种做法提高了程序流程控制的可读型,但降低了程序流程控制的灵活性,
为了弥补这种不足,Java提供了continue和break来控制循环结构。return可以结束整个方法,当然也就结束了一次循环。
1,使用break结束循环
在某些使用我们需要在某种条件出现时,强行终止结束循环,而不是等到循环条件为false时,这时可以使用break来完成这个功能。
break用于完全结束一个循环,跳出循环体。不管哪种循环,一旦在循环体中遇到break,系统将完全结束该循环,开始执行循环后的代码。
break:强迫程序中断循环,当执行到break,即会离开循环,执行循环外的下一个语句
代码示例: 
break语句可以结束其所在的循环,也可以直接结束其外层循环。
//一个简单的for循环
for(int i=0;i<10;i++)
{
    System.out.println("i的值是"+i);
    if(i==2)
    {
        //执行该语句时将结束循环
        break;    
    }
}

java中的标签就是一个紧跟着英文冒号(:)的标识符。它只有放在循环语句之前才有作用
//外层循环,w作为标识符
w:
for (int x = 0; x < 4; x++) {
            //内层循环
            y:for (int y = 0; y < 4-x; y++) {
                System.out.print("*");
            //跳出w标签所标识的循环。
                break w;
            }
            System.out.println();
通常紧跟在break之后的标签,必须在break所在循环的外层循环之前定义才有意义。
2,使用continue结束本次循环
continue:结束本次循环。可强迫程序跳转到循环的起始处,会停止剩下循环体,从头开始执行。
代码示例:
                //continue    继续
                int n=1;
                while(n<12){
                    if(n==9){
                        n++;//n=10
                        continue;//结束本次循环,继续下次循环
                    }
                    System.out.println(n);
                    n++;
                }

//外层循环,w作为标识符
w:
for (int x = 0; x < 4; x++) {
            //内层循环
            y:for (int y = 0; y < 4-x; y++) {
                System.out.print("*");
            //跳出w标签所标识的循环。
                continue w;
            }
            System.out.println();
3,使用return结束方法
        return的功能是结束一个方法。
        当一个方法执行到一个return语句时,这个方法将被结束。
       一旦在循环体内执行到一个return语句,return语句将会结束该方法,循环自然随之结束。
代码示例:
//一个简单的循环
for (int i = 0; i < 3; i++) {
            System.out.println("i的值是"+i);
            if(i==1)
            {
                return;
            }
            System.out.println("Continue后的输出语句");
        }
运行结果:
i的值是1
return结束整个方法,不管return位于多少层循环之内。

Java流程控制

标签:

原文地址:http://blog.csdn.net/reflse/article/details/51361087

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!