--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------
0 小小论述：
流程控制语句非常的重要本篇博文笔记记录的括条件语句、循环语句、中断与继续语句、分支语句和返回语句。越往后知识越加重要也会有些难度，就需要更加努力。“没有人比你更聪明，只有人比你更努力。”这句话一直是我的学习格言。相信自己，只有努力才有收获。
1 条件语句：
@条件语句：表达意思是：
如果……就……否则……语句表现为：if（条件）{目的1；} else {目的2；}
最简单的是只有一个if： if(条件) 目的；
还有另一种是多个if else的：
if(条件1)
{目的1；}
esle if(条件2)
{目的2；}
else if(条件3)
{目的3；}
else
目的4；
if条件语句特点：
1 每一种格式都是单条语句
2 if else 格式与三元运算符的区别在于，三元运算符运算完成后要有值出现，也就相当于有返回值，所以：可以用在其他表达式中，这也是其好处。
3 if 语句的条件表达式无论写成什么样子，只看最终的结果：true或者false。
2 循环语句 ：
当需要反复执行同样的动作时要用到循环语句。循环语句有三种：for循环、while循环和do…while循环。
for循环格式：for(初始化表达式；判断表达式；变量表达式){ 执行语句；}
while语句格式：while(条件){目的1；目的2；...}
do...while循环语句格式：do{目的；}while(条件);
以上知识点用代码演示，示例代码：
- class Circle_1
- {
- public static void main(String[] args)
- {
- //if语句
- if(1==2)
- System.out.println("if语句：YES");
- else
- System.out.println("if语句：NO");
- //for 循环
- for(int x=0;x<3;x++)
- {
- System.out.println("for循环语句：x="+x);
- }
- //while循环
- boolean flag=true;
- while(flag)
- {
- for(int x=3;x>0;x--)
- {
- System.out.println("while循环语句：x="+x);
- }
- flag=false;
- }
- //do...while循环语句
- boolean flag1=true;
- do
- {
- for(int x=3;x>0;x--)
- {
- System.out.println("do...while循环语句："+x);
- }
- flag1=false;
- }
- while (flag1);
- }
- }
- /*
- if语句：NO
- for循环语句：x=0
- for循环语句：x=1
- for循环语句：x=2
- while循环语句：x=3
- while循环语句：x=2
- while循环语句：x=1
- do...while循环语句：3
- do...while循环语句：2
- do...while循环语句：1
- */
for循环的使用非常的广泛，可以使用for的嵌套循环，执行一些相对比较复杂的操作。for(int x=0;x<3;x++)循环里面定义的变量为局部的临时变量，作用范围是for循环，出了for循环就无效。这时和while循环不同的地方。
注意：
1 for循环里面的初始化循环只执行一次；条件表达式为真就执行循环体，然后再执行循环后的表达式。接着再判断循环条件，重复这个过程，知道条件不满足为止。
2 while 可以和 for 进行互换，区别在于，for为了循环而定义的变量在for循环结束就在内存中释放。而while使用的变量，在循环结束后还可以就使用。
3 最简单无限循环： while（true），for（；；） 寻仙循环的原因并不知道循环多少次，而是根据某些条件，来控制循环。
4 C++中允许数值做boolean值用，0为false，非0为true，在java中是不可以的
。
■注意：
如果循环次数已知且固定，那么用for循环，否则用while循环（利用判断是否满足的条件）
for循环的嵌套循环是经常用到的，最经典的一个例子就是输出99乘法表，也是要多加练习和理解记忆的。下面是99乘法表的练习示例代码：
class MulForm
{
public static void main(String[] args)
{
print99(9);
print99(6);
}
public static void print99(int n)
{
for (int x=1;x<=n ;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(x+"*"+y+"="+x*y+"\t");
}
System.out.println();
}
}
}打印结果：
1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
3中断和继续语句：中断语句只有一个关键字"break"。读到它时就跳出所在的循环。continue语句表示跳出当前循环，再继续下一轮循环。
break（跳出），continue（继续）
break 作用于 选择结构（switch） 和 循环结构（while）。
continue 作用于 循环结构（while）。
注意：
1 这两个语句离开应用范围存在时没有意义的、
2 这两个语句单独存在时，下面都可以有语句，因为执行不到其他语句。
3 continue是结束本次循环 继续下次循环。
4 标号的出现，可以让这两个语句作用于指定的范围。
for(int i=1;i<5;i++)
{
break;//换成continue；也是一样的；
System.out.println(i);
}
编译失败，System.out.println(i);为无法执行到 的语句，那么这个语句就是"废话"。java中不允许存在废语句
4分支语句：分置于句很好理解，格式：
switch(整数因子)
{
case 整数值1：语句； break；//break是可选语句；
case 整数值1：语句； break；
case 整数值1：语句； break；
……
default：语句；//default是默认语句；
}
switch语句特点：
1 其选择的类型只有四种：byte short char int ，即int兼容型的。注意：char ch='';里面什么没有是错误的，有空格是可以的。
2 case 之间与 default 没有顺序，先执行第一个case，没有匹配的case再去执行 default ，但是为了增强代码的可读性，会将default放在代码的后面。
3 结束 switch 的两种情况：a.遇到break语句；b.执行到switch语句结束。
4 如果匹配的 case 或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
5 case与判断表达式相匹配，类型要一致。
eg：byte b=2;
switch(b)
{
case 2: System.out.println("这是2");
break；
case 128: System.out.println("这是128");
break;
}
程序会编译失败，在编译时期就会出现错误，虽然第一个满足了条件，但是128超出了byte类型的取值范围。
6 case 后的表达式必须是常量值，必须由字面常量与final修饰的变量组成。其他的是错误的。
7 case 后的值不能重复，case 后的值不能相同。否则出错。虽然逻辑也严密，但是编译出错，不符合语法要求，出现重复case值的情况错误。
8 在JDK1.7中表达式的类型增加了String类型。
5 方法部分：
java中函数称为方法。方法是为了更方便的实现某一功能的一个具有独立功能的整体，使用方法可以大大减少代码的书写，可以重复利用某一方法达到减少代码的目的。并且提高了阅读性。方法是对重复代码进行不断抽取的结果，提高代码的复用性。
@标准的函数定义格式：
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句；
return 返回值；
}
解析：
*返回值类型：函数运行后的结果的数据类型。
*参数类型：是形式参数的数据类型。
*形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
*实际参数：传递给形式参数的具体数值。
*return：用于结束函数。
*返回值：该值会返回给调用者。
示例代码：
- class Function
- {
- publicstaticvoid main(String[] args)
- {
- int y=getSum(5);//调用getSum()方法；
- System.out.println(y);
- }
- //定义求和函数
- publicstaticint getSum(int x)
- {
- return x+10;
- }
- }
定义了一个求和功能简单函数，返回值类型为int，形式参数类型为int，传入的实际参数为 5，return语句返回x+10即5+10 这个结果给函数getSum()，其返回值类型和函数的类型相匹配，再由主函数中的标准输出函数输出打印出来。方法getSum()定义在main()方法前面，并不会先执行getSum()方法，而是先执行main()方法，main()方法是程序的入口。
函数的特点：
*定义函数可以将功能代码进行封装。
*便于对该功能记性复用
*函数只有被调用才会被执行。
*函数的出现提高了代码的复用性。
*当函数没有返回值时，函数类型就是void，并且return语句可以省略。
应用函数时应明确两点:
1.明确要定义的功能最后的结果是什么,是否有返回值
2.明确在定义该功能的过程中，是否需要未知内容参与运算,确定参数列表
函数的重载:在同一个类中,可以出现同名的函数,只要函数的参数列表不同就可以.
函数重载的特点:与返回值无关,只看参数列表.
重载的应用条件:当实现某些功能时,功能的主体是一致的,但是功能的实现细节有所区别,这个时候可以考虑函数的重载.
值得注意1：
函数中只能调用函数，不能在函数中再定义函数；定义函数时，函数的结果应该返回给调用者，交由调用者处理。
@怎么定义一个方法呢？
有一个正确的思路对于定义方法来说是非常重要的。有一定的步骤那就会简单化。
*想到方法的功能后，要明确方法运算后的结果是什么。这是在明确函数的返回值类型。
*再明确该方法是否需要外部数据内容参与运算，如需要传入参数。要么方法独立完成功能，不要外部数据参与，要么需要调用者给方法传入参数才能完成。这是在明确函数的参数列表（包括类型和个数）。
如要实现两个数的和。1.实现10+12。2.实现两个未知整数相加。简单地实现代码，仅方法体:
- 1.publicstaticint Sum1（）//明确方法为int 型的结果，并且不需要参数
- {
- return10+12；//将运算结果返回给方法Sum1
- }
- 2.publicstaticint Sum2(int x,int y)//明确方法为int结果，需要调用者传入参数
- {
- return x+y;//将x+y的运算结果返回给方法Sum2
- }
1和2 分别对应上面的情况。方法Sum1毫无扩展性可言；Sum2方法可以实现任意两个int型整数的和，功能就被扩展了。明确好这些之后再去定义方法就会简单一些，思路会更清晰。
@函数的重载（overload）：函数的重载是个非常重要的二部分，首先明确什么是函数重载。函数重载是指在同一个类中允许存在一个以上的同名函数，只要他们的参数个数或参数类型不同即可。 函数之间的区与其返回值类型无关，只于参数列表有关。重载有很大的好处，方便与阅读，优化程序设计。
如要定义方法，获取几个数据的和。要求有两个数的和，有三个数的和，有求两个字符串的和的方法。代码示例：
- <span style="color: rgb(51, 0, 0);"><span style="font-size:14px;">class AddFun
- {
- publicstaticvoid main(String[] args)
- {
- double sum1=add(10,21);
- System.out.println("和："+sum1);
- double sum2=add(10,21,32);
- System.out.println("和："+sum2);
- String sum3=add("你","好");
- System.out.println("字符串和："+sum3);
- }
- //两个数相加
- publicstaticdouble add(double x,double y)
- {
- return x+y;
- }
- //三个数相加
- publicstaticdouble add(double x,double y,double z)
- {
- return add(double x,double y)+z;//方法内调用方法
- }
- //字符串相加
- publicstatic String add(String x,String y )
- {
- return x+y;
- }
- }</span></span>
方法演示很简单，方法名一样，类型可以不一样，但是方法返回值类型不是区分重载方法的标识，其参数列表才是区分重载的标识，参数数量不一样，参数类型不一样的同名方法才是重载方法。
6 返回语句 ：
返回语句只有一个关键字"return"组成。在函数中最常用到，返回函数运算后的结果。
以上几点用简单代码演示，示例代码：
- class Circle_2
- {
- public static void main(String[] args)
- {
- int n=8;
- //分支语句
- switch (n)
- {
- case 2:System.out.println("输出2");
- case 4:System.out.println("输出4");
- case 6:System.out.println("输出6");
- case 8:System.out.println("吉利的数字8");break;
- }
- //break语句
- boolean flag=true;
- while(flag)
- {
- for(int x=0;x<3;x++)
- {
- System.out.println("执行几次呢？：一次");
- break;//执行一次就跳出循环
- }
- flag=false;
- }
- //调用返回语句函数，执行返回语句
- String str=returnString();
- System.out.println(str);
- }
- //返回语句
- public static String returnString()
- {
- return "终于执行完了！";
- }
- }
- /*
- 执行结果：
- 吉利的数字8
- 执行几次呢？：一次
- 终于执行完了！
- */
本篇博文结束！
@感谢老师的辛苦批阅
44万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
