目录
1、程序流程控制
顺序结构
判断结构
选择结构
循环结构
1.1 顺序结构
顺序结构就是程序从上一行到下一行执行的结构，中间没有判断和跳转。直到程序结束。
| public static void main(String[] args) { // 顺序结构 System.out.println("hello java day01"); System.out.println("hello java day02"); System.out.println("hello java day03"); System.out.println("hello java day04"); System.out.println("hello java day05"); System.out.println("hello java day06"); } |
回忆我们的第一个程序计算圆面积的程序，如果获取到的半径是一个负值，是不希望程序计算面积的，如何处理？java提供了判断
| public static void main(String[] args) { double radius = 0; double area; if (radius < 0) System.out.println("参数错误！"); else { area = radius * radius * 3.14159; System.out.println("面积是： " + area); } } |
选择语句要用到条件，条件就是布尔表达式（结果是true或者flase）
1.2 判断
1.2.1 if 语句
if语句可以使程序选择是否执行某条语句.
三种格式：
1、if(条件表达式)
{
执行语句；
}
2、if(条件表达式)
{
执行语句；
}
else
{
执行语句；
}
3、if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
If语句格式1：
| if(布尔表达式){ 语句; ... } |
该语句的特点：当且仅当条件为true时执行一个动作。
| public static void main(String[] args) { int x = 0; if (x > 0) { System.out.println("yes"); } System.out.println("over"); } |
if就是如果的意思。括号里边是条件表达式,只要是条件表达式,就会有true 和false。 那么我就通过if 语句控制来了某些语句的执行。条件满足就会执行if 控制区间内的代码,什么是控制区间,就是一对{}之间的。
如果if 控制的语句只有一条那么,括号可以省略不写.也就是说如果if 后没有大括号,那么if 只控制离if最近的语句.建议初学者加上{}
| int i=100; if(i>0){ System.out.println("大于0"); } |
注意：不要少写括号
| int i=100; if(i>0 { System.out.println("大于0"); } |
如果花括号内只有一条语句可以省略花括号
| int i=100; if(i>0) System.out.println("大于0");
|
练习：提示用户输入一个整数。如果该整数是5的倍数，打印“5的倍数”如果是2的倍数打印“2的倍数”
提示：为了便于让用户输入数据，我们使用Scanner这个类，固定用法Scanner sc=new Scanner(System.in); 该类需要导入包import java.util.Scanner;
int nextInt = sc.nextInt();获取用户输入的数字
| import java.util.Scanner; public class Demo9 { public static void main(String[] args) { Scanner sc=new Scanner(System.in); int nextInt = sc.nextInt(); if(nextInt%5==0){ System.out.println("是5的倍数"); } if(nextInt%2==0){ System.out.println("是2的倍数"); } } } |
If语句第二种格式：
If语句的第一种格式只有当条件表达式为真的时候才执行操作，但条件为假的时候什么也不做。假如希望在条件为false的时候也做一些动作。那么就可以使用第二种格式的语句。根据条件为true和flase分别执行不同的动作。
语法：
| if(布尔表达式){ 布尔表达式为真时执行语句; ... }else{ 布尔表达式为假时执行语句; ... }
|
案例：判断一个整数是奇数还是偶数
| public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入一个整数："); int nextInt = sc.nextInt(); if (nextInt % 2 == 0) { System.out.println("是偶数"); } else { System.out.println("是奇数"); } System.out.println("over"); } |
同样道理如果花括号中只有一条语句，那么花括号可以省略不写，初学者不推荐省略。
| public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入一个整数："); int nextInt = sc.nextInt(); if (nextInt % 2 == 0) System.out.println("是偶数"); else System.out.println("是奇数"); System.out.println("over"); } |
观察发现if else语句有点类似于三元运算符.其实三元运算符是if else 的一种简写格式.
| public static void main(String[] args) { int x = 0, y = 1, b; // if else 语句 if (x > y) { b = x; } else { b = y; } System.out.println(b);// 1 // 3元运算 b = x > y ? x : y; System.out.println(b); // 1 } |
这两种格式是一样的。if else 结构 简写格式： 变量 = (条件表达式)?表达式1：表达式2；
三元运算符：
好处：可以简化if else代码。
弊端：因为是一个运算符，所以运算完必须要有一个结果。
If语句第三种格式
需求: 根据用户定义的数值不同,打印对应的星期英文。if 只能进行一层判断,if else 只能进行两层判断,那么需要多层判断时呢?星期可是有7个数的。如何设计代码？
星期英文 Monday Tuesday Wednesday Thursday Friday Saturday Sunday 方案一：使用if 语句
| public static void main(String[] args) { int x = 8; if (x == 1) { System.out.println("星期一"); } if (x == 2) { System.out.println("星期二"); } if (x == 3) { System.out.println("星期三"); } } |
如果这样设计的话,第一个if语句执行完毕后,第二个语句仍会执行（去判断）,是一个顺序结构.那么事实上当前定义的星期之后会有一个.假如,第一个已经符合条件,那么剩余的执行就没有意义了。属于逻辑错误。
使用if else ，如果用户输入的是7以外的数据，那么怎么处理？就需要使用else 了
方案2：使用if else if语句
| public static void main(String[] args) { int x = 8; if (x == 1) { System.out.println("星期一"); } else if (x == 2) { System.out.println("星期二"); } else if (x == 3) { System.out.println("星期三"); } else if (x == 4) { System.out.println("星期四"); } else if (x == 5) { System.out.println("星期五"); } else if (x == 6) { System.out.println("星期六"); } else if (x == 7) { System.out.println("星期日"); } else { System.out.println("哥们：请输入数字1-7，不能这么干"); } } |
注意：
| public static void main(String[] args) { int x = 5; if (x == 1) { System.out.println("1"); } if (x == 2) { System.out.println("2"); } if (x == 3) { System.out.println("3"); } else { System.out.println("4"); // 4 } } |
该if 语句不是一个整体,第一个if 是一个语句
第二个又是一个语句,最后的if else 又是一个语句
if语句特点
1、每一种格式都是单条语句。
2、第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以写在其他表达式中。
3、条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false。
练习:
练习1：根据用户输入的月份,打印出月份所属的季节.
345 spring 678 sunmer 9 10 11 autumn 12 1 2 winter
练习2：根据用户输入的成绩，进行评级，根据学生考试成绩划分ABCD A90-100 B80-89 C70-79 D60-69 E0-59，建议成绩使用double
练习1：
| public static void main(String[] args) { int x = 1; if (x == 3) { System.out.println("spring"); } else if (x == 4) { System.out.println("spring"); } } |
仔细观察：发现if和else if要执行的语句是一样的，可不可以合并呢。当然是可以的。怎么合并？使用逻辑运算符，那么使用哪个逻辑运算符呢， &肯定不行。需要全部为真才为真，月份是不可能同时满足的 那么使用|连接符号即可。意思只要其中一个为真，就为真。另外可以使用短路功能。
| public static void main(String[] args) { int x = 1; if (x == 3 || x == 4 || x == 5) { System.out.println("spring"); } else if (x == 6 || x == 7 || x == 8) { System.out.println("Summer"); } else if (x == 9 || x == 10 || x == 11) { System.out.println("autumn"); } else if(x==12||x==1||x==2){ System.out.println("Winter"); } else { System.out.println("月份不存在"); } } |
练习2：
| public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入考试分数："); double score = sc.nextDouble(); char grade; if (score >= 90.0) grade = 'A'; else if (score >= 80.0) grade = 'B'; else if (score >= 70.0) grade = 'C'; else if (score >= 60.0) grade = 'D'; else grade = 'F'; System.out.println("你的成绩是:" + grade); } |
If语句常见的错误：
1忘记必要的括号：如果代码块中只有一条语句的时候，可以省略花括号，但是当花括号将多条语句扩在一起时，花括号就不能在省略。
| double radius = 4; double area; if (radius >= 0) area = radius * radius * 3.14; System.out.println("The area " + " is " + area); |
| double radius = 4; double area; if (radius >= 0) { area = radius * radius * 3.14; System.out.println("The area " + " is " + area); } |
虽然代码一样多，但是第一个会编译报错（area没有出初始化），第二个正常运行。就是因为少了花括号。所以一定要仔细。
2if语句后出现分号
| double radius = 0; double area; if (radius > 0); { area = radius * radius * 3.14; System.out.println("The area " + " is " + area); } |
注意：这是一个逻辑错误，编译和运行都不会报错，只是不会出现想要的结果。
| double radius = 0; double area; if (radius > 0){}{ area = radius * radius * 3.14; System.out.println("The area " + " is " + area); } |
3布尔值的测试
| double radius = 0; double area; boolean flag=true; if (flag==true){ area = radius * radius * 3.14; System.out.println("The area " + " is " + area); } |
其中的布尔表达式很容易写成flag=true，并且flag本来就是布尔类型的值。没有必要在进行真假判断。
| double radius = 0; double area; boolean flag=true; if (flag){ area = radius * radius * 3.14; System.out.println("The area " + " is " + area); } |
拓展题：
判断闰年
1：什么是闰年？可以被4整除不能被100整除，或者可以被400整除，那么这一年就是闰年（leap year）
| public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入年份："); int year = sc.nextInt(); // 判断年份能否被4整除 boolean isLeapYear = (year % 4 == 0); // 年份能被4整除，并且不能被100整除并且使用&&（and） isLeapYear = isLeapYear && (year % 100 != 0); // 年份或者能够被400整除 isLeapYear = isLeapYear || (year % 400 == 0); if (isLeapYear) { System.out.println(year + "是闰年！"); } // 简写格式； if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) { System.out.println(year + "是闰年！"); } } |
1.3 选择结构
1.3.1 switch语句
格式：
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
…...
default:
执行语句；
break；
}
switch语句特点：
1,switch语句选择的类型只有四种：byte，short，int ， char。
2,case之间与default没有顺序。先执行第一个case，没有匹配的case执行
default。
3,结束switch语句的两种情况：遇到break，执行到switch语句结束。
4,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运
行可以执行的语句，直到遇到break或者switch结尾结束。
5，switch case中的值必须要与switch表达式的值具有相同的数据类型。而且case后跟的值必须是常量，不能跟变量。
案例：
| public static void main(String[] args) { int x = 3; switch (x) { case 1: System.out.println("1"); break; case 2: System.out.println("2"); break; case 3: System.out.println("3"); break; default: System.out.println("ok"); break; } } |
case 就像选择题的答案之一。 break 就是如果该答案正确那么就可以跳出switch 了,意思就是说 已经找出了正确的答案了。那么这道题也就做完了。如果 case 没有匹配接着进行下一个case 匹配,直到匹配为止。 最后如果都没有匹配上,那么 switch 给提供了一个默认的答案,就是 default。
注意: case后跟的是冒号:
每个case中的执行语句一定要加break；
练习；
需求2:根据用于指定的月份,打印该月份所属的季节.
一旦case匹配,就会顺序执行后面的程序代码,而不管后面的case是否匹配,直到遇见break,利用这一特性可以让好几个case执行同一语句.
345 spring 678 summer 9 10 11 autumn 12 1 2 winter
| public static void main(String[] args) { int x = 3; switch (x) { case 3: case 4: case 5: System.out.println("spring"); break; case 6: case 7: case 8: System.out.println("sunmer"); break; case 9: case 10: case 11: System.out.println("autumn"); break; case 12: case 0: case 1: System.out.println("winter"); default: System.out.println("ok"); break; } } |
练习：char 类型在switch 中的使用.
| public static void main(String[] args) { int x = 1, y = 2; char ch = '*'; switch (ch) { case '+': System.out.println("x*y=" + (x + y)); break; case '-': System.out.println("x-y="+(x-y)); break; case '*': System.out.println("x*y="+(x*y)); break; case '/': System.out.println("x/y="+(x/y)); break; default: System.out.println("不靠谱"); } } |
if 和switch 语句很像.
具体什么场景下,应用哪个语句呢?
如果判断的具体数值不多,而是符号byte,short int char 四种类型.
虽然2个语句都可以使用,建议使用switch语句.因为效率稍高.
其他情况:对区间判断,对结果为boolean 类型判断,使用if if的使用范围更广。
if 除了能判断具体数值还能判断区间。switch 判断区间会费劲。要写好多case 对于运算结果是boolean型的 if 能判断 switch 是不能实现的。例如：根据学生考试成绩划分ABCD A90-100 B80-89 C70-79 D60-69 E0-59
实际开发怎么选择呢。
如果要对具体数值进行判断,并且数值不多,那么 就用switch 来完成。 Switch 是一开始就全部加载进了内存,而if 语句要顺序执行，需要多个if 和else if 执行过程就要比switch 稍微多了一点。
但是switch 的局限性比较大必须是4种类型,并且值不多。一般都是使用if。 最后在jdk 7中对switch 进行了增强 还可以判断字符串。5.0 增加了对枚举的判断。
1.4 循环结构
循环可以使程序多次执行某些语句.
需求：需要打印一行字符串"hello gzitcast"，100次
就需要将该语句打印100遍System.out.println("hello gzitcast");
那么如何解决该问题？
Java提供个一个称之为循环的结构，用来控制一个操作的重复执行。
| int count = 0; while (count < 100) { System.out.println("hello gzitcast"); count++; } System.out.println("over"); |
变量count初始化值为0，循环检查count<100 是否为true,如果为true执行循环体（while后{}之间的语句），输出"hello gzitcast"语句，然后count自增一，重复循环，直到count是100时，也就是count<100为false时，循环停止。执行循环之后的下一条语句。
Java提供了三种类型的循环语句：while循环，do-while循环和for循环。
| 1、while语句格式： while(条件表达式) { 执行语句； } |
| 2、do while语句格式： do { 执行语句； }while(条件表达式); do while特点是条件无论是否满足， 循环体至少被执行一次。 |
| 3、for格式： for(初始化表达式；循环条件表达式；循环后的操作表达式) { 执行语句； } |
1.4.1 while
定义需求: 想要打印5次helloworld
1、
| public static void main(String[] args) { System.out.println("hello world"); System.out.println("hello world"); System.out.println("hello world"); System.out.println("hello world"); System.out.println("hello world"); } |
2、
| public static void main(String[] args) { int x = 0; while (x < 5) { System.out.println("hello java "); } } |
如果是在dos里编译和运行，是不会停止，除非系统死机。需要ctrl+c来结束。
这就是真循环或者死循环。因为x<5 永远为真。
3、
| public static void main(String[] args) { int x = 0; while (x < 5) { System.out.println("hello java "); x++; } } |
让x自增，那么就会有不满足条件的时候。循环就会结束。
练习：想要打印出1-100之间的奇数
| public static void main(String[] args) { int x = 1; while (x < 100) { System.out.println(x); x = x + 2; } } |
| public static void main(String[] args){ int x=1; while(x<100){
if(x%2!=0){ System.out.print(x); } x++; } System.out.println(); } |
练习2：计算1+2+3+4+5+6+7+8+9 的值
| int sum = 0; int i = 1; while (i < 10) { sum = sum + i; i++; } System.out.println(sum); |
注意：要精确控制循环的次数。常犯错误是是循环多执行一次或者少执行一次。
例如会执行101次，想要执行100次，要么是count初始值为1，然后count<=100
要么是count初始值为0，coung<100
| int count = 0; while (count <=100) { System.out.println("hello gzitcast"); count++; } System.out.println("over"); |
猜数字游戏:
编写程序随即生成一个1-100之间的随机数。程序提示用户输入一个数字，不停猜测，直到猜对为止。最后输出猜测的数字，和猜测的次数。并且如果没有猜中要提示用户输入的值是大了还是小了。
思考：
如何生成1-100之间随机数？
(int)(Math.random()*100)+1;
如何提示用户输入数字，
Scanner sc=new Scanner(System.in);
int guessNum = sc.nextInt();
需要将随机数和用户输入的数字进行比较。
猜一次：
| Scanner sc = new Scanner(System.in); int num = (int)(Math.random()*100)+1; System.out.println("请输入0-100之间整数"); int guessNum = sc.nextInt(); if (guessNum == num) { System.out.println("中啦"); } else if (guessNum < num) { System.out.println("小啦"); } else { System.out.println("大了"); } |
这个程序只能才一次，如何让用户重复输入直到猜对？
可以使用while循环
| public static void main(String[] args) { int num = (int)(Math.random()*100)+1; Scanner sc = new Scanner(System.in); while (true) { System.out.println("请输入1-100之间整数"); int guessNum = sc.nextInt(); if (guessNum == num) { System.out.println("中啦"); } else if (guessNum < num) { System.out.println("小啦"); } else { System.out.println("大了"); } } } |
该方案发现了问题，虽然实现了让用户不停的输入，但是即使猜中了程序也不会停止。
那么就需要控制循环次数了。也就是while() 括号中的条件表达式。当用户猜测的数和系统生成的数字不相等时，就需要继续循环。
| int num = (int)(Math.random()*100)+1; Scanner sc = new Scanner(System.in);
int guessNum = -1; while (guessNum != num) { System.out.println("请输入1-100之间整数"); guessNum = sc.nextInt(); if (guessNum == num) { System.out.println("中啦"); } else if (guessNum < num) { System.out.println("小啦"); } else { System.out.println("大了"); } } |
为什么将guessNum初始化值为-1？因为如果初始化为1到100之间程序会出错，因为可能是要猜的数。
1：首先程序生成了一个随机数
2：用户输入一个数字
3：循环检查用户数字和随机数是否相同，知道相同位置，循环结束
1.4.2 do while 语句
| public static void main(String[] args) { int x = 0, y = 0; do { System.out.println(x); x++; } while (x < 0); // do while do会先执行一次,不管是否满足循环条件。 while (y < 0) { System.out.println(y); y++; } } |
while:先判断条件，只有条件满足才执行循环体。
do while: 先执行循环体，再判断条件，条件满足，再继续执行循环体。
简单一句话：do while：无论条件是否满足，循环体至少执行一次。
注意一个细节do while 后面的分号;
案例：改写猜数字游戏
| public static void main(String[] args) { // 记录用户输入的数字 int guess = -1; // 记录用户输入次数 int count = 0; // 生成1-100之间随机数 int num = (int) (int)(Math.random()*100)+1; Scanner sc = new Scanner(System.in); // 循环猜数字 do { System.out.println("请输入1-100之间的数字"); guess = sc.nextInt(); if (guess > num) { System.out.println("哥们，太大了"); } else if (guess < num) { System.out.println("哥们，太小了"); } else { System.out.println("恭喜，中啦"); } count++; } while (num != guess); System.out.println("你猜测的数字是:" + num + "猜测了" + count + "次"); } |
案例：计算器
系统自动生成2个随机数用于参与运算。
系统生成0-4之间的随机数，表示加减乘除取模运算。
使用switch 进行匹配
| class Couter { public static void main(String[] args) throws InterruptedException { // 生成随机数Math.random()生成0-1值，不包含0和1， //乘以10得到0和10之间的数（double类型），不包含0和10 //强转为int，并加1得到1和10之间的数，包含1和10 int x = (int)(Math.random()*10)+1; int y = (int)(Math.random()*10)+1; System.out.println(x); System.out.println(y); // 创建0-4随机数 0 1 2 3 4 各表示加减乘除取模 int z = (int) (int)(Math.random()*5); System.out.println(z); switch (z) { case 0: System.out.println(x + "+" + y + "=?"); System.out.println("哥们快猜。。。。"); Thread.sleep(2000); System.out.println(x + "+" + y + "=" + (x + y)); break; case 1: System.out.println(x + "-" + y + "=?"); System.out.println("哥们快猜。。。。"); Thread.sleep(2000); System.out.println(x + "-" + y + "=" + (x - y)); break; case 2: System.out.println(x + "*" + y + "=?"); System.out.println("哥们快猜。。。。"); Thread.sleep(2000); System.out.println(x + "*" + y + "=" + (x * y)); break; case 3: System.out.println(x + "/" + y + "=?"); System.out.println("哥们快猜。。。。"); Thread.sleep(2000); System.out.println(x + "/" + y + "=" + (x / y)); break; case 4: System.out.println(x + "%" + y + "=?"); System.out.println("哥们快猜。。。。"); Thread.sleep(2000); System.out.println(x + "%" + y + "=" + (x % y)); break; } } } |
计算器2：上述中只能计算一次。可以使用while循环来不停计算。
程序生成了3个随机数，前两个数参与运算，第三个数用于匹配运算符。要注意除数为0的情况。
int x = (int)(Math.random()*10)+1;
Math.random() 生成0-1之间的数字，double类型
Math.random()*10 就是0-9之间的数，是double类型
(int)(Math.random()*10)将double类型强转成int类型，去掉小数点，便于计算。
(int)(Math.random()*10)+1，生成了1到10之间随机数。
int z = (int) (int)(Math.random()*5);
生成0-4之间的数字，可以用0表示加，1表示减，2表示乘，3表示除，4表示取模
为了减慢程序，使用了Thread.sleep(2000); 让程序等待一会。
1.4.3 for 循环
格式：for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
定义需求: 想要打印5次helloworld
| public static void main(String[] args) { for (int x = 0; x < 5; x++) { System.out.println("hello java"); } } |
1、for的执行流程是什么一定要明白
for 知道要进行循环，读到x=0 的时候，在内存中开辟了空间,定义变量x 赋值为0。接着进行条件判断 x<5，为真，这个时候对满足条件后执行了循环体的内容System.out.println("hello java");当循环体执行完毕之后,执行x < 5;后的表达式即 x++ 。x自增后变为了1 ，再次进行判断 x<5 (int x=0 只执行一次)，如果为真就再次运行System.out.println("hello java");如果为假，for循环结束。
2、for 和while的区别
| public static void main(String[] args) { for (int x = 0; x < 5; x++) { System.out.println("hello java"); } System.out.println(x); //x cannot be resolved to a variable int y = 0; while (y < 5) { System.out.println("hello world"); y++; } System.out.println(y); } |
1 错误
解释 x 为什么会找不到,注意了变量的作用域,也就是变量的作用范围。x 只在 for 循环的大括号内有效,出了这个区域，就无效了.在内存中就消失了。x消失后,仍要访问它,肯定会报错的。
y 就不一样了，y 是定义在while 外的。while循环完毕仍有效 while的初始化 动作在外边，循环结束后y 仍然存在。
当定义的y 只作为循环增量存在的话的，循环完毕后y就没有用了，但是y还是占着一块内存。所以，如果定义的变量只作为循环增量存在的话，就用for 循环可以节约内存。
其实for 和while 是可以互换的。
最后总结
1、for里面的两个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
2、while与for可以互换，区别在于for为了循环而定义的变量在for循环结束时就在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
3、最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
| while(true){
} for(;;){
} for(;true;){
|
推荐使用while(true)
for 练习:
-
- 获取1-10的和，并打印。
- 1-100之间 7的倍数的个数,并打印。
| public static void main(String[] args) { // 获取1到10的和1+2+3+4+5+6+7+8+9+10 int sum = 0; for (int x = 1; x <= 10; x++) { System.out.println((sum + x) + "=" + sum + "+" + x); sum = sum + x; } System.out.println(sum);// 55 } |
| public static void main(String[] args) { // 1-100之间 7的倍数的个数,并打印。 int count = 0; for (int x = 0; x <= 100; x++) { if (x % 7 == 0) { System.out.println(x); count++; } } System.out.println(count); } |
累加思想：通过变量记录住循环操作后的结果；通过循环的形式.进行累加的动作。
计数器思想：通过一个变量记录住数据的状态变化，也是通过循环完成。
循环常见错误：
多加分号：在for括号后和循环体之间加分号是常见错误。
错误：
程序编译运行都可以通过，只是不是我们想要的结果。
| for(int i=0;i<100;i++);{ System.out.println("hello "); } |
正确：
| for(int i=0;i<100;i++){ System.out.println("hello "); } |
错误；是一个死循环
| int i=0; while(i<100);{ System.out.println("hello"); i++; } |
正确：
| int i=0; while(i<100){ System.out.println("hello"); i++; } |
1.4.4 语句的嵌套应用
什么是嵌套形式，其实就是语句中还有语句。
想要打印出矩形：
| public static void main(String[] args) { for (int x = 0; x < 5; x++) { System.out.print("*"); } } |
| public static void main(String[] args) { for (int x = 0; x < 5; x++) { System.out.println("*"); } } |
这里用“*”表示矩形的边。
| public static void main(String[] args) { for (int x = 0; x < 5; x++) { for(int y=0;y<6;y++){ System.out.print("*"); } System.out.println(); } } |
forfor 嵌套for循环练习2
打印此种格式的图案
*****
****
***
**
*
| public static void main(String[] args) { for (int x = 5; x > 0; x--) { for(int y=x;y>0;y--){ System.out.print("*"); } System.out.println(""); } } |
| for (int x = 0; x < 5; x++) { for (int y = 0; y < 5-x; y++) { System.out.print("*"); } System.out.println(); } |
| for (int x = 0; x < 5; x++) { for (int y = x; y < 5; y++) { System.out.print("*"); } System.out.println(); } |
练习：
*
**
***
****
*****
| public static void main(String[] args) { for (int x = 0; x < 5; x++) { for (int y = 0; y <= x; y++) { System.out.print("*"); } System.out.println(""); } } |
| public static void main(String[] args) { for (int x = 0; x < 5; x++) { for (int y = x; y >= 0; y--) { System.out.print("*"); } System.out.println(""); } } |
练习：99乘法表
| public static void main(String[] args) { for (int x = 1; x <= 9; x++) { for (int y = 1; y <= x; y++) { System.out.print(y + "*" + x + "=" + x * y + '\t'); } System.out.println(" "); } } |
1.5 其他流程控制语句
break 跳出 continue 继续
break 语句: 应用范围:选择结构和循环结构
continue 应用于循环结构
注:
1、这两个语句离开应用范围,存在是没有意义的.
2、 这两个语句单独存在下面都不可以有语句,因为执行不到.
3、 continue 语句是结束本次循环继续下次循环。
4、 标号的出现,可以让这两个语句作用于指定的范围.
break；
| public static void main(String[] args) { for (int x = 0; x < 3; x++) { System.out.println("x=" + x); break; } } |
for 循环的执行.只会打印一次 0.然后结束了循环.
日后使用无限循环,循环多少次不确定,但是在循环中加入判断语句进行判断,当满足条件就要跳出,这时使用break 就可以满足
案例：
| public static void main(String[] args) { // 会打印出什么? for (int x = 0; x < 3; x++) { for (int y = 0; y < 4; y++) { System.out.println("x=" + x); System.out.println("y=" + y); break; } } } |
想要跳出外层循环,但是上述例子每次都是跳出了内层循环。就需要使用标号，也就是起一个名字。
| public static void main(String[] args) { // 注意标号只能用于循环上,是给循环起名字的一种方式. w: for (int x = 0; x < 3; x++) { q: for (int y = 0; y < 4; y++) { System.out.println("x=" + x); break w; // 此时执行了一次内循环直接就跳出整个循环. } } } |
continue 只能用于循环结构.
| public static void main(String[] args) { for (int x = 0; x < 3; x++) { continue; // 如果这样写会编译失败的,java认为是无法访问。 System.out.println("x=" + x); // Unreachable code } } |
| public static void main(String[] args) { for (int x = 0; x < 3; x++) { if (x % 2 == 1) continue; System.out.println("x=" + x); } } // x=0 、x=2 |
continue 用于结束本次循环.继续下一次循环.
break 和continue 单独存在时,下面不可以有任何语句,因为都执行不到。
使用while循环，使用break修改猜数字游戏
| int num = (int) Math.random() * 101; Scanner sc = new Scanner(System.in); System.out.println("请输入0-100之间整数"); int guessNum = -1; while (true) { guessNum = sc.nextInt(); if (guessNum == num) { System.out.println("中啦"); break; } else if (guessNum < num) { System.out.println("小啦"); } else { System.out.println("大了"); } } |
作业：
如果再for循环中声明一个变量，退出循环后还可以使用吗
2、函数
函数的定义
函数的特点
函数的应用
函数的重载
2.1 函数的定义
请完成如下需求：计算出1到10的，20到30，30到50的整数和
| int sum = 0; for (int i = 1; i <= 10; i++) { sum += i; } System.out.println(sum); int sum = 0; for (int i = 20; i <= 30; i++) { sum += i; } System.out.println(sum); int sum = 0; for (int i = 30; i <= 50; i++) { sum += i; } System.out.println(sum);
|
代码完成后发现，计算1到10、20到30、30到50的整数和，除了数字不同之外，其他的都是一样的。出现了重复代码，如何减少重复代码，发现上述案例都是进行求和运算，功能一样只是数值不同，可以通过定义方法来实现减少重复代码的目标。
快速体验函数
上面的代码可以简化为以下:
| public static int getSum(int x, int y) { int sum = 0; for (int i = x; i <= y; i++) { sum += i; } return sum; } |
使用方法：
| public static void main(String[] args) { int reault = getSum(1, 10); System.out.println(reault); int reault2 = getSum(20, 30); System.out.println(reault2); int reault3 = getSum(30, 50); System.out.println(reault3); } |
举例：地铁自动售票机，接收纸币或硬币，返回车票，该售票机具有独立功能，可以理解为函数。有未知内容参与运算（要投币，纸币硬币，多少钱）。有返回值（返回车票）
举例2：手机，手机具备打电话功能，有未知内容（电话号码），键盘是（形参），输入的号码是实际参数。
定义函数：
1、什么是函数？
函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。
函数的格式：
| 修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…) { 执行语句; return 返回值; } |
总结:
定义函数两个明确:
1：是否有未知内容参与运算
2：是否有运算结果（返回值）
案例：获取2个整数中的较大的数。
| public static int getMax(int x, int y) { int result; if (x > y) { result= x; } else { result= y; } return result; } |
解析：getMax方法
该方法方法名为：getMax,方法的作用是获取找出两个整数中较大的值。该方法有两个int型参数，：x和y，方法返回两个数中较大的一个。
注意: 函数定义详解
|
方法定义完成之后，如何调用一个方法？
getMax功能在类中是独立存在的,运行这个类的时候该函数并不会运行,因为功能定义完了却
没有使用.如何使用该函数,直接在主函数中通过调用getMax;即可。
函数调用：
想要使用方法，必须调用它。
| public static void main(String[] args) { int max = getMax(5, 7); System.out.println(max); } |
一：在main方法中调用getMax()方法，5和7就是给该方法传递的实际参数。如果方法有返回值，可以定义一个变量接收返回值，变量类型和方法返回值类型一致。本例中通过int类型变量max接收了getMax方法的返回值。
完整程序
这里的getMax(i, j); 变量i和j就是方法的实际参数。
| public class Demo6 { public static void main(String[] args) { int i=5; int j=7; int max = getMax(i, j); System.out.println(i+"和"+j+"的最大值是："+max); } public static int getMax(int x, int y) { int result; if (x > y) { result= x; } else { result= y; } return result; } } |
二：上述案例中调用getMax方法，并将结果赋值给了max变量。也可以直接打印getMax()方法的结果。
| public class Demo6 { public static void main(String[] args) { int i=5; int j=7; //打印方法的结果 System.out.println(getMax(i, j)); } public static int getMax(int x, int y) { int result; if (x > y) { result= x; } else { result= y; } return result; } } |
解析:
该类中包含了两个方法，main方法和getMax方法。main方法由java虚拟机调用，并且main方法的写法是固定的。main方法可以调用其他方法。
当调用getMax方法时，变量i的值传递给方法中的x，j的值传递给方法中的y，并开始执行getMax方法中的语句，执行return，并返回运算结果。getMax方法运行完毕。
总结: 程序的执行过程
1、主函数被虚拟机调用,
2、getMax(i,j)被执行,
3、程序就跳转到了getMax中运行，同时把变量i和j持有的值传递给了函数中的x和y .
注意：main方法是程序的入口由虚拟机调用，方法和方法之间不能嵌套，方法之间通过调用来使用。
方法什么时候执行完毕：
当执行完return语句，或者执行到方法末尾的花括号时方法结束。
知识拓展(以下是了解)
栈内存：
方法执行原理,每当调用一个方法时，系统都会将参数，局部变量存储在栈内存中，采用先进后出的方式存储数据，当一个方法调用另外一个方法时，调用者的栈空间保持不变，为新方法开辟空间。一个方法运行结束返回到调用者时，其相应的空间也被释放。
本例中java虚拟机调用main方法，为main方法在栈内存中开辟空间（进栈），main方法中有变量i=5 j=7 max，当调用了getMax方法，就为getMax方法开辟空间（栈内存）变量x，变量y 变量result，其中main方法的i和j的值传递给了x，y。getMax方法执行完毕后，将结果传递给了main方法的变量max。getMax方法运行完毕（出栈），getMax方法的空间就被释放掉。继续运行main方法。最后main方法运行完毕，main方法的栈空间被释放。
总结 其实就是将一部分可以复用的代码进行了封装,最主要特点就是可以被重复使用.这就是函数的功能.
2.2 函数的特点
- 定义函数将功能代码进行封装,通过函数提高代码复用性
- 函数只有被调用才会被执行
- 函数没有具体返回值时，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
- return 关键字 用于返回值，用于结束函数。
注意：
函数中只能调用函数，不可以在函数内部定义函数。
错误写法
| public static void main(String[] args) { public static void getResult(int x) { System.out.println(x * 8); // 主函数，里边嵌套函数。错误！ } } |
函数的返回值void
需求：定义函数打印99乘法表:
分析: 该方法仅仅是在控制台输出信息没有具体的返回值,此时就可以使用void来定义方法的返回值类型.
该方法没有具体的返回值,那么返回值的类型 可以省略掉吗?当然不行,因为函数的格式要求有返回值类型.
当函数运算后, 没有具体的返回值时,这时返回值类型用一个特殊的关键字做标志.该关键字就是void void 表示没有具体的返回值类型. 当函数的返回值类型是void 时,函数中的return语句可以省略不写.
return 关键字
用于返回值，用于结束函数。
| public static void print(int a) { if (a % 2 == 0) { System.out.println(a + "是偶数"); } else { System.out.println(a + "是奇数"); } System.out.println("判断结束....."); } public static void print2(int a) { if (a % 2 == 0) { System.out.println(a + "是偶数"); return; } else { System.out.println(a + "是奇数"); } System.out.println("判断结束....."); } |
2.3 函数应用
1.判断2个数是否相同。
2.定义一个功能,用于打印矩形. rectangle
3.定义一个打印99乘法表功能的函数.
练习1
| public static boolean equals(int x, int y) { if (x == y) { return true; } else { return false; } } |
| public static boolean equals2(int x, int y) { return x == y; } |
2.4 函数的重载(overload)
| 重载的概念 在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。 重载的特点： 与返回值类型无关，只看方法名和参数列表。 重载的好处： 方便于阅读，优化了程序设计。 重载示例： 返回两个整数的和 int add(int x,int y){return x+y;} 返回三个整数的和 int add(int x,int y,int z){return x+y+z;} 返回两个小数的和 double add(double x,double y){return x+y;} |
1需求：定义一个函数，实现两个整数的加法。
| public static int add(int x, int y) { return x + y; } |
调用
| System.out.println(getSum(2,3)); /没有问题 System.out.println(getSum(2L,3L)); //编译报错 |
如何解决这个问题，显然add方法只能接受byte short int 和char类型的实际参数,可以再次再次定义add2（long x,long y）方法。
如果需要计算double 数的求和，需要再次定义 add3(double x,double y ) 方法
发现问题
如果要定义运算两个数的求和函数，由于数据类型的不同,可能需要定义对个方法,方法名可能是 getSum1 getSum2 … 等等.关键以后如何调用.怎么知道哪个方法接收的什么类型参数?
总结：如果没有函数重载技术，一个类中会有很多具备相同功能但方法名不同的函数，导致开发者在使用的时候要记住很多函数名。
函数的功能一样，仅仅是参与运算的未知内容不同时。
可以定义多函数，使用统一函数名称，这样方便阅读。
在调用时，虚拟机通过实际参数的不同来区分同名函数。
重载.单词overload
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
范围 是同一个类中, 同名函数,就是函数名一样,那么函数名一样怎么区分呢,
那么只要他们的参数类型,参数个数不同.参数顺序。就是用这些来区分.
那么参数类型和参数个数是函数的哪一个部分呢.参数的定义发现就是函数名后括号中的内容.
所以重载只和参数列表有关系.
练习:
定义一个加法运算,获取两个整数的和.
定义一个加法,获取三个整数的和.
| public static void main(String[] args) { getSum(5, 5); getSum1(5, 6, 6); } // 定义一个加法运算,获取两个整数的和. public static int getSum(int x, int y) { return x + y; } // 定义一个加法,获取三个整数的和. public static int getSum1(int x, int y, int z) { return x + y + z; } |
那么在主函数中写getSum 使用 getSum ，写 getSum1 使用 getSum1
发现这两个函数的功能的具体实现是一样的原理,
函数的名称有什么用？是用于标识函数的。还有一个作用,就是通过函数的名称,体现函数的功能。
函数名称一定要有意义,就是要具有良好的阅读性.所以定义函数名重点在于体现函数的功能。
查看代码发现两个都是求和运算，那么定义了 getSum 和getSum1不是很合适。
虽然这样写没有问题，但是可以写的更好吗？
| public static void main(String[] args) { getSum(5, 5); getSum(5, 6, 6); } // 定义一个加法运算,获取两个整数的和. public static int getSum(int x, int y) { return x + y; } // 定义一个加法,获取三个整数的和. public static int getSum(int x, int y, int z) { return x + y + z; } |
因为功能一致所以函数的名称就一致。那么函数名都叫getSum后还能区分吗？
是可以的,当调用 getSum(6,6);时就去找参数有两个整数的getSum 的方法,如果调用getSum(6,6,6); 那么自动去找对应的三个参数的方法。这些工作都是java虚拟机自动识别的。
如果传入一个参数的呢？肯定会失败,因为函数没有定义。.这就是getSum方法在类中出现了重载的形式，这就是java中的重载,名称保持一直,参数类型,参数个数不同。
注意如果定义两个参数名称,参数列表一样的函数,那么这个就不是重载了,虚拟机是不认的.所以得用参数列表来区分。
练习
/*
void show(int a,char b,double c){}
a.
void show(int x,char y,double z){}//没有，因为和原函数一样。
b.
int show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。
c.
void show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。
d.
boolean show(int c,char b){}//重载了，因为参数个数不同。
e.
void show(double c){}//重载了，因为参数个数不同。
f.
double show(int x,char y,double z){}//没有，这个函数不可以和给定函数同时存在与一个类中。
*/
649
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
