Java6

程序逻辑结构

分支与循环：
在程序开发的过程之中，存在三种程序逻辑：顺序结构、循环结构、分支结构，对于之前所编写的代码都是顺序结构，即：所有的程序都按照定义的代码顺序依次执行

Public class JavaDemo {
  Public static void main(String [] args) {
   Int x = 10;
   X = x * 19;
    }
}

If分支结构：
If分支结构主要针对于关系表达式进行判断和处理的分支操作。对于分支语句，主要有三种使用形式，使用的关键字：if、else

If判断：
if（布尔表达式）{
     条件满足时执行；
}

if…else判断：

if（布尔表达式）{
     条件满足时执行；
}else{
条件不满足时执行；
}

多条件判断：

if（布尔表达式）{
     条件满足时执行；
} else if（布尔表达式）{
    条件满足时执行；
}else if (布尔表达式){
   条件满足时执行；
} [else if (布尔表达式){
条件不满足时执行；
}]

观察if语句：

Public class JavaDemo{
  Public static void main(String args []){
     Int age = 18;
     If (age >=18 && age <= 20) {
        System.out.println(“光荣的参与为人民服务的志愿活动！”);
  }
System.out.println(“回到正常的生活轨迹中去”);
   }
}

if就判断一次

使用if…else:

Public class JavaDemo{
   Public static void main(String args []){
    double money = 20 ;
    if (money >= 19.8){
      System.out.println(“大气拿出20元说不用找啦”);
       }else{
         System.out.println(“在灰暗的角落等别人剩下的东西”);
}
System.out.println(“好好吃饭好好喝”);
}

注意：在使用if的时候，只有if…else可以进行若干条件判断

Public class JavaDemo{
    Public static void main(String args []){
    double score = 90.00 ;
    if (score >= 90.00 && score <= 100){
      System.out.println(“优等生”);
       }else if（score >=60 && score <= 90）{
         System.out.println(“中等生”);
}else{
System.out.println(“差等生”);
    }
  }
}

在进行多条件判断的时候，可以不写else语句。但是好的习惯一定要写上else语句。

switch分支语句

switch是一个开关语句，它主要是根据内容来进行判断，需要注意的是，switch中可以判断的只有数据（int、char、枚举、String）而不能使用逻辑判断。

switch（数据）{
    case 数值：{
       数值满足时执行；
       [break]
     }
     case 数值：
       数值满足时执行；
       [break]
    [default:
       所有判断数值不满足时执行；
       [break；]  
       ]
 }

Public class JavaDemo{
  Public static void main(String args []){
     Int ch = 2;
     switch (ch){
        case 2:
            System.out.println("设置的内容是2");
            break；
        case 1：{
            System.out.println("设置的内容是1");
            break；
        }
        default:{
            System.out.println("没有内容满足");  
            break；
            }
        }
    }
}

switch语句在进行设计的时候，如果你在每一个case后面没有追加break语句，那么会在第一个匹配的case中后一直执行，一直到switch中后续代码执行完毕或者遇见break。

从JDK1.7开始，Oracle公司推出的JDK1.7版本里面将开发者呼吁10年以上的功能加入到了系统之中，可以进行字符串数据的判断。
判断字符串：

Public class JavaDemo{
  Public static void main(String args []){
     String str = "Hello";
     switch (str){
        case "Hello":
            System.out.println("Hello");
            break；
            }
        case "Hello"：{
            System.out.println("Hello");
            break；
        }
        default:{
            System.out.println("NoMatch");  
            }
        }
    }
}

switch这个语句是一个编程语言重要的技术。

while循环结构

所谓的循环结构指的是某一段代码被重复执行的处理操作，在程序之中，提供有while语句来实现循环定义，该语句有两类定义使用形式：
while循环：

while（布尔表达式）{
    条件满足时执行；
    修改循环条件；
}

do…while:

