3. JAVA逻辑控制

3. 逻辑控制

3.1 逻辑运算

3.1.1 布尔类型及其运算

• 主要包括与（&）、或（|）、非（！）、异或（^）
• 直接上代码

public static void main(String[] args) {
		// boolean表示布尔类型，该类型的变量只允许两个取值，即true和false
		boolean zhen = true; // true表示为真
		boolean jia = false; // false表示为假
		// “!”加在布尔变量前面表示开展“非”运算。若原变量值为true则运算结果为false，若原变量值为false则运算结果为true
		boolean not = !zhen;
		// “&”放在两个布尔变量之间表示开展“与”运算。只有两个变量都为true时，运算结果才为true，其余情况的运算结果都为false
		boolean and = zhen & jia;
		// “|”放在两个布尔变量之间表示开展“或”运算。只要两个变量有一个为true，运算结果就为true。只有两个变量都为false时，运算结果才为false
		boolean or = zhen | jia;
		// “^”放在两个布尔变量之间表示开展“异或”运算。当两个变量同为true或者同为false时，运算结果为false。当两个变量一个为true另一个为false时，运算结果为true
		boolean xor = zhen ^ jia;
		boolean value = true; // 为布尔变量赋初始值
		// 对布尔变量做“与”运算，且运算结果仍旧保存在该变量中，则可使用运算符“&=”
		value &= false; // 该行代码等同于 value = value&false;
		// 对布尔变量做“或”运算，且运算结果仍旧保存在该变量中，则可使用运算符“|=”
		value |= true; // 该行代码等同于 value = value|true;
		// 对布尔变量做“异或”运算，且运算结果仍旧保存在该变量中，则可使用运算符“^=”
		value ^= false; // 该行代码等同于 value = value^false;
	}

3.1.2 关系运算符
主要包括等于（==）、不等于（！=）、大于（>）、小于(<)、大等于(>=)、小等于(<=)

• 运算符的优先级顺序：优先级从高到低
• 1. 算术运算符：正负号>乘除、取余>加减
• 2. 逻辑运算符（非）：非
• 3. 关系运算符：大于、等于、小于、不等于
• 4. 逻辑运算符（其他）：与、或、异或
• 5. 赋值运算符：赋值号

简单总结一下：

• 如果没有圆括号加以约束，对于数值变量来说，几种运算符的优先级顺序依次为
• 正号、负号>乘号、除号、取余>加号、减号>大于、小于、等于、不等>各种赋值符号
• 对于bool变量来讲，相关运算符的优先顺序为
• 逻辑非>等号、不等号>逻辑与、或、异或>各种赋值符号
• 来一段代码方便理解：

public static void main(String[] args) {
		// 比较加减乘除以及取余数运算的优先级顺序
		int fiveArithmetic = 7 + 5 - 4 * 6 / 3 % 9; // 等价于“7+5-(4*6/3%9)”
		// 比较负号与乘除运算的优先级顺序
		int negativeArithmetic = -8 / 4 + 2 * -3; // 等价于“(-8)/4+2*(-3)”
		// 以下比较算术运算符和关系运算符的优先级顺序
		boolean greaterResult = 1 + 2 > 3 + 4; // 等价于“(1+2)>(3+4)”
		boolean lessResult = 1 + 2 < 3 + 4; // 等价于“(1+2)<(3+4)”
		// 比较逻辑与运算以及关系运算符的优先级顺序
		boolean andResult = 1 > 2 & 3 < 4; // 等价于“(1>2)&(3<4)”
		// 比较逻辑或运算以及关系运算符的优先级顺序
		boolean orResult = 1 > 2 | 3 < 4; // 等价于“(1>2)|(3<4)”
		// 比较逻辑异或运算以及关系运算符的优先级顺序
		boolean xorResult = 1 > 2 ^ 3 < 4; // 等价于“(1>2)^(3<4)”
		// 比较逻辑非运算以及关系运算符的优先级顺序
		boolean zhen = true;
		boolean jia = false;
		boolean notResult = zhen == !jia; // 等价于“zhen==(!jia)”
	}

3.1.3 按位逻辑和短路逻辑

• 逻辑运算符不是只对布尔类型变量起作用，同样的，他可以对数字做运算

