03Java基础语法（逻辑运算符、位运算符、三元运算符、Scanner、流程控制语句（顺序结构、分支结构、循环结构））

复习

//运算符：操作变量和常量的符号
/*
 * 算术运算符：+ - * / % ++ --
 * 赋值运算符：= += -= *= /= %= 自动强制类型转换
 * 关系运算符：== < > != >= <= instanceof 结果永远是boolean类型
 * */

1、逻辑运算符

2、位运算符

3、三元运算符

4、Scanner

5、流程控制语句

1、逻辑运算符

注意事项：

• 逻辑运算符一般用于连接boolean类型的表达式或者值
  在Java中我们要表示一个数大于3并且小于6 ，不可以写成3<x<6，应该写成 x>3 & x<6
• 表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子
  算术表达式：a + b
  关系表达式：a == b

逻辑运算符的结果同样是boolean类型

&(并且)：&两端条件同时成立，返回true；两端只要有一个false，结果为false；

int a = 20;
int b = 10;
System.out.println((a > b) & (a != b));
//true & true = true
System.out.println((a > b) & (a == b));
//true & false = false

|(或者)：|两端条件只要有一个满足，返回true；两端结果都为false，结果为false；

int a = 20;
int b = 10;
System.out.println((a > b) | (a < b));
//true
System.out.println((a == b) | (a < b));
//false

!(非)：取反，true变false，false变true；

System.out.println(!true);
//false
System.out.println(!false);
//true

^(异或)：相同为false，不同为true；

System.out.println(true ^ true);
//false
System.out.println(false ^ true);
//true
System.out.println((2 == 3) ^ (2 < 3));
//true

&&(短路与)：

&和&&在运算结果上没有区别，在运算效果上有区别。

（&&左边的结果为false时，那么将不执行&&右边的表达式）

（&&左边的结果为true时，才会执行&&右边的表达式）

int a = 20;
int b = 20;
boolean flag = (a < b) && (a++ > b); //a < b判断为false，那么a++没有执行
System.out.println(flag);
//false
System.out.println(a);
//20
System.out.println(b);
//20

int a = 20;
int b = 20;
boolean flag = (a < b) & (a++ > b); //a < b判断为false，a++依然执行了
System.out.println(flag);
//false
System.out.println(a);
//21
System.out.println(b);
//20

||(短路或)：

|和||在运算结果上没有区别，在运算效果上有区别。

（||左边结果为true时，那么将不执行||右边的表达式）

（||左边结果为false时，才会执行||右边的表达式）

int c = 20;
int d = 20;
boolean flag = (c == d) || (c++ > d); //c == d结果为true，直接不计算c++
System.out.println(flag);	
//true
System.out.println(c);
//20
System.out.println(d);
//20

int c = 20;
int d = 20;
boolean flag = (c == d) | (c++ > d); //c == d结果为true，依然要执行右边的表达式
System.out.println(flag);
//true
System.out.println(c);
//21
System.out.println(d);
//20

2、位运算符

两端是数值，按照位运算符，两端是boolean类型，按照逻辑运算符。

位运算按照数值的补码进行运算，效率较高。

&(与)：两个都为1的情况下，&结果为1；只要有一个0，&结果为0；

System.out.println(3 & 4);
//0011 & 0100 = 0000
//0

|(或)：两个只要有一个为1，|结果为1；两个都为0，|结果为0；

System.out.println(3 | 4);
//0011 | 0100 = 0111
//7

^(异或)：相同为0，不同为1；

System.out.println(4 | 4);
//0100 | 0100 = 0000
//0

~(按位取反)：0变1，1变0，包括符号位；

System.out.println(~9);
//0000 1001 -> 补码：11110110 -> 反码：11110101 ->原码：1000 1010 = -10
//-10

<<(左移)：空位补0，被移除的高位丢弃；

System.out.println(3 << 2);
//0011 -> 1100
//12

System.out.println((byte)(127 << 1));
//0111 1111 -> 丢弃高位 -> 补码：1111 1110 -> 反码：1111 1101 -> 原码：1000 0010 = -2
//-2

>>(右移)：正数高位补0，负数高位补1；

System.out.println(3 >> 2);
//0011 -> 0000
//0

>>>(无符号右移)：无论是正数还是负数，最高位都补0；

位运算的特点：

^位异或：
相同则0，不同则1.

• 一个数异或另一个数两次，结果不变

System.out.println(3 ^ 8 ^ 8);
//相当于3 ^ 0 = 3

• 自己和自己位异或结果为0

