Java基础（4）——逻辑控制 分支，循环，try...catch，递归 & break, continue, return

引出

条件，循环，异常获取try-catch，递归，逻辑控制语句

---

一、条件分支

1.单分支选择if…else

@Override
public void deleteById(String id) {
    // id 为null 和 ""
    if (Objects.isNull(id) || "".equals(id)) {
        System.out.println("401异常，id为空...");
        return;
    }
    Older newOlder = new Older();
    newOlder.setId(id);
    boolean removeFlag = list.remove(newOlder); // 根据对象删除，返回True和false
    if (!removeFlag) {
        System.out.println("402异常，未找到该对象，删除失败...");
    } else {
        System.out.println("成功删除编号为" + id + "的老人信息");
    }
}

2.多分支选择if…else if…else

@Override
public void sortByAge(String order) {
    // 对老人的年龄进行排序
    if (order.equals("order")) {// 从小到达
        Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());
    } else if (order.equals("reverse")) { // 从大到小
        Collections.sort(list, (o1, o2) -> o2.getAge() - o1.getAge());
    } else {
        System.out.println("404异常，请输入order或reverse,分别对应顺序和逆序");
    }
}

3.开关语句switch…case

表达式的类型

• long，float，double，boolean不可放
• byte，short，int，char，String，枚举 可以

Switch case的穿透：如果没有写break，程序会接着往下走

// 总结：switch中的条件不能放。long,float,double,boolean;
byte a = 10;
short b = 10;
int c = 10;
long d = 10; //不可以
char ch = 'A'; //本质存的是数字65
float e = 1.2F; // 不可以
double f = 1.2; // 不可以
boolean flag = true; // 特殊，不可放
double g = 1e3; // 科学技术法 1.0*10的3次方，默认是double类型的

ID自增长方法

public class IdGenerator {
    public static int idd = 0;

    /**
     * 根据idd的位数自动生成id
     * @return older的id
     */
    public static String generate(){
        idd++;
        String idStr = idd + "";
        int idStrLength = idStr.length();
        switch (idStrLength){
            case 1:
                return StaticValue.W_PROFIX + "000" + idStr;
            case 2:
                return StaticValue.W_PROFIX + "00" + idStr;
            case 3:
                return StaticValue.W_PROFIX + "0" + idStr;
            default:
                return StaticValue.W_PROFIX + idStr;
        }
    }
}

二、循环分支

作用：循环的作用:减少代码的冗余，提高代码重用性

1.while：

先判断后循环，使用循环次数不确定的情况

// 迭代器的方式【安全删除List的元素】
Older findOlder = null;
Iterator<Older> it = list.iterator();
while (it.hasNext()) {
    Older older = it.next();
    if (id.equals(older.getId())) {
        findOlder = older;
        break;
    }
}

2.do-while

冷门循环，先执行1次再判断

3.重点：for循环

for (int i = 0; i < 10; i++) {}

简化：for each

Older findOlder = null;
for (Older older: list) {
    if(id.equals(older.getId())){
        findOlder = older;
        break;
    }
}

语法：变形语法forEach

list.forEach(System.out::println);

三、异常try…catch

捕获异常的作用：

• 1.当程序异常时，可以根据异常的类型做出不同的处理；
• 2.保证程序在处理完异常后可以继续执行后面的程序，而不是中断程序；

产生 ：Scanner使用时产生；
解决：异常处理机制——异常捕获
try {
// 可能会出现异常的代码
}

四、逻辑控制词

• break 跳出循环 跳出当前的for循环，距离最近的一层循环
• return 直接把方法停止
• continue 结束本次循环，进入下次循环，不会执行continue下面的代码

// 1.电梯有18层，只能停10层一下的楼层(10层以上楼层不可达)
int i = 1;
for( ;i <= 18;i++) {
   if(i % 2 == 0) {
       continue; // 结束本次循环，进入下次循环，不会执行continue下面的代码
	}
	System.out.println("电梯停在了"+i+"层");
}

如何交换两个变量的数据

// 面试点：如何交换两个变量的数据
int x = 10;
int y = 20;
int temp = x; //声明第三个变量存放任意一个变量值；

System.out.println("x=" + x + ",y=" + y);
x = y;
y = temp;
System.out.println("交换后的x=" + x + ",y=" + y);

五、递归：自己调用自己

典型案例：求阶乘

/** 用递归的方式
 * 6! = 6*5! = 6*5*4*3*2*1
 * 6 * jiecheng2(5)
 * 		5 * jiecheng2(4)
 * 			...
 * 			2 * jiecheng2(1)
 * 				return 1; 递归结束的条件
 */
public static long jiecheng2(int num) {
	if(num == 1 || num == 0) { // 0和1的阶乘都为1
		return 1;
	}else if (num < 0){
		System.out.println("错误的输入");
		return (Long) null;
	}
	return num * jiecheng2(num-1);
}

六、案例

1.手机号格式判断

• 号码的位数为1880222959,11位，开头为18；
• String.valueOf(任意类型) 将任意类型转换成字符串
• str.startsWith(“18”) 字符串以18开头
• str.endsWith(“18”) 以18结尾

import java.util.Scanner;
import java.util.InputMismatchException;

// 输入手机号码，判断手机号码是否正确
/*
 * 号码的位数为18802229401,11位，开头为18；
 * String.valueOf(任意类型) 将任意类型转换成字符串
 * str.startsWith("18") 字符串以18开头
 * str.endsWith("18") 以18结尾
 */
