Java程序逻辑控制
2019-05-16 本文已影响0人
Miracle001
在程序开发的过程之中一共会存在有三种程序逻辑：顺序结构、分支结构、循环结构，对于之前所编写的代码大部分都是顺序结构的定义，即：所有的程序将按照定义的代码顺序依次执行。
IF分支结构
if分支结构主要是针对于关系表达式进行判断处理的分支操作。对于分支语句主要有三类的使用形式，使用的关键字：if、else。
if判断：
if (布尔表达式) {
条件满足时执行 ;
}
if..else判断：
if (布尔表达式) {
条件满足时执行 ;
} [else {
条件不满足时执行 ;
}]
注意：else部分是可选[]部分，但是建议加上
多条件判断：
if (布尔表达式) {
条件满足时执行 ;
} else if (布尔表达式) {
条件满足时执行 ;
} else if (布尔表达式) {
条件满足时执行 ;
} ... [else {
条件不满足时执行 ;
}]
... 省略号表示可以继续加多个条件
if判断：只判断一次，满足就执行满足条件的语句，不满足就算了
public class JavaDemo {
public static void main(String args[]) {
int age = 18 ; // 18换成21
if (age >= 18 && age <= 20) {
System.out.println("光荣的参与为人民服务的志愿活动！") ;
}
System.out.println("回到正常的生活轨迹！") ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
光荣的参与为人民服务的志愿活动！
回到正常的生活轨迹！
age的18换成21后代码执行：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
回到正常的生活轨迹！
现在要进行不满足条件时的执行可以使用if..else操作。
范例：使用if..else
public class JavaDemo {
public static void main(String args[]) {
double money = 20.00 ; // 把20.00换成2再次执行
if (money >= 19.8) {
System.out.println("很牛x走到售卖处，很霸气拿出20元，说不用找了。") ;
} else {
System.out.println("在昏暗的角落，等待别人剩下的东西。") ;
}
System.out.println("好好吃饭，好好的喝！") ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
很牛x走到售卖处，很霸气拿出20元，说不用找了。
好好吃饭，好好的喝！
把20.00换成2再次执行：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
在昏暗的角落，等待别人剩下的东西。
好好吃饭，好好的喝！
在使用if的时候最主要的特点是它可以进行若干个条件判断。在Java里面只有if..else能够执行多个条件判断。
范例：多条件判断
public class JavaDemo {
public static void main(String args[]) {
double score = 90 ;
if (score >= 90 && score <= 100) {
System.out.println("优等生。") ;
} else if(score >= 60 && score < 90) {
System.out.println("良等生。") ;
} else {
System.out.println("差等生。") ;
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
优等生。
在进行多条件判断的时候可以不写上else语句，但是好的习惯一定要写上else语句。
SWITCH开关语句
switch是一个开关语句，它主要是根据内容来进行的判断，需要注意的是 switch 中可以判断的只能够是数据（int、char、枚举、String）而不能够使用逻辑判断，它的语法如下：
switch(数据) {
case 数值 : {
数值满足时执行 ;
[break ;]
}
case 数值 :
数值满足时执行 ;
[break ;]
[default:
所有判断数值不满足时的执行 ;
[break ;]
]
}
case处的大括号{}是可选的。根据习惯来操作。
default也是可选[]的。
范例：观察switch语句
public class JavaDemo {
public static void main(String args[]) {
int ch = 2 ; // 把2换成1再次执行
switch (ch) {
case 2 :
System.out.println("设置的内容是2。") ;
case 1 : {
System.out.println("设置的内容是1。") ;
}
default : {
System.out.println("没有内容满足。") ;
}
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
设置的内容是2。
设置的内容是1。
没有内容满足。
ch的2换成1再次执行：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
设置的内容是1。
没有内容满足。
switch语句在进行设计的时候，如果你在每一个case后面没有追加break语句，那么会在第一个匹配的case之后继续执行，一直到全部的switch中后续代码执行完毕或者遇见break。
范例：使用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 ;
}
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
设置的内容是2。
这个语句什么时候会用到？
dos界面（命令行界面）会让你选择1234...的功能。
此时输入一个数字来表示选项。这个选项可以通过switch来实现。
但是它不能判断非int、非char、非枚举、非String类型。
从 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("No Match") ;
}
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
hello
switch这个语句是一个编程语言发展的重要技术。支持的常用类型String是在 JDK1.7 之后。
while循环
所谓的循环结构指的是某一段代码被重复执行的处理操作，在程序之中提供有while语句来实现循环的定义，该语句有两类使用形式：
while循环：
while (布尔表达式) {
条件满足时执行 ;
修改循环条件 ;
}
do...while循环：
do {
条件满足时执行 ;
修改循环条件 ;
} while (布尔表达式) ;
注意while最后面有一个分号
范例：实现1~100的累加
public class JavaDemo {
public static void main(String args[]) {
int sum = 0 ; // 保存最终的计算总和
int num = 1 ; // 进行循环控制
while (num <= 100) { // 循环的执行条件
sum += num ; // 累加，与"sum = sum + num"效果类似
num ++ ; // 修改循环条件，然后再把这一行注释掉，没有循环条件，此时会导致死循环
}
System.out.println(sum) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
5050
把代码中的"num ++ ; " 这一行注释掉，此时没有循环条件，再次执行代码，会导致死循环
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
......
把代码中的"int num = 1 ;" 中的1换成200，执行代码：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
0
除了使用while循环之外也可以使用do...while来进行处理。
范例：使用do...while实现数字累加
public class JavaDemo {
public static void main(String args[]) {
int sum = 0 ; // 保存最终的计算总和
int num = 1 ; // 进行循环控制
do {
sum += num ; // 累加，与"sum = sum + num"效果类似
num ++ ; // 修改循环条件
} while (num <= 100) ; // 循环的执行条件
System.out.println(sum) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
5050
把代码中的"int num = 1 ;" 中的1换成200，执行代码：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
200
比较 while 和 do...while 二者中 "int num = 200 ;" 的结果：
while ——> 0
do...while ——> 200
此时可以看出while和do...while二者的区别
while 循环与 do...while 循环的最大差别：
while 循环是先判断后执行，而 do...while 先执行一次后判断。开发中能见到 do...while 循环的几率几乎为1%左右，99%的情况下首选的肯定是 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) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
5050
如果现在要想更加清楚的观察到三个操作定义，可以拆开处理。
强烈不建议这种写法，了解即可。
for 循环拆开处理：
public class JavaDemo {
public static void main(String args[]) {
int sum = 0 ; // 保存最终的计算总和
int x = 1 ; // 循环条件初始化
for ( ; x <= 100 ; ) { // 循环判断
sum += x ; // 累加
x ++ ; // 修改循环条件
}
System.out.println(sum) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
5050
对于 while 和 for 循环的选择只有一个参考标准：
在明确确定循环次数的情况下优先选择for循环；
在不知道循环次数但是知道循环结束条件的情况下使用 while 循环；
循环控制
在循环语句定义的时候还有两个控制语句：break、continue；
1、break 主要的功能是退出整个循环结构；
public class JavaDemo {
public static void main(String args[]) {
for (int x = 0 ; x < 10 ; x ++) {
System.out.print(x + "、") ;
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
0、1、2、3、4、5、6、7、8、9、
添加 break 操作后，执行代码：
public class JavaDemo {
public static void main(String args[]) {
for (int x = 0 ; x < 10 ; x ++) {
if (x == 3) { // 此处的双等不能换成单等，单等是赋值，双等是逻辑关系比较
break ; // 整个循环结束
}
System.out.print(x + "、") ;
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
0、1、2、
2、continue严格来讲只是结束当前的一次调用（结束当前循环）
public class JavaDemo {
public static void main(String args[]) {
for (int x = 0 ; x < 10 ; x ++) {
if (x == 3) {
continue ; // 退出x为3的这个循环，继续下面的条件判断
}
System.out.print(x + "、") ;
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
0、1、2、4、5、6、7、8、9、
当执行到了 continue 的时候就表示在当前的语句之中后续代码不再执行，而直接进行后续的判断处理
在C语言里面有一个 goto 的指令，这个指令会直接造成代码的混乱，所以在开发中一般都对其深恶痛绝，但是在Java里面可以利用 continue 实现部分 goto 的功能。最好不要用 goto 这个指令，了解即可。
public class JavaDemo {
public static void main(String args[]) {
point: for (int x = 0 ; x < 10 ; x ++) {
for (int y = 0 ; y < 10 ; y ++) {
if (x == y) {
continue point ; //循环结束
}
System.out.print(x + "、") ;
}
System.out.println() ;
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
1、2、2、3、3、3、4、4、4、4、5、5、5、5、5、6、6、6、6、6、6、7、7、7、7、7、7、7、8、8、8、8、8、8、8、8、9、9、9、9、9、9、9、9、9、
解析：
当x=0，y=0，此时x与y相等，continue point ——> 执行point代码（进行x的下一个循环），所有结果中没有0出现
当x=1，y=0，此时x与y不等，System.out.print(x + "、") ——> 执行此代码后，结果：1、
接下来进行y的循环
当x=1，y=1，此时x与y相等，continue point ——> 执行point代码（进行x的下一个循环），所有结果中不会再出现第二个 1、
当x=2，y=0，此时x与y不等，System.out.print(x + "、") ——> 执行此代码后，结果：2、
接下来进行y的循环
当x=2，y=1，此时x与y不等，System.out.print(x + "、") ——> 执行此代码后，结果：2、
接下来继续y的循环
当x=2，y=2，此时x与y相等，continue point ——> 执行point代码（进行x的下一个循环），所有结果中不会再出现第三个 2、
... ...
依次进行下去
对于此类代码强烈不建议开发者在你的开发代码中出现。
只是部分的恢复了goto功能，但是这个功能是要结合continue去用的。不到万不得已 千万不要用，程序代码会非常混乱。
了解即可
public class JavaDemo {
public static void main(String args[]) {
point: for (int x = 0 ; x < 10 ; x ++) {
for (int y = 0 ; y < 3 ; y ++) {
if (x == 3) {
continue point ; //循环结束
}
System.out.print(x + "、") ;
}
System.out.println() ;
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
0、0、0、
1、1、1、
2、2、2、
4、4、4、
5、5、5、
6、6、6、
7、7、7、
8、8、8、
9、9、9、
把上述代码 (int y = 0 ; y < 3 ; y ++) 中的"y < 3"换成"y<10"，执行代码：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
0、0、0、0、0、0、0、0、0、0、
1、1、1、1、1、1、1、1、1、1、
2、2、2、2、2、2、2、2、2、2、
4、4、4、4、4、4、4、4、4、4、
5、5、5、5、5、5、5、5、5、5、
6、6、6、6、6、6、6、6、6、6、
7、7、7、7、7、7、7、7、7、7、
8、8、8、8、8、8、8、8、8、8、
9、9、9、9、9、9、9、9、9、9、
循环嵌套
在一个循环语句中嵌套其它的循环语句就称为循环嵌套处理，循环嵌套层次越多时间复杂度就越高，那么下面通过循环的嵌套观察两个简单的程序。
范例：打印乘法口诀表
y*x=...
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
随着x的增加，y才会增加，所以y应该受到x的控制
public class JavaDemo {
public static void main(String args[]) {
for (int x = 1 ; x <= 9 ; x++) { // 口诀表最多9行
for (int y = 1 ; y <= x ; y++) { // 为什么y要小于等于x，因为y应该受到x的限制，才会呈现乘法表的形状
System.out.print(y + "*" + x + "=" + (x * y) + "\t") ;
}
System.out.println() ; // 换行
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
-----------------------------------------------------------------------
把上述代码 (int y = 1 ; y <= x ; y++) 中的 y<=x 换成 y<=9，执行代码：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
1*1=1 2*1=2 3*1=3 4*1=4 5*1=5 6*1=6 7*1=7 8*1=8 9*1=9
1*2=2 2*2=4 3*2=6 4*2=8 5*2=10 6*2=12 7*2=14 8*2=16 9*2=18
1*3=3 2*3=6 3*3=9 4*3=12 5*3=15 6*3=18 7*3=21 8*3=24 9*3=27
1*4=4 2*4=8 3*4=12 4*4=16 5*4=20 6*4=24 7*4=28 8*4=32 9*4=36
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 6*5=30 7*5=35 8*5=40 9*5=45
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 7*6=42 8*6=48 9*6=54
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 8*7=56 9*7=63
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 9*8=72
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
其中 1*2 和 2*1 这种类似情况重复了，所以乘法表中y要受到x的控制。
范例：打印三角形
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
行数增加，星数也增加
每个星后面都有一个空格
把星前面的输出当做空格，会发现：行数增加的同时，空格在减少
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(" ") ; // 随着x的增加，y再减小，即：输出的空格数在减小
}
for (int y = 0 ; y <= x ; y ++) {
System.out.print("* ") ; // 随着x的增加，y也增加，即：输出*数在增加；每个*后面有一个空格
}
System.out.println() ;
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
*
* *
* * *
* * * *
* * * * *
这些是留给你上学时做的程序逻辑的训练。跟我们开发的紧密程度不大，一般不会写太复杂的代码。有时候可能需要，出现应届生考题。