do{
   条件满足时执行；
   修改循环条件；
}while(布尔表达式)；

实现1～100的累加：

Public class JavaDemo{
  Public static void main(String args []){
     int sum = 0 ；   //保存最终的计算总和
     int num = 1 ；  //进行循环控制
     while（num <= 100）{//循环的执行条件
          sum += num ；//累加
          num ++ ； //修改循环条件
        }
        System.out.println(sum);
     }
   }

使用do…while实现数字累加：

Public class JavaDemo{
  Public static void main(String args []){
      int sum = 0 ;
      int num = 1 ;
      do{
          sum += num ;
          num ++;
          }while (num <= 100);
          System.out.println(sum);
       }
   }

while循环与do…while的最大差别：
while循环是先判断后执行，而do…while是先执行一次后判断。开发中能见到do…while为百分之一。首选while循环。

for循环

for循环也是常规的使用结构，其使用的语法如下：

for（定义循环的初始化数值；循环判断；修改循环数据）{
    循环语句的执行；
}

使用for循环实现1到100的累加：

Public class JavaDemo{
  Public static void main(String args []){
      int sum = 0 ;
      for (int x = 1;x <= 100; x++){
          sum += x ;
       }
       System.out.println(sum);
      }
   }

如果现在想要更加清楚的观察到三个操作的定义，可以拆开处理。

Public class JavaDemo{
  Public static void main(String args []){
      int sum = 0 ;
      int x = 1；
      for (;x <= 100; ){
          sum += x ;
       }
       System.out.println(sum);
      }
   }

对于while和for循环的选择只有一个参考标准：
1、在明确确定循环次数的情况下优先选择for循环；
2、在不知道循环次数，但是知道循环条件的情况下使用while循环

循环控制

循环控制语句：break和continue

1. break的主要功能是退出整个循环的结构

Public class JavaDemo{
  Public static void main(String args []){
      for (int x = 1;x < 10; x++){
          if (x > 3){
             break;//循环结束
          }
         System.out.println(x + "、");
        }
      }
   }

输出的是：0、1、2、3
2、continue严格来讲只是结束当前的一次调用（结束当前循环）。

Public class JavaDemo{
  Public static void main(String args []){
      for (int x = 1;x < 10; x++){
          if (x == 3){
             break;//循环结束
          }
         System.out.println(x + "、");
        }
      }
   }

输出：1、2、4、5、6、7、8、9

当执行到continue的时候，表示当前的语句之中代码不在执行而直接进行后续的判断处理。
在c语言中有一个goto的命令，这个指令会直接造成代码的混乱，所以在开发之中都对此深恶痛绝。但是在Java中可以使用continue实现部分goto的功能。

Public class JavaDemo{
  Public static void main(String args []){
      point:for (int x = 1;x < 10; x++){
          for （int y == 0；y < 3; y ++){
          if (x == 3){
             continue point;//循环结束
          }
         System.out.println(x + "、");
         }
         System.out.println();
        }
      }
   }

强烈不建议开发者使用这个功能！

循环嵌套

在一个循环语句中嵌套其他的循环语句就称为循环嵌套处理，循环嵌套层次越多，时间复杂度就越高。
打印乘法口诀表：

Public class JavaDemo{
  Public static void main(String args []){
     for(int x = 1;x <= 9;x ++){//口诀表最多九行
        for （int y = 1;y <= x;y ++){
          System.out.print(y + "*" + x + "=" + (x * y) + "\t")
          }
          System.out.println();//换行
          }
      }
   }

打印三角形：

Public class JavaDemo{
  Public static void main(String args []){
     int line = 5;//总体行数
     for （int x = 0;x < line; x ++){
        for (int y = 0;y < line - x;y ++){
           System.out.print("");
         }
         for(int y = 0; y <= x; y ++){
             System.out.print("* ");
          }
          System.out.println();
        }
      }
   }

程序逻辑的训练。