黑马程序员——Java基础语法 之程序流程控制

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
程序流程控制即通过不同的语句格式对流程进行判断，循环等控制
判断结构
if语句
格式一：
if(条件表达式)
{
执行语句;
}
例如

 class IfDemo 
{
    public static void main(String[] args) 
    {   
        int a=3;
        if(a>3)//只有条件为true时才执行大括号中语句
        {
            System.out.println("Hello World!");
        }
    }
}

技巧，如果if语句中的执行语句只有一条，可以省略大括号，条件成立时，只执行离if()最近语句
例如：

 class IfDemo 
{
    public static void main(String[] args) 
    {   
        int a=3;
        if(a>3)//只有条件为true时才执行大括号中语句
            System.out.println("Hello World!");
    }
}

格式二
if(条件表达式)
{
执行语句①;
}else
{
执行语句②;
}
当条件成立时执行执行语句①，否则执行执行语句②
格式三
if(条件表达式)
{
执行语句①;
}else if(条件表达式)
{
执行语句②;
}
……
else
{
执行语句x;
}
当第一个条件表示为true时，执行执行表达式①。否则进行第二条条件表达式判断，
第二条条件表达式为true执行执行语句②，否则进行第三条条件表达式判断，一直
向下直到结束。
if(条件表达式)后面不能加分号，否则会判断后结束语句而不执行任何执行语句。
原来执行语句代码块变成局部代码块去执行。
选择结构
switch语句
格式：
switch(表达式)
{
case 取值1：
执行语句;
break;
case 取值2：
执行语句;
break;
default:
执行语句；
break；
}
switch语句特点：
1、switch语句选择的类型只有四种：byte，short，int，char,(测试过String也可以）。
2、case与default没有顺序。先执行第一个case，没有匹配的case执行default。
3、结束switch语句的两种情况：①遇到break，②执行到switch语句结束。
4、如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇
到break或者switch结尾结束。
5、进入switch语句后，执行顺序是先执行case，然后从上到下，最后再执行default。即使default放在case
上面，执行顺序也不变。
例一：一个case一种处理方式

class TestDemo
{
    public static void main(String[] args) 
    {
        char ch='=';
        switch(ch)
        {
            case '+':
                System.out.println("ch为+");
                break;
            case '-':
                System.out.println("ch为-");
                break;
            case '*':
                System.out.println("ch为*");
                break;
            case '/':
                System.out.println("ch为/");
                break;
            default:
                System.out.println("ch不是+-*/");
                break;
        }
    }
}

结果为

ch不是+-*/

例二：多个case同一种处理方式

class TestDemo
{
    public static void main(String[] args) 
    {
        char ch='*';
        switch(ch)
        {
            case '+':
            case '-':
                System.out.println("ch为-或+");
                break;
            case '*':
            case '/':
                System.out.println("ch为/或*");
                break;
            default:
                System.out.println("ch不是+-*//");
                break;
        }
    }
}

结果为

ch为/或*

有时候if语句能和switch互换使用，但各有优势，选用时具体问题具体分析
例如对于有几个固定值进行判断，建议使用switch，效率相对高点
循环语句
类型：while(){},do{}whlie(),for(){}
while(){}格式
while(条件表达式)
{
执行语句;
}
只要条件表达式为true，就会一直循环执行主体中的执行语句
do{
执行语句;
}whlie(条件表达式)
执行一次主体中的执行语句，然后判断条件表达式是否为true，若是，再执行主体执行语句，再判断表达式，一直循环直到表达式为false
以上两种格式区别，一开始条件表达式为false时，前者不会执行，后者至少执行一次。
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句;
}
for循环内部语句执行顺序测试

class  TestDemo
{
    public static void main(String[] args) 
    {   
        int i=0;
        for(System.out.println("a");i<3;System.out.println("c"),i++){
            System.out.println("b");
        }
    }
}

由结果可知执行顺序是初始化表达式，循环条件表达式，执行语句，循环后表达式，条件表达式，执行语句…………
最简单的无限循环表达式是while(true),for(;;)

循环结构，由多个循环组成。
for循环嵌套：
练习一，打印出下面格式的内容

*****
****
***
**
*