public class Test5 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in); // 扫描输入
		System.out.println("请输入一个手机号码");
		long num = 0; // 变量赋初值
		while(true) {
			// 用try catch 捕获处理异常
			try {
				num = scanner.nextLong();
//				String strnum = num + ""; // 任意类型转换成字符串；
				String strnum = String.valueOf(num);
				int length = strnum.length(); // 手机号码的长度
				if(length==11 && strnum.startsWith("18")) {
					System.out.println("手机号码正确，跳出循环");
					break;
				}else { // 手机号位数不正确
					throw new IllegalArgumentException("手机号码位数不正确，请重新输入");
				}
			}catch(InputMismatchException e) {
				// 手机号格式错误
				System.out.println("手机号必须是数字，请重新输入");
				scanner.next(); // 阻塞，此处将键盘的输入传递到scanner.nextLong()
			}catch(IllegalArgumentException e) {
				System.out.println(e.getMessage());
				
			}
		}
		System.out.println("循环之外的代码");
		scanner.close(); // 关闭扫描
	}
}

2.输入字母，大小写；输入字符，字母数字中文？

import java.util.Scanner;

public class Test6 {
	public static void main(String[] args) {
		// 1.键盘输入一个字母，判断是大写字母还是小写字母;
		Scanner scanner = new Scanner(System.in);
		String str1 = scanner.nextLine();
		char ch1 = str1.charAt(0); // 取输入的第一个字符
		if(ch1 >= 'a' && ch1 <= 'z') {
			System.out.println("您输入的"+ ch1 +"是小写");
		}else if(ch1 >= 'A' && ch1 <= 'Z') {
			System.out.println("您输入的"+ ch1 +"是大写");
		}else {
			System.out.println("输入的"+ ch1 +"不是字母");
		}
		
		// 2.键盘输入一个字符，判断是字母，数字，还是中文字符？
		String str = scanner.nextLine();
		char ch = str.charAt(0); // 取输入的第一个字符
		if(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') {
			System.out.println("输入的是字母");
		}else if(ch >= '0' && ch <= '9') {
			System.out.println("输入的是数字");
		}else if(ch >= '\u4E00' && ch <= '\u9FA5') { // 常用汉字范围4E00-9FA5
			System.out.println("输入的是汉字");
		}else {
			System.out.println("输入其他字符");
		}
		scanner.close();
	}
}

3.键盘输入年、月、日，判断输入的日期是当前这一年的第几天

巧妙使用switch的穿透

public class Test9 {
	public static void main(String[] args) {
		// 经典题：键盘输入年、月、日，判断输入的日期是当前这一年的第几天
		int year = 2020;
		int month = 7;
		int day = 22;
		
		int num = 0; // 一年中的第几天
		switch(month) {
		case 12:
			num = num + 31;			
		case 11:
			num = num + 30;	
		case 10:
			num = num + 31;	
		case 9:
			num = num + 30;	
		case 8:
			num = num + 31;	
		case 7:
			num = num + 31;	
		case 6:
			num = num + 30;	
		case 5:
			num = num + 31;	
		case 4:
			num = num + 30;	
		case 3:
			num = num + 31;	
		case 2:
			// 判断是不是闰年year
			num = num + 29;	
		case 1:
			num = num + 31;	
		default:
			System.out.println("输入月份错误");
			break;
		
		}
	}

}

另一种方法，用for循环 + if 判断

public class Test10 {
	public static void main(String[] args) {
		// 经典题：键盘输入年、月、日，判断输入的日期是当前这一年的第几天
		int year = 2019;
		int month = 12;
		int day = 31;
		
		int num = 0; // 一年中的第几天
		for(int i = 1;i < month;i++) {
			if(i == 1 || i == 3 || i == 5 || i == 7 || i == 8 || i == 10 || i == 12) {
				num += 31;
			}else if(i == 4 || i == 6 || i == 9 || i == 11) {
				num += 30;
			}else {
				if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0 ) {
					num += 29;
				}else {
					num += 28;
				}
			}
		}
		num += day;
		System.out.println(year+"年"+month+"月"+day+"天"+ "是第"+num+"天");
	}
}

4.产生随机数的案例

• 总结公式：产生m~n之间的随机整数
• random.nextInt(n-m+1) + m

import java.util.Random;

public class Test2 {
	public static void main(String[] args) {
		//1.随机数类
		Random random = new Random();
		// 产生一个随机数，[0,3)左闭右开
		int nextInt = random.nextInt(3); 
		System.out.println(nextInt);
		
		// 练习1：获取随机数65~90
		int num = random.nextInt(26)+65;
		// 练习2：获取随机的4位数(产生4位数的验证码）1000~9999
		int num1 = random.nextInt(9000) + 1000;
		/*
		 * 总结公式：产生m~n之间的随机整数
		 * random.nextInt(n-m+1) + m
		 */
		// 1.java.lang下的类型不需要进行导包
		System.out.println(Math.PI);
		// 2.开根号
		double sqrt = Math.sqrt(3);
		// 3.三元运算符求绝对值
		int number = -20;
		int abs = number < 0 ? -number:number;
		System.out.println(abs);
		// 4.向上取整
		double ceil = Math.ceil(1.9);
		double floor = Math.floor(2.5);
		
		// 5.产生随机数
		System.out.println(Math.random()); // [0,1)之间的double数据
		// 需求：[1000,10000]
		// [0,1)*9000 + 1000 = [0,9000) + 1000 = [1000,10000)
		// 向上取整 Math.ceil()
		// 再强制转
	}
}

---

总结

1.while循环+break的组合使用；
2.逻辑控制词continue，break，return的灵活使用；
3.递归思想初步，自己调用自己；
4.try-catch异常捕获初步；