第三章:流程控制语句

程序结构
顺序结构
分支结构

if结构
if....else结构
if...else if....else if...else结构
switch结构

循环结构

while循环
do....while循环
for循环

分支结构
if结构

if结构语法:

if(布尔表达式){
//语句;
}

执行过程:如果布尔表达式为true执行其下语句，布尔表达式为false时不执行其下语句。
{}可以省略，如果省略将执行第一个语句块。为了程序的可读性推荐不要省略{}

if...else结构

语法:
if(布尔表达式){
//语句1
}else{
//语句2;
}

执行过程:如果布尔表达式值为true,执行语句1,否则执行语句2.
{}也是可以省略的，省略之后只执行第一个语句块。

if....else if....else结构

语法:
if(条件1){
//语句1;
}else if(条件2){
//语句2;
}else if(条件3){
//语句3
}....{
}else{
//语句N;
}
执行过程:先判断条件1是否成立,如果条件1成立执行语句1并跳出条件结构；如果条件1不成立继续判断其下的条件2,如果条件2成立执行语句2....，所有条件都不成立执行else中语句N.

注意:条件的位置有可能影响执行结构，条件位置一般需要满足从范围小的条件到范围大的条件逐次摆放。

switch结构

switch可以代替多重if条件结构中等值判断。
语法:
switch(表达式){
case 值1:
语句1;
[break];
case 值2:
语句2;
[break];
.....
default
语句N;
[break];
}

执行过程:将表达式的值与case中的常量值挨个进行比较，如果匹配成功将执行其下语句，直到遇到break关键字跳出switch结构。
注意:
1.swtich中传入的表达式可以是byte,short,int,char,从JDK1.7以后支持String类型
2. case后的常量值不能重复
3.case语句中的break是可以省略的，但如果省略break将出现case穿透。
4. default语句也是可以省略的。

循环结构
while循环

语法:
while(布尔表达式){
//循环体
}

执行过程:
步骤1:先判断布尔表达式值是否为true，如果为true进入步骤2
步骤2:执行while中循环体，执行结束后回到步骤1

特点:先判断，后执行，有可能一次都不执行。

do...while循环

语法:
do{
//循环体;
}while(布尔表达式);
执行过程
步骤1:先执行循环体，进入步骤2
步骤2:判断布尔表达式是否为true,如果值为true，执行步骤1，否则退出循环。
特点:先执行，后判断。执行会执行1次。

for循环

语法:
for(表达式1;表达式2;表达式3){
//循环体;
}
表达式1:循环变量的初始化，只会执行1次
表达式2:循环条件
表达式3：更改循环变量(步进)
注意:从语法的角度上说表达式1，表达式2，表达式3都可以省略，分号不能省略。但是如果省略了表达式2和表达式3经常会造成死循环。

执行过程:
步骤1：先执行表达式1进行循环变量的初始化工作
步骤2:执行表达式2进行循环条件的判断，如果条件为true,执行步骤3，否则退出循环。
步骤3:执行循环体;
步骤4:执行表达式3进行更改循环变量，然后执行步骤2。

break关键字

break关键字
可以用于switch结构和循环结构
作用:
1.如果用于switch结构，跳出当前的case语句
2.如果用于循环结构中，跳出当前循环结构。

continue关键字

continue关键字只能用于循环结构。
作用:跳过本次循环，重新开始下一趟循环。

循环嵌套

一个循环结构中嵌套了其他的循环结构。
特点:只有当内层循环结束后，才会执行下一次的外层循环（外层循环一次，内层循环可能循环多次）。

矩形

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

直角三角形

***
**
*

平行四边形

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

正等腰三角形

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

倒等腰三角形

*****
***
*

菱形

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

百元百鸡

公鸡5元/只,母鸡3元/只,小鸡1元3只，问100元买100只鸡如果购买?

斐波那契数列

兔子问题:
1对兔子，从第三个月开始每个月可以生一对小兔子，小兔子从三个月开始每个月也可以再生一对小兔子，假设兔子不死，问1年后共多少对兔子？
斐波那契数列:
1 1 2 3 5 8 13....

f(n)=f(n-1)+f(n-2)
n>=3

九九乘法表

1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
....

更改循环结构的三个关键字
break

break在循环嵌套中使用，可以跳出当前循环结构。
continue