System.out.println(3 ^ 3);
//0

• <<：左边的数乘以2的移动次幂

System.out.println(10 << 3);
//80

• >>：左边的数除以2的移动次幂

System.out.println(40 >> 3);
//5
System.out.println(-40 >> 3);
//-5

位运算符效率较高。

值交换的案例：

• 方式一：采用中间变量

int a = 10;
int b = 20;

//方式一：采用中间变量
int c = a;
a = b;
b = c;
System.out.println(a);
//20
System.out.println(b);
//10

• 方式二：位异或运算

int a = 10;
int b = 20;

//方式二：异或运算
a = a ^ b;
b = a ^ b; //b = a
a = a ^ b; //a = (a ^ b) ^ a = b
System.out.println(a);
//20
System.out.println(b);
//10

• 方式三：加减运算

int a = 10;
int b = 20;

//方式三：加减运算
a = a + b;
b = a - b; //b=a
a = a - b; //a=a+b-a=b
System.out.println(a);
//20
System.out.println(b);
//10

3、三元运算符

//三元(目)运算符语法：表达式 ? 结果1 : 结果2;
//如果表达式的值为true，返回结果1；为false，返回结果2；
int a = 50;
int b = 100;
int max = a > b ? a : b;
System.out.println(max);
//100

int a = 50;
int b = 100;
int c = 200;
int max = c > (a > b ? a : b) ? c : (a > b ? a : b);
//IDEA建议修改为int max = Math.max(c, (Math.max(a, b)));
System.out.println(max);
//200

4、Scanner

Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int a = scanner.nextInt();
System.out.println("请输入第二个整数：");
int b = scanner.nextInt();
int max = (a > b) ? a : b;
System.out.println("最大值为" + max);

快捷键：

1、alt + enter

2、ctrl + alt + V

自动补全，没有选项

3、.sout

自动补全System.out.println()

• hasNext（） 是检测 还有没有下一个输入
• next（）是指针移动到当前下标，并取出下一个输入
• nextLine（） 把指针移动到下一行 让然后取出当前这一行的输入
• hasNextLine（） 是检测下一行有没有输入

一般情况下，hasNextLine()和nextLine()搭配使用，hasNext()和next()搭配使用，hasNextInt()和nextInt()搭配使用。

面试题中的输入输出

1、样例

Scanner sc = new Scanner(System.in);
while (sc.hasNextInt()) {
    int a = sc.nextInt();
    int b = sc.nextInt();
    System.out.println(a + " + " + b + " = " + (a + b));
}

5、流程控制语句

• 顺序结构
• 选择结构
• 循环结构

选择结构

• if-else
• switch-case

if语句

if语句格式一：

if(关系表达式或者是boolean类型的值) {
	语句体;
}

a:关系表达式无论简单还是复杂，结果必须是boolean类型
b:if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略。

if语句格式二：

if(关系表达式) {
	语句体1;
}else {
	语句体2;
}

注意事项：else后面是没有比较表达式的，只有if后面有。

三元运算符实现的，都可以采用if语句实现。反之不成立。

什么时候if语句实现不能用三元改进呢?
当if语句控制的操作是一个输出语句的时候就不能。
为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。

if语句格式三：

if(关系表达式1) {
	语句体1;
}else if(关系表达式2) {
	语句体2;
}else if(关系表达式3) {
	语句体3;
}
...
else {
	语句体n+1;
}

分支结构的if-else if-else，只会进入一个分支。

switch格式：

switch(表达式){
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	case 值3:
		语句体3;
		break;
	....
	default：	
		语句体n+1;
		break;
}

执行流程：
先计算表达式的值
然后和case后面的匹配，如果匹配成功就执行对应的语句，遇到break就会结束,否则执行default控制的语句

switch注意事项

• switch语句所支持的类型，byte、short、char、int，JDK 1.5之后支持枚举类型，JDK 1.7之后支持String类型；
• case 匹配项：case后面只能跟常量，不能跟变量，多个case的值不能重复；
• default：所有case项都没有匹配上，那就执行默认项，不是必须要提供的，也不是说一定要放在最后面，放在哪都行；（无论default写在哪里，总是先来匹配case后的常量，如果都没有匹配上，执行default）
• break：用来结束switch语句，你忘了写或者故意不写，语法不报错，但是会发生case穿透，你可以利用这种现象；
• switch语句的结束条件，遇到break就结束了或者执行到末尾就结束了；