public static void main(String[] args) {
		// 3的二进制为00000011，7的二进制为00000111
//		int andNumber = 3&7;  // 对两个数字开展“按位与”运算
//		System.out.println("andNumber="+andNumber);
//		int orNumber = 3|7;  // 对两个数字开展“按位或”运算
//		System.out.println("orNumber="+orNumber);
//		int xorNumber = 3^7;  // 对两个数字开展“按位异或”运算
//		System.out.println("xorNumber="+xorNumber);

		// 3的二进制为00000011，7的二进制为00000111
		int andNumber = 1 + 2 & 3 + 4; // 等价于“(1+2)&(3+4)”
		System.out.println("andNumber=" + andNumber);
		int orNumber = 1 + 2 | 3 + 4; // 等价于“(1+2)|(3+4)”
		System.out.println("orNumber=" + orNumber);
		int xorNumber = 1 + 2 ^ 3 + 4; // 等价于“(1+2)^(3+4)”
		System.out.println("xorNumber=" + xorNumber);
		
		// 下面写法是错误的，因为“与”、“或”、“异或”的优先级低于关系运算符
		// boolean logicalResult = 1&2 > 3|4;
		// 下面写法是正确的，使用圆括号把需要先计算的语句括起来
		boolean logicalResult = (1 & 2) > (3 | 4);
		System.out.println("logicalResult=" + logicalResult);
		int i = 1, j = 1;
		// 对于按位逻辑运算，需要等待左右两边都计算完毕，然后进行按位逻辑判断
		boolean result1 = 3 > 4 & ++i < 5;
		System.out.println("result1=" + result1 + ", i=" + i);
		// 对于短路逻辑运算，一旦左边的计算能够确定结果，就立即返回判断结果，不再进行右边的计算
		boolean result2 = 3 > 4 && ++j < 5;
		System.out.println("result2=" + result2 + ", j=" + j);
	}

输出为：

andNumber=3
orNumber=7
xorNumber=4
logicalResult=false
result1=false, i=2
result2=false, j=1

3.2 控制语句

3.2.1 条件分支

• 在生活中，常有岔路口，代表我们要做选择，条件分支一般是if / else为例，具体格式为：
• if(条件){条件成立时的操作代码}else{条件不成立时的操作代码}，见下面例子
• 这里就对两种条件分开判断，输入不同的键值能够揭晓不同的谜底
• 同时还应注意在Java中，从控制台接受输入文本语句的写法：

Scanner scan = new Scanner(System.in); 
int seq = scan.nextInt();

public static void main(String[] args) {
		System.out.println("凉风有信，秋月无边。打二字");
		System.out.println("获取“凉风有信”的谜底请按1，获取“秋月无边”的谜底请按2");
		Scanner scan = new Scanner(System.in); // 从控制台接收输入文本
		int seq = scan.nextInt(); // nextInt方法表示接收一个整数，以回车键结尾
		if (seq == 1) { // 按1时打印“凉风有信”的谜底
			System.out.println("凉风有信的谜底是“讽”");
		}
		if (seq == 2) { // 按2时打印“秋月无边”的谜底
			System.out.println("秋月无边的谜底是“二”");
		}
	}

• 代码改写：
• 式子A？式子B：式子C，代替了if / else的结构

public static void main(String[] args) {
		System.out.println("凉风有信，秋月无边。打二字");
		System.out.println("获取“凉风有信”的谜底请按1，获取“秋月无边”的谜底请按2");
		Scanner scan = new Scanner(System.in); // 从控制台接收输入文本
		int seq = scan.nextInt(); // nextInt方法表示接收一个整数，以回车键结尾
		// “式子A ? 式子B : 式子C”里的问号加冒号构成了一个三元运算符，
		// 当式子A成立时，运算结果为B，否则（式子A不成立）结果为C
		seq = seq == 1 ? 1 : 2; // 等价于 seq = (seq==1)?1:2
		if (seq == 1) { // 按1时打印“凉风有信”的谜底
			System.out.println("凉风有信的谜底是“讽”");
		}
		if (seq == 2) { // 按2时打印“秋月无边”的谜底
			System.out.println("秋月无边的谜底是“二”");
		}
	}

3.2.2 多路分支

• 直接看代码