continue用于跳过本次循环，从新开始下一趟循环。
return

严格意义上不是专门为更改循环结构而设计的，它的主要结构是退出当前方法(函数)

方法
方法的定义

方法:为了完成某些功能而封装了某些代码的集合。
方法的定义:
[修饰符] 返回值类型 方法名(形参列表){
方法体;
return 返回值;
}
修饰符:封装时会详细介绍，今天代码的修饰符:public static
返回值类型:如果有返回值，其返回值类型可以是任何类型，如果没有返回值，可以定义为void
是否需要返回值的判断依据:其他方法是否需要使用当前方法的处理结果。
如果其他方法需要使用当前方法的处理结果，需要返回值，否则可以不要返回值
方法名:满足标识符的命名规则
参数列表:可以有参数，也可以没有参数。
是否需要参数的判断依据:当前方法是否需要使用其他的方法中的值。
如果当前方法需要使用其他方法的值，需要以参数的方式进行传入，否则可以不要参数
返回值:java中返回值只有1个，其类型必须与返回值类型向对应。
参数:
形式参数:在方法定义时，用于限制该方法需要的参数的类型和个数。(int rows,int cols)
实际参数:在方法调用时，具体传入的值。(5,10)
注意:在方法调用时,实际参数的类型和个数必须与形式参数相对应。

方法的调用:
情况1:如果在同一个类中，直接使用方法名就可以调用。printRectangle();
情况2:通用的静态方法的调用方式: 类名.方法名(); TestMethod.printRectangle();
public class TestMethod{

//无参数，无返回值
public static void printRectangle(){
for(int i=0;i<3;i++){
for(int j=0;j<8;j++){
System.out.print("*");
}
System.out.println();//换行
}
}
//有参数,无返回值
public static void printRectangle2(int rows,int cols){
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
System.out.print("*");
}
System.out.println();
}
}
//无参数,有返回值
public static double calcArea(){
int r=2;//半径
final double PI=3.14;
double s = PI*r*r;
return s;//返回值
}
//有参数,有返回值
public static double calcArea2(int r){
final double PI=3.14;
double s = PI*r*r;
return s;
}

public static void main(String[] args){
//printRectangle();
//TestMethod.printRectangle(); //无参数,无返回值
//TestMethod.printRectangle2(15,10);//有参数,无返回值
//double s = TestMethod.calcArea();//无参数,有返回值
double s = TestMethod.calcArea2(4);//有参数,有返回值
System.out.println("圆的面积为:"+s);

}
}

方法的重载

方法的重载:在同一个类中，方法名参数列表不同。
参数列表不同：
1.个数不同
2.类型不同
3.顺序不同
在方法调用时，会根据参数的类型，个数和顺序自动匹配到响应的方法
public class TestMethod2{

public static int add(int a,int b){
return a+b;
}

public static double add(int a,double b){
return a+b;
}
public static double add(double a,int b){
return a+b;
}
public static double add(double a,double b){
return a+b;
}

public static void main(String[] args){
double result = TestMethod2.add(1.0,2.0);
System.out.println("result="+result);
}
}

递归

递归:在程序中方法(函数)自身调用自身的一种行为。
使用场景:将一个复杂的问题可以分解为若干子问题，每个子问题的解决方案与上一层一致。
编写递归时需要注意:递归的条件和递归体
递归条件:类似于循环条件，做什么时候为止不再调用自身，如果缺少条件将会造成死循环。
递归体:类似于循环体，重复做的事情。

递归的优点:编写简单，更加贴近人类的思维习惯。
递归的缺点: 1.大量占用系统堆栈，对内存的消耗较大。
2.递归调用耗时较长。
注意:所有利用递归解决的问题都可以使用循环(迭代)解决；不推荐过多使用递归，应为递归既耗时又耗用资源。

public class TestMethod3{

//计算N的阶乘
public static long factorial(int n){
if(n==1){
return 1;
}else{
return n*factorial(n-1);
}
}
//斐波那契数列:f(n)=f(n-1)+f(n-2)
public static long fibonacci(int n){
if(n==1||n==2){
return 1;
}else{
return fibonacci(n-1)+fibonacci(n-2);
}
}

public static void main(String[] args){
//long result = factorial(5);
long result = fibonacci(12);
System.out.println("result="+result);
}
}

第三章：流程控制语句