3.0 java的流程控制语句
流程控制语句是用来控制程序中各语句执行顺序的语句
控制语句分为三种: 顺序、选择、循环。
"循环结构"代表先执行a，在执行b的逻辑。eg:网上买东西，先看商品，再付款。
“选择语句"代表如果....,则......的逻辑。 eg:如果看到红的就要停车。
"循环结构"代表如果....,则在继续......的逻辑。eg: 如果允许一直在操场上跑步，则可以持续的跑下去。
3.1选择结构
选择结构分为以下四种：
1.if单选择结构
2.if-else双选择结构
3.if-else if-else多选择结构
4.switch结构
3.1.1 if单选择结构 ###
语法结构：
if(布尔表达式){
java语句块;
}
if语句对布尔表达式进行一次判断，若判断为真，则执行括号内的语句块，否则跳过该语句块。流程如下图所示：
【示例】if单选择结构
public static void main(String[] args) {
double d1 = Math.random();
System.out.println(d1);
int i = (int)(6*Math.random() + 1);
//第一种写法
if(i <= 3){
System.out.println("小");
}
//第二种写法，不推荐使用
if(i >= 4)
System.out.println("大");
}
大
注解说明：Math.random()该方法用于产生一个0到1区间的double类型的随机数 [0,1)
3.1.2 if-else双选择结构
语法结构:
if(布尔表达式){
java语句块1；
}else{
java语句块2；
}
当布尔表达式为真时，执行语句块1，否则，执行语句块2,。也就是else部分，流程图如下所示：
【示例】if-else结构
public static void main(String[] args){
//随机产生[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长
double d1 = 4 * Math.random();
double area = Math.pow(d1, 2) * Math.PI;
double circle = Math.PI * 2 * d1;
System.out.println("半径为： "+d1);
System.out.println("面积为: "+area);
System.out.println("周长伟："+circle);
if(area >= circle){
System.out.println("面积大于或等于周长");
}else{
System.out.println("周长小于面积");
}
}
半径为： 2.089136450893916
面积为: 13.711453209259073
周长伟：13.126431452949959
面积大于或等于周长
条件运算符有时候可用于代替if-else，如示例二与示例三所示。
【示例二】if-else结构
public class Test3 {
public static void main(String[] args) {
int a=2;
int b=3;
if (a
System.out.println(a);
} else {
System.out.println(b);
}
}
}
2
【示例三】使用条件运算符
public class Test4 {
public static void main(String[] args) {
int a=2;
int b=3;
System.out.println((a
}
}
2
3.1.3 if-else if-else多选择结构
语法结构：
if(布尔表示式1){
java语句块1;
}else if(){
java语句块2;
}.....
else if(){
java语句块n;
}else{
java语句块 n+1;
}
当布尔表达式1为真时，执行语句块1;否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2;否则，继续判断布尔表达式3······;如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。流程图如下图所示。
【示例】if-else if-else多选择结构
public static void main(String[] args){
int score = (int)(100*Math.random())+1;
if(score >= 85){
System.out.println("等级A");
}else if(score >= 70 && score <= 84){
System.out.println("等级B");
}else if(score >= 60 && score <= 69){
System.out.println("等级c");
}else{
System.out.println("等级D");
}
}
等级D
3.1.4 switch多选择语句
语法结构:
switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
语句序列2;
[break];
… … … … …
[default:
默认语句;]
}
switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。
根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。
当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。
switch多选择结构的流程图如下图所示。
【示例一】switch多选择语句 -->int
public static void main(String[] args) {
int month = (int)(Math.random()*12 + 1);
System.out.println("月份:" + month);
switch(month){
case 1:
System.out.println("一月份，快过年了!");
break;
//当break不写时，会一直往下执行，直到碰到下一个break或者进入了default中，直接出去了
case 2:
System.out.println("二月份，过年了!");
break;
default :
System.out.println("其它月份");
break;
}
}
月份:8
其它月份
【示例二】switch多选择语句 -->char
public static void fun(){
char x = 100;
switch(x){
case 100:
System.out.println("One Hundred");
break;
case 200:
System.out.println("Two Hundred");
break;
case 300:
System.out.println("Three Hundred");
break;
default:
System.out.println("defult");
}
}
【示例三】switch多选择语句-->字符串
public static void fun(){
String x = "100";
switch(x){
case "100":
System.out.println("One Hundred");
break;
case "200":
System.out.println("Two Hundred");
break;
case "300":
System.out.println("Three Hundred");
break;
default:
System.out.println("defult");
}
}
One Hundred
【示例四】switch多选择语句 -->不带break
public static void show(){
char c = 'a';
int read = (int)(26*Math.random());
char c2 = (char) (c+read);
System.out.print(c2+": ");
switch(c2){
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
System.out.println("元音字母");
break;
case 'y':
case 'w':
System.out.println("半元音字母");
break;
default :
System.out.println("辅音字母");
}
}
z: 辅音字母
3.2 java 循环结构
循环结构分两大类，一类是当型，一类是直到型。
当型： 当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。
直到型：
先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。
3.2.1 while循环
语法结构：
while(布尔表达式){
循环体；
}
在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。
while循环结构流程图如下图所示。
【示例】while循环结构 求1到100的累加和
public static void main(String[] args){
//计算1+2+3+...+100
int i = 0;
int sum = 0;
while(i <= 100){
sum += i++;
}
System.out.println("sum: "+sum);
}
sum: 5050
这种写法就陷入了死循环，缺少是循环结束的语句
while(true){
循环体;
}
3.2.2 do- while循环
语法结构:
do{
循环体；
}while(布尔表达式);
do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如下所示。
【示例】do-while循环结构：1-100之间的累加和
public static void main(String[] args) {
int i = 0;
int sum = 0;
do {
sum += i; // sum = sum + i
i++;
} while (i <= 100);//此处的；不能省略
System.out.println("sum= " + sum);
}
sum=5050;
【示例】while与do-while的区别
//do-while和while的区别
public static void show(){
int a = 0;
//while循环 ，先判断在执行
while(a > 0){
System.out.println(a);
a++;
}
System.out.println("===========");
//do-while循环，先执行在判断
do{
System.out.println(a);
a++;
}while(a < 0);
}
===========
0
从运行结果可以看出do-while至少会执行一次；
3.2.3 for循环
语法结构：
for(初始表示式; 布尔表达式 ; 迭代因子 ){
循环体;
}
for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
A. 初始化部分设置循环变量的初值
B. 条件判断部分为任意布尔表达式
C. 迭代因子控制循环变量的增减
for循环在执行条件判定后，先执行的循环体部分，再执行步进。
for循环结构的流程图如下图所示。
【示例】for循环
public static void main(String[] args) {
//求1-100之间的累加和
int sum = 0;
//i变量的作用域，仅限于for内部
for(int i = 0; i <= 100; i++){
sum += i;
}
System.out.println(sum);
}
5050
执行步骤：
1.初始化变量
2.判断布尔表达式是否为真(true)
3.执行循环体;
4.for循环变量迭代
5.回到第二步，知道布尔表达式为false时，退出循环。
for循环中可以声明多个变量示例如下：
for(int i =1, j = 3; i < 5; i++, j *= 2){
System.out.println("i= " + i + " j= " + j);
}
for循环的无线循环
for( ; ; ){
循环体;
}
for循环中的变量的 作用域仅限于for内部
3.2.4 嵌套循环
示例：
ublic static void main(String[] args) {
for(int i = 1; i <= 5; i++){
for(int j = 1; j <= 5; j++){
System.out.print(i+"\t");
}
System.out.println();
}
}
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4
5 5 5 5 5
【示例】 使用嵌套循环打印九九乘法表
for(int i = 1; i <= 9; i++){
for(int j = 1; j <= i; j++){
System.out.print(j +"*"+ i +"="+ i*j +" ");
}
System.out.println();
}
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
3.2.5 break语句和continue语句
break用于强行退出循环，不执行循环中剩余的语句。
示例：
public static void main(String[] args){
int total = 0;
System.out.println("Begin");
while(true){
total++;
int i = (int)(Math.random()*100)+1;
System.out.println(i);
if(i == 88){
break;
}
}
System.out.println("Game over， used " + total + " times.");
System.out.println("======================================");
}
当i的值为88时，if语句成立，break触发跳出for循环。
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
示例：把100~150之间不能被3整除的数输出，并且每行输出5个
方式一：使用continue
//定义一个计数器
int count = 0;
for(int i = 100; i <= 150; i++){
if(i % 3 == 0){
continue;
}
System.out.print(i + "、");
count++;
//根据计数器判断每行是否已经输出了5个数
if(count % 5 == 0){
System.out.println();
}
}
100、101、103、104、106、
107、109、110、112、113、
115、116、118、119、121、
122、124、125、127、128、
130、131、133、134、136、
137、139、140、142、143、
145、146、148、149、
不使用continue
public static void show2(){
int count = 0;
for(int i = 100; i <= 150; i++){
if(i % 3 != 0){
count++;
System.out.print(i +"、");
}
if(count/5 == 1){
count = 0;
System.out.println();
}
}
}
100、101、103、104、106、
107、109、110、112、113、
115、116、118、119、121、
122、124、125、127、128、
130、131、133、134、136、
137、139、140、142、143、
145、146、148、149、
3.2.6 java带标签的break和continue
示例：控制嵌套循环跳转(打印101-150之间所有的质数)
质数：只有1和本身可以被除尽.
outer：
for(int i = 101; i <= 150; i++){
for(int j = 2; j < i /2; j++){// i/2，操作被除数的一半必然除不尽
if( i% j == 0){
continue outer;
}
}
System.out.println(i +" ");
}
101 103 107 109 113 127 131 137 139 149
3.3 java 语句块
语句块：是用花括号扩起的任意数量的简单Java语句。
语句块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。
【示例】语句块
public static void main(String[] args){
int n ;
int i;
{
int k;
int n;//不能重复定义变量n
}//变量K的作用域到此为止
}
3.4 java 中的方法
定义： 方法就是一段来完成特定功能的代码片段，类似于c语言中的函数。
方法的声明格式：
[修饰符1 修饰符2 ....] 返回值类型 方法名 (形式参数){
Java代码片段;
}
【示例】方法的声明及调用
/** main方法：程序的入口 */
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
//调用求和的方法：将num1与num2的值传给add方法中的n1与n2
// 求完和后将结果返回，用sum接收结果
int sum = add(num1, num2);
System.out.println("sum = " + sum);//输出：sum = 30
//调用打印的方法：该方法没有返回值
print();
}
/** 求和的方法 */
public static int add(int n1, int n2) {
int sum = n1 + n2;
return sum;//使用return返回计算的结果
}
/** 打印的方法 */
public static void print() {
System.out.println("方法的声明及调用");
}
sum = 30
方法的声明及调用
3.5 java中 方法的重载
方法的重载是指在一个类中可以定义多个方法名相同，但参数不同的方法。调用时系统会自动根据参数自动匹配对应的方法。
构成重载方法的条件： 1.方法名相同 2.在1的基础之上，参数的个数、类型、顺序不同(前提参数的类型不是相同的，)。
示例：
public void add(int a, int b){
}
public void add(int a, int b, int c){
}
public void add(double a, int b){
}
//较上一个方法，两者的参数顺序不同也构成重载
public void add(int a, double b){
}
误区： public void add(int a, int b){
}
public void add(int b, int a){
}
这种不属于方法的重载，本质上就是同一个方法。只是参数名不同而已。
3.6 java中的递归函数
递归的基本思想就是“自己调用自己”， 一个使用递归技术的方法将会直接或者间接的调用自己。
递归的结构：
定义递归头：如果没有头将陷入死循环，它是递归结束的条件。
递归体：什么时候调用自身的方法
示例：计算10的阶乘 10！= 1098765432*1
public int factorial(int n){
//递归头
if( n == 1){
return 1;
}else{
//递归体
return n * factorial(n -1);
}
}
3628800
factorial(10)
10 + factorial(9)--> 10! = 10 * 9!
9 + factorial(8)--> 9! = 9 * 8!
8 + factorial(7)--> 8! = 8 * 7!
7 + factorial(6)--> 7! = 7 * 6！
6 + factorial(5)--> 6! = 6 *5!
5 + factorial(4)--> 5! = 5 * 4!
4 + factorial(3)--> 4! = 4 * 3!
3 + factorial(2)--> 3! = 3 * 2!
2 + factorial(1)--> 2! =2 * 1！
factorial(1)--> 1! = 1
然后把值依次向上一级返回。
注意：递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。
使用for循环求n！
public int show(int n){
int result = 0;
for(int i = n; i >= 1; i++){
result *= i;
}
System.out.println(result)
}
show(10); --> 3628800
使用while循环求n!
//使用while循环来求10！
public static void b(int b){
int a = 10;
int result = 1;
while(a > 1){
result *= a ;
a -= 1;
}
System.out.println(result);
}
b(10); -->3628800
2108
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
