JavaSE–流程控制&函数
一、三元运算符
三元运算符，也称为三目运算符或问号冒号运算符。即有三个表达式参与的运算表达式。既然是个运算符，那么运算完必须有运算结果。
1、三元运算符格式
条件表达式?表达式1：表达式2
2、运算原则
- 条件表达式 运算结果必须为
boolean类型的值。 - 当 条件表达式 的值是
true时，表达式1结果就是三元运算符的结果。 - 当 条件表达式 的值是
false时，表达式2结果就是三元运算符的结果。
表达式1&表达式2 返回数据的语句。
3、举例
class OperateDemo
{
public static void main(String[] args)
{
int x = 3 ;
int y ;
y = x < 10 ? 100 : 200;
System.out.println("y="+y);
}
}
注意：表达式1&表达式2 当需要存储于变量时，需要类型相同。三元运算符的结果直接使用时，不要求类型一致。
System.out.println((target == 12)?true:0);
使用三元运算符求两个数的最大值：
class OperateDemo
{
public static void main(String[] args)
{
int a = 3 ;
int b = 5 ;
int max ;
max = a < b ? b : a;
System.out.println("max="+max);
}
}
思考：如何使用三元运算如何求三个数的最大值（最小值）。
// 三个数字作比较
int x = 14, y = 65, z = 37;
int max1;// O(1)
max1 = x > y? x : y;
max1 = max1 > z? max1 : z;
System.out.println("较大值："+max1);
二、流程控制&顺序结构
程序的流程 即就是 代码的执行顺序。 分为循环和判断两个方面。
class Demo
{
public static void main(String[] args)
{
int a = 3 ;
int b = 5 ;
int sum ;
sum = a + b;
System.out.println("sum="+sum);
}
}
上述代码当在dos命令行中写入java Demo 回车之后，首先会启动JVM，JVM就会去加载当前Demo这个class文件，并执行其中的main方法。当程序执行main方法的时候会从第一行开始往下执行，直到整个代码全部执行完成。在此过程中程序按照书写的顺序，不会跳过任何一行代码。像这样的执行流程就是常见的顺序执行结构。
三、判断结构(if)
if是Java中的关键字，当程序在执行过程遇到if关键字，JVM就知道此处需要进行判断，根据判断结果需要处理相应的代码。
1、第一种格式
if(条件表达式)
{
执行语句；
}
格式说明：if关键字后面是一对小括号，小括号后面是没有分号的，小括号中的表达式运算完的结果必须是boolean类型的值。
***if***流程控制执行顺序：JVM在执行代码时，遇到***if***关键字，首先会运算***if***括号中的表达式，当***if***中表达式的值为true时，就会执行***if***后面大括号中的语句。当***if***中表达式的值为false时，就会跳过***if***后面大括号中的语句，继续执行大括号下面的其他语句。
class IfDemo
{
public static void main(String[] args)
{
int y = 4;
if( y > 4)
{
System.out.println("y大于4");
}
System.out.println("over");
}
}
2、第二种格式
if(条件表达式)
{
执行语句；
}
else
{
执行语句；
}
执行说明：当if条件表达式为true时，执行if后面大括号中的语句，当if条件表达式为false时，执行else后面大括号中的语句。if-else格式组合成一条判断结构语句。要么执行if后面的语句，要么执行else后面的语句。切记，else后面的语句要能够执行，if中的条件表达式结果必须是false。
class IfDemo
{
public static void main(String[] args)
{
int y = 4;
if( y > 4)
{
System.out.println("y大于4");
}
else
{
System.out.println("y小于等于4");
}
System.out.println("over");
}
}
3、三元运算符的变形
通过三元运算可以简化if-else的操作
int a = 4 , b = 5;
int max;
if( a > b)
{
max = a;
}
else
{
max = b;
}
//可以使用三元运算简化：
max = a > b ? a : b;
三元运算符是简写的if-else格式，简写是有弊端：不是所有的if-else都能简化，三元运算符运算完必须有结果，而if-else不一定运算完一定有运算结果。
4、if判断第三种格式：
if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
代码演示：
class IfDemo
{
public static void main(String[] args)
{
int a = 3;
if( a > 1)
{
System.out.println("a");
}
else if( a > 2)
{
System.out.println("b");
}
else if( a > 3)
{
System.out.println("c");
}
else
{
System.out.println("d");
}
}
}
随堂练习：根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。
- 思路
- 怎么获取数值，并且保存这个值为变量，并且后续操作该变量。
- 输入的数值和星期联系起来，进行判断！
- 使用输出语句打印出结果
- 步骤
- 定义变量，记录数据。
- 通过判断结构语句
if对该变量进行判断。 - 根据不同的条件，通过输出语句显示不同的结果。
class IfTest
{
public static void main(String[] args)
{
//1，定义变量。记录数据。
int week = 9;
//2，通过判断结构语句if对该变量进行判断。
if(week == 1)
//3，根据不同的条件，通过输出语句显示不同的结果。
System.out.println(week+"对应的是星期一");
else if(week == 2)
System.out.println(week+"对应的是星期二");
else if(week == 3)
System.out.println(week+"对应的是星期三");
else if(week == 4)
System.out.println(week+"对应的是星期四");
else if(week == 5)
System.out.println(week+"对应的是星期五");
else if(week == 6)
System.out.println(week+"对应的是星期六");
else if(week == 7)
System.out.println(week+"对应的是星期日");
else
System.out.println(week+"没有对应的星期");
}
}
随堂练习：根据用户给定月份，显示季节
3,4,5 春季
6,7,8 夏季
9,10,11 秋季
12,1,2 冬季
四、多分支结构（switch）
1、switch 语句格式
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
...
default:
执行语句；
break；
}
程序执行时，遇到switch关键字，首先会计算表达式的值，然后根据计算的值和case后面的值做比较，当case后面的值和switch表达式的值相同时，就执行case身后的所有语句，若case身后没有和switch表达式匹配的值，程序就会执行default后面的语句。
2、代码演示
class SwitchDemo
{
public static void main(String[] args)
{
int x = 5;
switch(x){
case 5:
System.out.println("a");
break;
case 3:
System.out.println("b");
break;
default:
System.out.println("c");
break;
}
System.out.println("Hello World!");
}
}
3、switch语句特点
switch语句选择的类型只有四种：byte，short，int ， char。（java5之前）。还支持 enum(jdk5), String(jdk7)；
case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
结束switch语句的两种情况：遇到break，执行到switch语句结束。
如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
4、switch练习
修改上述 根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。
class SwitchTest
{
public static void main(String[] args)
{
int week = 9;
switch(week)
{
case 1:
System.out.println(week+"对应的是星期一");
break;
case 2:
System.out.println(week+"对应的是星期二");
break;
case 3:
System.out.println(week+"对应的是星期三");
break;
case 4:
System.out.println(week+"对应的是星期四");
break;
case 5:
System.out.println(week+"对应的是星期五");
break;
case 6:
System.out.println(week+"对应的是星期六");
break;
case 7:
System.out.println(week+"对应的是星期日");
break;
default:
System.out.println(week+"没有对应的星期");
break;
}
}
}
switch 根据月份判断季度
public static void main(String[] args) {
String moon = "小月";
switch(moon){
case "一月":
case "二月":
case "三月":
System.out.println("春");
break;
case "四月":
case "五月":
case "六月":
System.out.println("夏");
break;
case "七月":
case "八月":
case "九月":
System.out.println("秋");
break;
case "十月":
case "十一月":
case "十二月":
System.out.println("冬");
break;
default:
System.out.println("查询季度失败~~");
break;
}
}
使用switch结构将学生成绩划分为A(90 – 100)，B(80 – 89)，C(70 – 79)，D(60 – 69)，E(60分以下)五个等级。
public class Demo07 {
public static void main(String[] args) {
int res = 76;
switch(res/10){
case 10:
case 9:
System.out.println("成绩为: A");
break;
case 8:
System.out.println("成绩为: B");
break;
case 7:
System.out.println("成绩为: C");
break;
case 6:
System.out.println("成绩为: D");
break;
default:
System.out.println("成绩为: E");
break;
}
}
}
5、if和switch的区别
if可以用于判断数值，也可以判断区间，只要运算结果是boolean类型，都可以进行判断。
switch用于对固定的几个值，进行判断。判断的值的类型有限。
五、循环结构(while&do-while)
1、循环结构
根据程序的需求，可以将某些代码重复执行的操作。Java中的循环结构有如下三种：
-
while:事先不需要知道循环执行多少次；
-
do-while:同上，只是至少要执行一次(先做，后判断)；
-
for:需要知道循环次数；
2、 while循环
while(条件表达式)
{
执行语句；
}
while执行顺序：当程序遇到while关键字时，JVM首先会运算while后面的条件表达式，当条件表达式为true时，就会执行while后面大括号中的语句，当把大括号中的所有语句执行完之后，会又回到while的条件表达式处再次判断，若还为true，就继续执行大括号中的语句，若为false就跳过大括号中的所有语句，继续往下执行。
3、while代码举例
class WhileDemo
{
public static void main(String[] args)
{
int i = 1;
while( i < 10 )//这个程序是个死循环
{
System.out.println("i"+i);
}
System.out.println("over");
}
}
/*上述循环是个无限循环（也称为死循环），主要原因是i变量一直为1，每次判断i<10都成立，导致选好条件结束不了。程序永远卡在循环这个地方执行*/
public static void main(String[] args)
{
int i = 1;
while( i < 10 )
{
System.out.println("i"+i);
i++; // 让i不断的更新，最后使循环可以结束
}
System.out.println("over");
}
4、while练习
需求：
运算1-10的和。
思路：
1+2+3+4+…+10
每次加的和不确定。需要变量记录和值。
每次和值需要加的下一个数是确定的吗？不确定，需要变量。
求和和+下一个数在重复，说明需要执行多次，用循环。
下一个数，是有规律的。自增。
步骤：
1，定义变量。一个记录和，一个记录下一个数。
2，需要循环结构。
3，循环中需要进行和+下一个数的运算。并让下一个数自增。
//1，定义变量。一个记录和，一个记录下一个数。
int i = 1;
int sum = 0;
//2，需要循环结构。
while(i<=10)
{
//3，循环中需要进行和+下一个数的运算。并让下一个数自增。
sum = sum + i;
i++;
}
System.out.println("sum = "+sum);
5、while循环注意事项
- while循环的括号中的表达式计算结果必须为boolean类型的值。
- while循环的括号中不能直接写false常量。
- while循环的括号后面不要写分号，循环控制的语句的代码用大括号扩起来。
- while循环控制的条件变量一定要更新，保证循环能够正常结束。
6、do-while循环
do
{
执行语句；
}while(条件表达式);
执行顺序：先执行do后面的语句，当执行完之后再进入条件表达式进行判断，若条件表达式结果为true继续执行do后面的语句，若条件表达式结果为false，则结束循环。
do while特点是无论条件是否满足，循环体至少被执行一次。
7、while和do-while对比
以下两个程序的执行结果：
int x = 3;
while(x<3)
{
System.out.println("x="+x);
x++;
}
///
int y = 3;
do
{
System.out.println("y="+y);
y++;
}while (y<3);
随堂练习：1、获取1-100之间，6的倍数的个数。
六、循环结构(for)
1、for循环格式
for(初始化表达式（1）;循环条件表达式（2）;循环后的操作表达式（3）)
{
执行语句；（4）
}
执行顺序： for里面的3个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。编号表示：1》》》2》》》4》》》3·········2（当判断结果false时）。
2、for循环代码举例
class ForDemo
{
public static void main(String[] args)
{
for(int x= 1; x<3; x++)
{
System.out.println("x="+x);
}
}
}
3、for和while的区别
for(int x = 1; x<3; x++)
{
System.out.println("x="+x);
}
//System.out.println("x......"+x);
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
int y = 1;
while(y<3)
{
System.out.println("y="+y);
y++;
}
System.out.println("y....."+y);
while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
4、无限循环
最简单无限循环格式：while(true){} , for(；；){},无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
5、for循环练习
需求
获取1-100之间6的倍数的个数。
思路
- 个数是未知的，所以定义
变量。 - 6的倍数咋表示？只要是对6能整除，也就是没有余数。
- 需要对1-100之间所以的数都要进行判断是不是6的倍数。如果是，需要对个数变量进行
自增。 - 怎么完成1-100之间呢？使用循环。
步骤
- 定义变量，记录个数。记录1-100变化的数。
- 定义循环，遍历1-100。
- 在循环中对1-100的数字进行判断。
- 满足条件，个数变量自增。
class ForTest
{
public static void main(String[] args)
{
//1，定义变量，记录个数。
int count = 0;
for (int x = 1; x<=100 ; x++ )
{
//对数值进行判断，是否是6的倍数。
if(x % 6 == 0)
count++;
}
System.out.println("count="+count);
}
}
课后练习：1、需求：100 到200之间所有奇数的和；
七、嵌套循环
循环嵌套：其实就是在循环中还有循环。简称大圈套小圈
1、代码演示
class ForForDemo
{
public static void main(String[] args)
{
for (int x=0; x<3; x++)//行
{
for(int y=0; y<4; y++)//每一行的个数。
{
System.out.print("y="+y);
}
}
}
}
通过结果发现：在循环嵌套中，外循环执行一次，内循环要从头外尾执行完。
2、循环嵌套练习
需求
在屏幕上显示以下图形
*****
****
***
**
*
思路
- 看起图形，发现是由5行的组成。
- 每一行都有多个星。
- 有点意思，多行，循环就可以搞定。每到一行，里面有多个星。循环内，还需要循环负责每一行的星的个数。
- 外循环控制行数，内循环控制每一个行的个数。
class ForForTest
{
public static void main(String[] args)
{
//int z = 1;
for ( int x=1; x<=5 ; x++ )
{
for ( int y=x ; y<=5 ; y++)
{
System.out.print("&");
}
//z++;
System.out.println();
}
/*
*
**
***
****
*****
*/
for (int x=1; x<=5 ; x++)
{
for (int y=1 ;y<=x ;y++ )
{
System.out.print("*");
}
System.out.println();
}
}
}
空心菱形
/**
* 空心菱形
*/
public class Demo03 {
public static void main(String[] args) {
/**
* 上半部分 等腰三角 空心
* 下半部分 倒等腰三角 空心
*/
for (int i =6 ;i>=1;i--){
for (int j = 1;j<=11;j++){
if(i==j||j==12-i){
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println();
}
for (int i = 2;i<=6;i++){
for (int j = 1;j<=11;j++){
if(i==j||j==12-i){
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println();
}
}
}
八、流程控制(continue,break)
1、break语句、continue语句
break：终止该层循环；
continue：跳过该次循环
注意：
- 若这两个语句离开应用范围，存在是没有意义的。
- 这个两个语句单独存在后面都不能有语句，因为执行不到。
- continue语句是跳过本次循环，继续下次循环。
- 标签的出现，可以让这两个语句作用于指定的循环。
2、break语句 和 continue语句举例
break是终止循环，即在程序中遇到break，那么break所属的循环将结束。
for (int x=0; x<3 ;x++ )
{
if(x==1)
break;
System.out.println("x="+x);
}
continue是结束本次循环，继续下次循环。循环是不会结束的。
for (int x=0; x<10 ;x++ )
{
if(x%2==0)
continue;
System.out.println("x="+x);
}
3、使用循环标签
在多层嵌套循环中，终止/跳过标签标记的那层循环的执行；break <标签> 或 continue <标签>；
outer:for (int x=0; x<3 ;x++ )
{
inner:for (int y=0; y<4 ;y++ )
{
System.out.println("x="+x);
break outer;
}
}
///
outer:for (int x=0; x<3 ;x++ )
{
inner:for (int y=0; y<4 ;y++ )
{
System.out.println("x="+x);
continue outer;
}
}
九、函数的概念
1、什么是函数
函数就是定义在类中的具有特定功能的一段独立小程序，并能被多次使用。
站在代码复用的角度来考虑，之前的打印矩形问题。
问题：要画矩形，需要不断使用该for嵌套代码。造成代码复用性很差。
解决：定义一个功能用于画矩形，每次只要使用该功能即可。这样提高复用性。
定义一个功能：
- 应该是一个封闭的区间。那就需要使用大括号将其封装。
- 需要给这个区间起个名字。以后通过这个名字来调用这个区间
- 这个区间需要有参与运算的数据。
- 需要定义该功能的结果类型。
public static void draw(int row,int col)
{
for(int x=0; x<row; x++)
{
for(int y=0; y<col; y++)
{
System.out.print("*");
}
System.out.println();
}
//return;
}
2、函数定义格式
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句;
return 返回值;//return关键字是用于结束该功能。并将后面的具结果返回给调用者。
//必须有return语句。
}
注意：函数的返回值类型如果是void时，return语句可以省略不写；void表示的是没有返回值的情况。
3、如何定义函数
函数就是一个功能，功能就需要两部分：1、函数运行完的结果是什么；2、函数运行时有无未知参数。
定义函数时，时刻把握如下两个明确，基本就可以完成函数的定义：
这个功能的结果是什么？其实就是明确返回值类型。这个功能需要未知内容是什么？其实就是明确参数列表。
4、定义函数举例
需求：需要一个方法，进行加法运算，获取两个整数的和。
- 功能的结果是什么呢？是一个和。和是整数。返回值的类型是
int。 - 功能的未知内容有吗？有，加数和被加数。都是
int类型，这就是参数列表。
public static int add(int a,int b)
{
return a+b;
}
5、函数的执行过程
class MethodDemo
{
public static void main(String[] args)
{
int sum = getSum(3,4);
System.out.println("sum="+sum);
}
//定义功能求和
public static int getSum(int a , int b)
{
return a + b;
}
}
6、函数的内存加载
class MethodDemo
{
public static void main(String[] args)
int a = 3;
int b = 4;
int sum = getSum(a,b);
System.out.println("sum="+sum);
}
public static int getSum(int a , int b)
{
return a + b;
}
}
说明:
- 首先会加载main方法加载进栈内存中，并执行main方法中的代码，分别给a变量开辟空间并存放3，给b变量开辟空间存放4。
- 当程序执行到 int sum = getSum(a,b)时;会将getSum函数加载进栈内存中，同样在getSum所属的栈区域中开辟a和b变量空间，接受main方法中的getSum(a,b)传递的值。
- 然后执行getSum函数中的代码，当getSum函数执行结束后，函数会出栈（弹栈）。
- 程序回到main方法的调用语句int sum = getSum(a,b);处，并将getSum方法执行完返回的结果赋值给sum变量，程序继续往下执行。打印sum的值。
随堂练习：计算1-N(包含N)之间的所有能被3和7整除数之和。
十、函数的重载（名同参不同）
1、重载的引入
java为我们提供了重载这个功能，使用重载就可以解决某个功能不同场合的泛用性，一个函数的多个版本。
两个数相加，需要一个函数名字getSum，三个数相加需要一个函数名字getSum2，那如果有100个数相加，不是就需要getSum100了？那是不是在调用函数的时候还需要去记住哪个函数名对应多少个参数？这很显然是不可能的了。这个时候就要用重载。
2、重载的概念
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可，这时就形成了重载。重载和返回值类型无关。
3、重载的举例
完成任意乘法表打印
class MethodDemo3
{
public static void main(String[] args)
{
printCFB();
}
//打印标准九九乘法表。
public static void printCFB()
{
printCFB(9);
}
//打印任意乘法表。
public static void printCFB(int num)
{
for(int x=1; x<=num; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
4、重载的练习
以 void show(int a,float b,char c){} 为原函数，判断以下哪些函数重载了；
| 函数 | 判断结果 |
|---|---|
| int show(int x,float y,char z) | 没有重载，这个函数不允许和给定函数存在于同一个类中。因为会产生调用的不确定性。 |
| void show(float b,int a,char c) | 重载了，参数类型不同。 |
| void show(int c,float a,char b) | 没有重载，和给定函数一样。不允许存在。 |
| void show(int a,int b,int c) | 重载了，因为类型不同。 |
| double show() | 重载了，因为个数不同。 |
5、函数命名规范
在定义函数时，函数名不能使用关键字，第一个单词的首字母小写，采用驼峰式；由有实际意义的动词或动词短语。如：getSum。
public class Demo07 {
// 方法{}里的内容为方法体
public static int computer(int a,int b){
return a+b;
}
public static int computer(int a, int b ,int c){
return a+b+c;
}
public static double computer(double a, double b){
return a/b;
}
// public static double computer(double num01, double num02){
// return 0;
// } 函数的参数是一种形式参数
// public static int computer(double a, double b){
// return (int)a/b;
// }
public static void main(String[] args) {
computer(2.3,1.7); // JVM不知道调用结果的 如果重载跟返回值有关 调用时就会产生歧义
computer(1.0,2.0); // 参数名也是不会认为是参数列表的属性，名称只是形式，所以参数列表里的参数名全是形式参数
}
}
延伸学习
一、操作符优先级
操作符的优先级还有组合规则确定了操作符计算的顺序。
优先级相同的操作符相邻，则结合规则决定它们的执行顺序。除了赋值运算符意外，其它所有二元操作符都是左结合的。
二、产生随机数
Math.random()：来获取一个0.0到1.0之间的随机double值，不包含1.0。
/**
* 产生随机数
*/
public class 产生随机数 {
public static void main(String[] args) {
// 产生两个随机数
int number1 = (int) (Math.random() * 10);
int number2 = (int) (Math.random() * 10);
// 输出
System.out.println("number1 = " + number1);
System.out.println("number2 = " + number2);
}
}
三、调试
调试是在程序中找到和修改错误的过程。
逻辑错误称为bug，查找和改正错误的过程称为调试（debugging）。调试的一般步骤采用各种方法缩小程序bug的所在范围，可以手动跟踪也可以插入打印语句。
一个调试功能大多数包含：
-
一次执行一条语句：调试器允许一次执行一条从而看到每句的问题。
-
跟踪进入一个具体方法：如果一个方法正在执行，可以让调试器进入这个方法内部，一次执行一条语句。或者让整个调试器跳过这个方法全部执行。
-
设置断点：你可以在一条特定的语句上面设置断点。当遇到一个断点，你的程序将要停止。需要查看什么语句的执行，就把断点设置在什么地方。
-
显示调用堆栈：宏观观察变量的内存占用。
-
显示变量：显示内存中变量的名称和内容。
328
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