public static void main(String[] args) {
		System.out.println("凉风有信，秋月无边。打二字");
		System.out.println("获取“凉风有信”的谜底请按1，获取“秋月无边”的谜底请按2");
		Scanner scan = new Scanner(System.in); // 从控制台接收输入文本
		int seq = scan.nextInt(); // nextInt方法表示接收一个整数，以回车键结尾
		if (seq == 1) { // 条件式子1为真时，进入第一个if分支处理
			System.out.println("凉风有信的谜底是“讽”");
		} else if (seq == 2) { // 否则的话，继续判断条件式子2为真时，进入第二个if分支处理
			System.out.println("秋月无边的谜底是“二”");
		} else { // 否则（前面的判断条件都不满足），进入else分支处理
			System.out.println("您的按键有误");
		}
	}

• 或者用 switch case 改写：
• 除了switch和case两个关键字以外，还有break和default两个关键字
• break的作用是跳出整个多路分支，不再执行本分支或剩余分支的代码
• default相当于else，不满足已知条件的情况全部放入default分支进行处理
• 使用多路分支需要注意：
• 每个case后面务必加一个break语句，否则将会死循环
• 多路分支只能判断整型、字符型和枚举型的变量，对于布尔。浮点、双精度等不能判断
• case只能做相等判断，不能进行其他关系运算

	public static void main(String[] args) {
		System.out.println("凉风有信，秋月无边。打二字");
		System.out.println("获取“凉风有信”的谜底请按1，获取“秋月无边”的谜底请按2");
		Scanner scan = new Scanner(System.in); // 从控制台接收输入文本
		int seq = scan.nextInt(); // nextInt方法表示接收一个整数，以回车键结尾
		// switch允许判断某个变量的多个取值，并分别进行单独处理
		switch (seq) {
		case 1: // seq值为1时进入该分支
			System.out.println("凉风有信的谜底是“讽”");
			break; // 跳出多路分支。即跳到switch分支的右花括号之后
		case 2: // seq值为2时进入该分支
			System.out.println("秋月无边的谜底是“二”");
			break; // 跳出多路分支。即跳到switch分支的右花括号之后
		default: // seq值为其它时进入该分支
			System.out.println("您的按键有误");
			break; // 跳出多路分支。即跳到switch分支的右花括号之后
		}
		System.out.println("猜谜结束");
	}

3.2.3 while 循环

• 直接上代码

public static void main(String[] args) {
		System.out.println("长夜漫漫，无心睡眠，请给他设定一个睡醒的年限");
		Scanner scan = new Scanner(System.in); // 从控制台接收输入文本
		int limit = scan.nextInt(); // nextInt方法表示接收一个整数，以回车键结尾
		int year = 0;
		while (year < limit) { // 当条件满足时，在循环内部持续处理
			System.out.println("已经过去的年份：" + year);
			year++;
		}
		System.out.println("他足足睡了这么多年：" + year);
	}

• 将 while 改成 do while 类型的

public static void main(String[] args) {
		System.out.println("长夜漫漫，无心睡眠，请给他设定一个睡醒的年限");
		Scanner scan = new Scanner(System.in); // 从控制台接收输入文本
		int limit = scan.nextInt(); // nextInt方法表示接收一个整数，以回车键结尾
		int year = 0;
		do { // 开始循环处理
			System.out.println("已经过去的年份：" + year);
			year++;
		} while (year < limit); // 当条件满足时，在循环内部持续处理
		System.out.println("他足足睡了这么多年：" + year);
	}

3.2.4 for 循环

public static void main(String[] args) {
		System.out.println("长夜漫漫，无心睡眠，请给他设定一个睡醒的年限");
		Scanner scan = new Scanner(System.in); // 从控制台接收输入文本
		int limit = scan.nextInt(); // nextInt方法表示接收一个整数，以回车键结尾
		for (int year = 0;; year++) {
			System.out.println("已经过去的年份：" + year);
			if (year >= limit) { // 这里判断能否跳出循环
				System.out.println("他足足睡了这么多年：" + year);
				break; // 跳出循环。即跳到for循环的右花括号之后
			} else {
				continue; // 继续下一次循环。此时先执行year++，再执行循环内部语句
			}
		}
	}

逻辑控制就说到这，下次说说java中的数组！拜~