int x = 2;
int y = 3;
switch (x) {
    default:
        y++;
        break;
    case 3:
        y++;
    case 4:
        y++;
}
System.out.println("y = " + y);
//y = 4

int x = 2;
int y = 3;
switch (x) {
    default:
        y++;
    case 3:
        y++;
    case 4:
        y++;
}
System.out.println("y = " + y);
//y = 6
//首先没有匹配的项，直接执行default，y++，没有break，所以直接跳到case 3下的y++和case 4下的y++。

Scanner scanner = new Scanner(System.in);
int month = scanner.nextInt();
switch (month) {
    case 3:
    case 4:
    case 5:
        System.out.println("春季");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("夏季");
        break;
    case 9:
    case 10:
    case 11:
        System.out.println("秋季");
        break;
    case 12:
    case 1:
    case 2:
        System.out.println("冬季");
        break;
}

if和switch的选择：

if语句使用场景：

• 针对结果是boolean类型的判断 if(sc.hasNext()) boolean类型
• 针对一个范围的判断 if(month >= 3 && month <= 5)
• 针对几个常量值的判断 if(date == 1)

switch语句使用场景：

• 针对几个常量值的判断

循环结构

for循环

for(初始化表达式语句;判断条件语句;控制条件语句) {
	循环体语句;
}

1、初始化表达式语句只执行一次
2、判断条件语句无论简单还是复杂结果是boolean类型。
3、循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。

for (int i = 0; i < 10; i++) {
    System.out.println("I love you.");
}
/*
1、int i = 0：循环的初始值；初始化语句只执行一次
2、i < 10：循环的条件；当这个条件为true时，执行循环体；当这个条件为false时，循环终止；
3、{}循环体
4、i++：控制循环的语句
返回2继续判断，如果为true，继续第三步，然后第四步，直到2返回false，退出循环
*/

快速生成for循环：循环次数.for

int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println("1到100的和为" + sum);
//1到100的和为5050

int sum = 0;
for (int i = 1; i <= 100; i += 2) {
    sum += i;
}
System.out.println("1到100的奇数和为" + sum);
//1到100的奇数和为2500

int sum = 0;
for (int i = 0; i <= 100; i += 2) {
    sum += i;
}
System.out.println("1到100的偶数和为" + sum);
//1到100的偶数和为2550

int sumJi = 0;
int sumOu = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 2 == 1) {
        sumJi += i;
    } else {
        sumOu += i;
    }
}
System.out.println("1到100的奇数和为" + sumJi);
//1到100的奇数和为2500
System.out.println("1到100的偶数和为" + sumOu);
//1到100的偶数和为2550

判断水仙花数

int count = 0;
//水仙花数：三位数
for (int i = 100; i < 1000; i++) {
    int ge = i % 10;
    int shi = (i / 10) % 10;
    int hundred = (i / 100) % 10;
    int res = ge * ge * ge + shi * shi * shi + hundred * hundred * hundred;
    if (res == i) {
        System.out.println(res + "是水仙花数.");
        count++;
    }
    //153是水仙花数.
    //370是水仙花数.
    //371是水仙花数.
    //407是水仙花数.
}
System.out.println("共有" + count + "个水仙花数.");
//共有4个水仙花数.

while循环

初始化条件语句;
while(判断条件语句) {
	循环体语句;
	控制条件语句;
}

do...while循环

初始化条件语句;
do {
	循环体语句;
	控制条件语句;
}while(判断条件语句);

三种循环的区别：

(1):do...while循环至少执行一次循环体，而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
(2):A： 如果你想在循环结束后，继续使用控制条件的那个变量，用while循环（初始化语句在循环外面，循环结束还可以使用），否则用for循环（初始化语句在循环里，循环外不能使用）;
	B:建议优先考虑for循环，然后是while循环 ，最后是do...while循环

死循环：

public static void main(String[] args) {
    for (;;) {
        System.out.println("死循环");
    }
    // System.out.println();
    // 编译错误，上面是死循环，Unreachable Statement，不能到达该语句
}

while(true){...}

循环嵌套输出四行五列的小星星（外循环控制行数、内循环控制列数）

for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 5; j++) {
        System.out.print("*");
    }
    System.out.println();
}

循环嵌套输出三角形（外循环控制行数、内循环控制列数）

for (int i = 0; i < 5; i++) {
    for (int j = 0; j <= i; j++) {
        System.out.print("*");
    }
    System.out.println();
}

循环嵌套输出九九乘法表

for (int i = 1; i < 10; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print(j + "*" + i + "=" + (j*i) + "\t");
    }
    System.out.println();
}