代码：

class  TestDemo
{
    public static void main(String[] args) 
    {   //方法一：
        for(int i=5;i>0;i--){
            for(int j=i;j>0;j--){
                System.out.print('*');
            }
            System.out.println();
        }   
        //方法二：
        for(int i=0;i<5;i++){
            for(int j=0;j<5-i;j++){
                System.out.print('*');
            }
            System.out.println();
        }
    }
}

练习二，打印出下面格式的内容

*
**
***
****
*****

代码：

class  TestDemo
{
    public static void main(String[] args) 
    {   for(int i=0;i<5;i++){
            for(int j=0;j<=i;j++){
                System.out.print('*');
            }
            System.out.println();
        }
    }
}

练习三：打印99乘法表，正反打
代码：

class  TestDemo
{
    public static void main(String[] args) 
    {   
        //正打99乘法表
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+(i*j)+"\t");
            }
            System.out.println();
        }
        //反打
        System.out.println();
        for(int i=9;i>0;i--){
            for(int j=9;j>0;j--){
                if(j>i)
                {System.out.print("\t");}
                else
                {System.out.print(j+"*"+i+"="+(i*j)+"\t");}
            }
            System.out.println();
        }
    }
}

\t为转义字符，表示制表符，还有\n回车，\b退格\r回车符
windows系统中回车符其实是由两个转义字符组成的：\r\n，linux中回车符是\n。
练习，打印出下面格式的内容

* * * * *
 * * * *
  * * *
   * *
    *

代码：

class  TestDemo
{
    public static void main(String[] args) 
    {   
        for(int i=1;i<=5;i++){
            for(int j=1;j<i;j++){
                System.out.print(" ");
            }
            for(int k=5;k>=i;k--){
                System.out.print("*"+" ");
            }
            System.out.println();
        }
    }
}

break,continue 控制语句
break为跳出当前循环
continue为不执行下面语句而直接继续下一个循环
1、这两个语句离开应用范围，存在是没有意义的。
2、这个两个语句单独存在，下面都不可以有语句，因为执行不到。
使用标号可以让这两个语句作用于指定范围：
continue例子

class  TestDemo
{
    public static void main(String[] args) 
    {   
        a:for(int i=1;i<=4;i++){
            b:for(int j=1;j<8;j++){
                if(j%3==0)
                    continue a;
                System.out.println("j="+j);
            }
        }
    }
}

break例子

class  TestDemo
{
    public static void main(String[] args) 
    {   
        a:for(int i=1;i<=4;i++){
            b:for(int j=1;j<8;j++){
                if(j%3==0)
                    break a;
                System.out.println("j="+j);
            }
        }
    }
}

<以上例子全部没写结果出来，但全部都经编者测试没问题，参考学习可以自己测试>
循环语句提高效率的调整
1，嵌套循环调整
例一：

int v1=100000;
int v2=1000;
int v3=10;
A:for(int i=0;i<=v1;i++){
    for(int j=0;j<=v2;j++){
        for(int k=0;k<=v2;k++){
            执行语句;
        }
    }
}
B:for(int i=0;i<=v3;i++){
    for(int j=0;j<=v2;j++){
        for(int k=0;k<=v1;k++){
            执行语句;
        }
    }
}

由于CPU在循环的内外层之间切换会有一定开销，所以如果可以，使用外层循环最小，内层最多
2，重复使用的调整
如果循环中需要某个定值要通过计算出来，循环内不改变，并且循环完作废，可以使用下面方式

for(int i=0,upper=model();i<upper,i++){
    执行语句;
}

这样可以将upper变量作用域限制最小，并减少CPU计算次数
3，局部变量与成员变量的调整访问

class Test
{
private int time=1000;
public void for_1(){
    for(int i=0;i<times;i++){
        执行语句;
    }
}
public void for_2(){
    int times=this.times;
    for(int i=0;i<times;i++){
        执行语句;
    }
}
}

由于成员变量存在堆内存中，而局部变量存在栈内存中，所以对局部变量的访问速度要快于成员变量
，当很多次访问某个实例变量时，可以先把实例变量赋值给一个局部变量，再对局部变量进行访问，很大提高运行效率。