Java（三）逻辑控制（if....else，循环语句）与方法

四、逻辑控制

1.if…else(常用)

1.1表达格式（三种）

1. 小括号里面进行判断条件是否符合，正确执行语句

   	 if(布尔表达式){ 
   	 	语句 
   	  }
   1
   2
   3

2. 在小括号里面进行条件判断，正确执行语句1，错误执行语句2

   		if (布尔表达式) {  
         		 语句1 
           }else{
              	语句2 
       	}
   1
   2
   3
   4
   5

3. 表达式1正确，执行语句1,诺表达式1不正确，
   则去判断表达式2是否正确，正确则执行语句2，
   表达式2不正确，则去语句3。

   		 if(布尔表达式1){
   				语句1
   		}else if(布尔表达式2){
   			 	语句2
   		}else{
   				语句3
   		}
   1
   2
   3
   4
   5
   6
   7

外入：为了能将值能够通过键盘等工具，输入到计算机里面，java为此提供了一个方法Scanner。我们不需要懂的实现原理，只需要知道它的作用，和实现方法就行。这就是java的其中一个好处。

如何使用？

Scanner scanner=new Scanner(System.in);
//整型接收
 int l= scanner.nextInt();//提供整型输入
//浮点型接收
 float h= scanner.nextFloat();//提供一个浮点数输入
//字符串接收
 String p=scanner.next();//提供了一个字符串输入
//没有输入char类型的方法
1
2
3
4
5
6
7
8

将两者结合一下：
实例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("错误数据");
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

实例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("不是闰年");
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.switch…case(用的少)

2.1表达式

		switch(表达式){
			case 常量值1:{
					语句1;
					break;//终止语句
					}
		case 常量值2:{
					语句2;
					break;//终止语句
					}
			.....
			
			default:{
					内容都不满足时执行语句;
					break;//终止语句
					}
				}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1. 先计算表达式的值
2. 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束
3. 当表达式的值没有与所列项匹配时，执行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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

注意：

1. 多个case后的常量值不可以重复
2. switch的括号内只能是以下类型的表达式：
   基本类型：byte、char、short、int，注意不能是long类型
   引用类型：String常量串、枚举类型

3.while(常用)

3.1语法格式

1. 循环条件为 true, 则执行循环语句; 当条件不满足时为false，则结束循环.

   			while(循环条件){
   				循环语句;
   			}
   1
   2
   3

实例1：
计算 1 ~ 100 的和

int n = 1;

int result = 0;

while (n <= 100) {

	result += n;
	n++;
	
}

System.out.println(num);//5050
1
2
3
4
5
6
7
8
9
10
11
12

实例2：
计算 5 的阶乘

int n = 1;
int result = 1;
while (n <= 5) {
	result *= n;
	n++;
}
System.out.println(num);//120
1
2
3
4
5
6
7

实例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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

注意：
循环内的条件一定要设置好，诺是没有设置好就会一直循环，直到程序吃完你的所有运算资源。然后崩溃。

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++;
}
1
2
3
4
5
6
7
8

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++;
}
1
2
3
4
5
6
7
8
9
10
11

4.for…（常用）

4.1语法格式

表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次
表达式2: 循环条件，满足条件，则继续循环，否则循环结束
表达式3: 循环变量变化方式

		for(表达式1;布尔表达式2;表达式3){
		
				表达式4;
		}
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


1
2
3
4
5
6
7
8
9
10

实例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);
1
2
3
4
5
6
7
8
9
10
11
12

注意：
和while循环一样，结束单趟循环用continue，结束整个循环用break

5.while…do(不常用)

5.1基本语法

1. 先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。

   	do{
   			循环语句;
   	}while(循环条件);
   1
   2
   3

实例

int num = 1;

do {
	System.out.println(num);
	num++;
} while (num <= 10);
1
2
3
4
5
6

逻辑控制小总结

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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
1
2
3
4
5

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;
1
2
3
4
5
6
7
8

注意：

1. 方法名必须相同
2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
3. 与返回值类型是否相同无关

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 调用函数自身
}
1
2
3
4
5
6
7
8
9
10
11
12

具体实现过程，红色为调用，绿色为返回

注意：

1. 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
2. 递归出口

方法小总结

1. 修饰符（权限修饰符）：public（公开）
2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void
3. 方法名字：采用小驼峰命名
4. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
5. 方法体：方法内部要执行的语句
6. 在java当中，方法必须写在类当中
7. 在java当中，方法不能嵌套定义
8. 在java当中，没有方法声明一说