Java（三）逻辑控制（if....else，循环语句）与方法
逻辑控制（if....else，循环语句）与方法
- 四、逻辑控制
-
- 1.if...else(常用)
-
- 1.1表达格式（三种）
- 2.switch...case(用的少)
-
- 2.1表达式
- 3.while(常用)
-
- 3.1语法格式
- 3.2关键字beak：
- 3.3关键字 continue：
- 4.for.....（常用）
-
- 4.1语法格式
- 5.while...do(不常用)
-
- 5.1基本语法
- 逻辑控制小总结
- 五、方法
-
- 1.定义
- 2.模块化
-
- 1.实参和形参的关系
- 3.重载（重要后边有大用）
- 4.重写（重要后边有大用）
- 5.递归（重要，一种思维方式）
- 方法小总结
四、逻辑控制
1.if…else(常用)
1.1表达格式（三种）
-
小括号里面进行判断条件是否符合，正确执行语句
if(布尔表达式){ 语句 } -
在小括号里面进行条件判断，正确执行语句1，错误执行语句2
if (布尔表达式) { 语句1 }else{ 语句2 } -
表达式1正确，执行语句1,诺表达式1不正确，
则去判断表达式2是否正确，正确则执行语句2，
表达式2不正确，则去语句3。if(布尔表达式1){ 语句1 }else if(布尔表达式2){ 语句2 }else{ 语句3 }
外入：为了能将值能够通过键盘等工具，输入到计算机里面，java为此提供了一个方法Scanner。我们不需要懂的实现原理，只需要知道它的作用，和实现方法就行。这就是java的其中一个好处。
如何使用？
Scanner scanner=new Scanner(System.in);
//整型接收
int l= scanner.nextInt();//提供整型输入
//浮点型接收
float h= scanner.nextFloat();//提供一个浮点数输入
//字符串接收
String p=scanner.next();//提供了一个字符串输入
//没有输入char类型的方法
将两者结合一下：
实例1：
题目：输入一个1~100的数字来代表一个学生的成绩，并给他或她给予这门课评价
分数在 [90, 100] 之间的，为优秀
分数在 [80, 90) 之前的，为良好
分数在 [70, 80) 之间的，为中等
分数在 [60, 70) 之间的，为及格
分数在 [ 0, 60) 之间的，为不及格
Scanner scanner=new Scanner(System.in);
//整型接收
int score = scanner.nextInt();//提供整型输入
if(score >= 90){
System.out.println("优秀");
}else if(score >= 80 && score < 90){
System.out.println("良好");
}else if(score >= 70 && score < 80){
System.out.println("中等");
}else if(score >= 60 && score < 70){
System.out.println("及格");
}else if(score >= 0 && score < 60){
System.out.println("不及格");
}else{
System.out.println("错误数据");
}
实例2：
判断一个年份是否是闰年（什么是闰年？就是一般年份多天的年份），如何解题？
四年一闰、百年不闰、400年再闰
用年份除以4，没有余数的就是闰年，有余数的是平年，如果是世纪年（整百年）则是除以400。
Scanner scanner=new Scanner(System.in);
//整型接收
int year = scanner.nextInt();//输入年份
if (year % 100 == 0) {
//判断世纪闰年
if (year % 400 == 0) {
System.out.println("是闰年");
} else {
System.out.println("不是闰年");
}
} else {
//判断普通闰年
if (year % 4 == 0) {
System.out.println("是闰年");
} else {
System.out.println("不是闰年");
}
}
2.switch…case(用的少)
2.1表达式
switch(表达式){
case 常量值1:{
语句1;
break;//终止语句
}
case 常量值2:{
语句2;
break;//终止语句
}
.....
default:{
内容都不满足时执行语句;
break;//终止语句
}
}
- 先计算表达式的值
- 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束
- 当表达式的值没有与所列项匹配时，执行default
实例1
输入一个数（1~10）的数，判断它是星期几
Scanner scanner=new Scanner(System.in);
//整型接收
int day = scanner.nextInt();//输入日期
switch(day) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("这个数不在日期中");
break;
}
注意：
- 多个case后的常量值不可以重复
- switch的括号内只能是以下类型的表达式：
基本类型：byte、char、short、int，注意不能是long类型
引用类型：String常量串、枚举类型
3.while(常用)
3.1语法格式
-
循环条件为 true, 则执行循环语句; 当条件不满足时为false，则结束循环.
while(循环条件){ 循环语句; }
实例1：
计算 1 ~ 100 的和
int n = 1;
int result = 0;
while (n <= 100) {
result += n;
n++;
}
System.out.println(num);//5050
实例2：
计算 5 的阶乘
int n = 1;
int result = 1;
while (n <= 5) {
result *= n;
n++;
}
System.out.println(num);//120
实例3
计算 1! + 2! + 3! + 4! + 5!的和
int num = 1;
int sum = 0;
// 外层循环负责求阶乘的和
while (num <= 5) {
int factorResult = 1;
int tmp = 1;
// 里层循环负责完成求阶乘的细节.
while (tmp <= num) {
factorResult *= tmp;
tmp++;
}
sum += factorResult;
num++;
}
System.out.println("sum = " + sum);
注意：
循环内的条件一定要设置好，诺是没有设置好就会一直循环，直到程序吃完你的所有运算资源。然后崩溃。
3.2关键字beak：
break 的功能是让循环提前结束.
实例：找到 100 - 200 中第一个 3 的倍数
int num = 100;
while (num <= 200) {
if (num % 3 == 0) {
System.out.println("找到了 3 的倍数, 为:" + num);//102
break;
}
num++;
}
3.3关键字 continue：
continue 的功能是跳过这次循环, 立即进入下次循环
实例：
找到 100 - 200 中所有 3 的倍数
int num = 100;
while (num <= 200) {
if (num % 3 != 0) {
num++;
continue;
}
System.out.println("找到了 3 的倍数, 为:" + num);
num++;
}
4.for…（常用）
4.1语法格式
表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次
表达式2: 循环条件，满足条件，则继续循环，否则循环结束
表达式3: 循环变量变化方式
for(表达式1;布尔表达式2;表达式3){
表达式4;
}
如何执行？
（1，2，3，4）—>(2,3,4)—>(2,3,4)—>(2,3,4)—>(2不满足条件)终止循环
实例1：
计算 1 ~ 100 的和
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println("sum = " + sum);5050
实例3
计算 1! + 2! + 3! + 4! + 5!的和
int sum = 0;
for (int i = 1; i <= 5; i++) {
int tmp = 1;
for (int j = 1; j <= i; j++) {
tmp *= j;
}
sum += tmp;
}
System.out.println("sum = " + sum);
注意：
和while循环一样，结束单趟循环用continue，结束整个循环用break
5.while…do(不常用)
5.1基本语法
-
先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。
do{ 循环语句; }while(循环条件);
实例
int num = 1;
do {
System.out.println(num);
num++;
} while (num <= 10);
逻辑控制小总结
1.常用for，if，while，等逻辑控制
2.switch，case，break，要一起用
3.break终止当前循环，continue跳出这次循环
五、方法
在实际开发中，有一些代码是会被重复使用的。首先我们假设一个应用场景，假设有一个程序描述了一个计算器。一个计算器有乘，除，加，减，根号。现在我需要计算一个数字，先除，再乘，再除。那么我们就需要写入一个关于除法的代码，写一个乘法的代码，然后再写一个除法的代码。你看我们写了两次除法的代码。这样就太不方便了。
1.定义
所以在这是Java就引入了一个概念，方法，将一个代码用方法装起来，等需要用的时候就将，方法名放入带到要使用的代码中，通过这个方法名调用这个代码。
修饰符 返回值类型 方法名称([参数类型 形参 …]){
方法体代码;
[return 返回值];
}
2.模块化
public static int add(int x, int y) {
System.out.println("调用方法中 x = " + x + " y = " + y);
return x + y;
}
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("第一次调用方法之前");
int ret = add(a, b);
System.out.println("第一次调用方法之后");
System.out.println("ret = " + ret);
System.out.println("第二次调用方法之前");
ret = add(30, 50);
System.out.println("第二次调用方法之后");
System.out.println("ret = " + ret);
}
1.实参和形参的关系
看见括号中的参数吗？这个是参数，而参数分为形参和实参。
形参：就相当于add函数中的自变量x，用来接收add函数在调用时传递的值的。形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。
实参：通过实际参数可以更改变量的值的参数。
这里就不得不说一个东西。数据在内存中如何存储？
真实的存储中，存储一个数据会将一个唯一的地址与一个数据进行映射。形参就是将数据扔给add方法。而实参就是通过地址映射，来进行修改数据。此时add中对a进行改动，那么地址与之对应的数据就会改变
public static int getSum(int n){ // n是形参
return n / 2;
}
getSum(10); // 10是实参,在方法调用时，形参n用来保存10
getSum(100); // 100是实参，在方法调用时，形参n用来保存100
3.重载（重要后边有大用）
在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。
为什么这样呢？我要去买菜，一个猪肉20块一斤，一斤白菜3.6块。那么问题来了。我要买一斤猪肉，3斤白菜。我要计算我要花多少钱。那么我就需要定义一个addMet（），addVegetable（）然后总和。可是都是加法，为什么不定义一个add（）只要中间的代码不同不就行了。
public class TestMethod {
public static void main(String[] args) {
add(1, 2); // 调用add(int, int)
add(1.5, 2.5); // 调用add(double, double)
add(1.5, 2.5, 3.5); // 调用add(double, double, double)
}
public static int add(int x, int y) {
return x + y;
注意：
- 方法名必须相同
- 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
- 与返回值类型是否相同无关
4.重写（重要后边有大用）
5.递归（重要，一种思维方式）
这种思想在数学和编程中非常有用，因为有些时候，我们遇到的问题直接并不好解决，但是发现将原问题拆分成其子问题之后，子问题与原问题有相同的解法，等子问题解决之后，原问题就迎刃而解了。
//计算阶乘
public static void main(String[] args) {
int n = 5;
int ret = factor(n);
System.out.println("ret = " + ret);
}
public static int factor(int n) {
if (n == 1) {
return 1;
}
return n * factor(n - 1); // factor 调用函数自身
}
具体实现过程，红色为调用，绿色为返回
注意：
- 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
- 递归出口
方法小总结
- 修饰符（权限修饰符）：public（公开）
- 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void
- 方法名字：采用小驼峰命名
- 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
- 方法体：方法内部要执行的语句
- 在java当中，方法必须写在类当中
- 在java当中，方法不能嵌套定义
- 在java当中，没有方法声明一说