2019-6-24 [JavaSE] 算术运算符 关系运算符 逻辑赋值运算符 条件运算符 位运算符 运算符优先级 控制台输入 流程控制语句 分支结构

1.算术运算符

自增自减运算符

代码分析一：
一元运算符
运算规则：
++ ： n ++ -> n = n + 1;
– : n – -> n = n - 1;
总结:
后缀: 赋值运算或输出语句中，先赋值运算或输出，后自增或自减；
前缀： 赋值运算或输出语句中，先自增或自减， 后赋值运算或输出。

            int n = 5;
            n ++; n = n + 1;
            -- n ;  n = n - 1;
            System.out.println(n);//5
			//---------------------------------
            int n = 5;
           int m = n ++;  m = n; m = 5; n = n + 1; n = 5 + 1;
           System .out.println(n + "," + m);// 6,5
            System .out.println(n ++);//5 先输出，再自增
            System .out.println(n);//6
            //-------------------------------------
            int n = 5;
            int m = ++ n; n = n + 1; n = 5 + 1; m = 6;
            System .out.println(n + "," + m);//6,6
            System .out.println(++ n); n = n + 1; n = 5 + 1;  6

2.关系运算符

运算的结果：boolean 类型 ：true 成立 ，false 不成立的。

   		int n1 = 5;
        int n2 = 6;
        System .out.println(n1 > n2);//false
        System .out.println(n1 == n2);// false
        System .out.println(n1 < n2); // true
        System .out.println(n1 <= n2);// true

3.逻辑运算符

&& ：与
|| :或
！ ：非

运算规则： && ：一假 （false) ,为 假(false);
|| : 一真（true),为 真(true);
! :取反

 		System .out.println(true && false);  // false
        boolean n1 = true;
        boolean n2 = true;
        System .out.println(n1 && n2);// true
                 false && false  -> false
        System .out.println( (5 > 6) && (7 == 8));
        System .out.println(!((5 > 6) && (7 == 8)));//!false -> true

&& ，|| 和 & ，|区别：
&& ，|| ：短路与，短路或；
& ， | ：（位运算符），非短路与 ，非短路或

        int n = 5;
        boolean r = false && ++ n > 6 && false && true;
        System .out.println(r);//false
        System .out.println(n);// 5
        //---------------------------------------------
        int n = 5;
        boolean r = false & ++ n > 6 & false & true;
        System .out.println(r);//false
        System .out.println(n);// 6

4.扩展赋值运算符

代码分析二：
运算规则： a += 5; -> a = a + 5;

  int n = 5;
        n += 5; n = n + 5；n = 5 + 5; n = 10;
        System.out.println(n);// 10

注意：扩展赋值运算符 可以 自动的隐式的 强制转换，会更安全。

    short n3 = 5;
        int  ->short 
              int
            int + int
          short + int
        n3 = n3 + 5;//出错：方式(short)
        System .out.println(n3);
        ----------------------------
        
        short n3 = 5;
        //   自动的隐式 强转
        n3 += 5; n3 =(short) (n3 + 5)
        System .out.println(n3);

5.条件运算符

？： 三元。
运算规则: 表达式 一 必须是boolean类型
当 表达式一 运算的结果 是true ,那么取 表达式二的值；
false,那么取表达式三的值。

  //            false
        String str = 5 < 3 ? "5大于3" : "5不大于3";
        System .out.println(str);

6.位运算符

& ： 与
规则： 两个 运算的位 都为 1 ，结果才能 为 1， 一个为0 ，结果就为0.
| : 或
规则： 两个运算的位 只要 有一个 为 1，结果就为 1.
^ :异或
规则： 两个运算的位 相同 为 0 ，不同为1
0 ， 0 1， 1 相同
0 ，1 1， 0 不同
~ :取反，非
1 取反 是 0 ， 0 取反 是 1

<< :左移
规则：向左 移动 n 位 ，右边 低位 用 0 补位。
重点规律:正数 ，移出去的都是0 ，那么 相等于 这个数 乘以 2的移动位数次方。num * 2 ^n
右移:>>
规则： 向右 移动 n 位 ，左边 高位 是什么用什么补位 ，是0用0补位，
是 1 用 1 补位。
规律： 相当于 这个数 除以 2的移动位数次方。 num / 2 ^n
无符号右移:>>>***
规则: 向右 移动 n 位 ，左边 高位 用 0 补位。
EG：
+5
-5
原码：
+ 5： 00000000-00000000-00000000-00000101
-5： 10000000-00000000-00000000-00000101
反码：
+5 ： 00000000-00000000-00000000-00000101
- 5： 11111111-11111111-11111111-11111010
补码：
+5：00000000-00000000-00000000-00000101
-5： 11111111-11111111-11111111-11111011 原码取反+1

  		System.out.println(5 & 2);\\0
        System .out.println(5 | 2);\\7
        System .out.println(5 ^ 2);\\7
        System .out.println(~5);\\-6
        System .out.println(5 << 2);\\20
        System .out.println(5 >> 2);\\1
        System .out.println(5 >>> 2);\\1
        System .out.println(-6 >>> 2);\\1073741822
        System .out.println(Integer.valueOf("111111111111111111111111111110",2));\\1073741822

7.运算符优先级

代码分析三：

8.控制台输入

语法：

import java.util.Scanner; //import java.util.*;
Scanner input = new Scanner(System.in);
input.nextInt(); //获得整数 int
input.nextDouble();// 获得小数  double
input.next();// 获得字符串

控制台输入 代码实例：

//导入 父包名.子包名.类型；
import java.util.Scanner;
//导入 Scanner类型  1.请超人
	public class Demo11 {
	public static void main(String[] args) {
//  2. 创建了一个超人
         //类型    对象名 = 创建  调用构造器（类.流对象）
		Scanner superman = new Scanner(System.in);
		System .out.print("请输入一个整数：");
            // 3.    对象名.方法名()    超人 工作 ，超人获得一个 整数
		int n = superman.nextInt();//11
		double n = superman.nextDouble();//11.11
		String n = superman.next();// n = "hello"字符     
		char n = superma.next().charAt(0);// n = +/*-（char类型）
		System .out.println(n);
		
	}
}

9.流程控制语句分类

9.1分类

顺序：从上而下顺序执行。
分支：根据条件不同，执行不同的语句。
循环：重复执行某些操作

9.2 流程图

10.分支结构语句

10.1 单分支

语法：


注意：
1.条件必须是 boolean数据类型
2.if只带 一行 代码 可以省略 大括号.

 Scanner superman = new Scanner(System.in);
        int score;
        System .out.println("输入成绩：");
        score = superman.nextInt();
        if (score >= 60){
            System .out.println("给吃饱饭");
            System .out.println("给买一瓶可乐");
        }
        System .out.println("其他代码");

10.2 双分支

注意：
1.else不能带条件的；
2. if,else只带 一行 代码 可以省略 大括号。

  Scanner superman = new Scanner(System.in);
        int score;
        System .out.println("输入成绩：");
        score = superman.nextInt();
        if (score >= 60)
            System .out.println("给吃饱饭");
        else
            System .out.println("抄写代码100遍");

11.编程：1.两个数字比较大小 2.三个数字求最大数

public class Demo8_exam {
	public static void main(String[] args) {
		//1.两个数字比较大小----------------------------------------------
		int n1 = 5;
		int n2 = 5;
		String str = n1 > n2 ? "n1大于n2" : n1 == n2 ? "n1等于n2":"n1小于n2";
		System.out.println(str);
		
		//2.三个数字求最大数------------------------------------------------
		int num1 = 5;
		int num2 = 6;
		int num3 = 7;
		int max = num1;
		max = max < num2 ? num2 : max;
		max = max < num3 ? num3 : max;
		System .out.println(max);
	}
}

12.编程：三种方法实现，两个变量互换。

/**
练习:
两个变量互换。
*/
public class Demo10_exam {
	public static void main(String[] args) {
//1. 定义第三个变量-----定义法------------------------------
		int a = 5;
		int b = 2;
		int temp ;
		temp = a;
		a = b;
		b = temp;
		System.out.println( a + "," + b);
//2 .算术方法-----------------------------------------------
		int a = 5;
		int b = 2;
		a = a + b;// 5 + 2 
		b = a - b;// 5 + 2 - 2 -》 5
		a = a - b;// 5 + 2 - 5 -》2
		System .out.println(a + "," + b);
		
//3 .位方法----------------------------------------------------
		int a = 5;
		int b = 2;
		a = a ^ b;// a = a ^ b
		b = a ^ b;// b = a ^ b ^ b;  b ->  a
		a = a ^ b;// a = a ^ b ^ a;  a ->  b
		System .out.println(a + "," + b);
	}
}

13.编程：1.输入两个数字，计算加减乘除 2.输入一个数字，判断奇偶

/**
练习：
控制台输入
*/
import java.util.Scanner;
public class Demo13_exam{
	public static void main(String[] args) {
//1.输入两个数字，计算加减乘除的结果--------------------------------
		Scanner superman = new Scanner(System.in);
		int n1,n2;
		System .out.println("--输入数字1：");
		n1 = superman.nextInt();
		System .out.println("--输入数字2：");
		n2 = superman.nextInt();
		System .out.println(n1 + "+" + n2 + "=" + (n1 + n2));
		System .out.println(n1 + "-" + n2 + "=" + (n1 - n2));
		System .out.println(n1 + "*" + n2 + "=" + (n1 * n2));
		System .out.println(n1 + "/" + n2 + "=" + (n1 / n2));
//2.输入一个数字，判断奇数和偶数.-----------------------------------
		int num;
		System .out.println("--输入一个数字：");
		num = superman.nextInt();
		String str = num % 2 == 0 ? "偶数" : "奇数";
		System .out.println(str);
	}
}

14.编程：1.判断闰年 2.有4位学号筛选出百位是6的 3.判断是否为3位数

import java.util.Scanner;
/**
练习：分支语句
*/
public class Demo16_exam {
	public static void main(String[] args) {
		Scanner superman = new Scanner(System.in);
//1.判断闰年：---------------------------------
//能被4整除但是不能被100整除，或者能被400整除
		int year;
		System .out.println("输入一个年：");
		year = superman.nextInt();
		if ((year%4 == 0 &&  year % 100 != 0) || year% 400 == 0){
			System .out.println("是闰年");
		}else{
			System .out.println("是平年");
		}
//2.百位 是6 ---------------------------------------------
		int num;
		System .out.println("--输入数字");
		num = superman.nextInt();//1234
		int n = num / 10 /10 % 10;
		if (n == 6){
			System .out.println("是幸运的");
		}else{
			System .out.println("谢谢参与");
		}
//3.判断3位数 100 - 999
		int number ;
		System .out.println("输入数字：");
		number = superman.nextInt();
		if (number >= 100 && number <= 999){
			System .out.println("是三位数");
		}else{
			System .out.println("不是");
		}
	}
}

15.注意：

1.短路的第一个被短路了，后面的都不需要运算了
例如好几个&&，第一个False了，则后面的都不用算的，直接输出false
||的第一个true，直接输出true，反之都运算。
2.扩展赋值运算符有着自动的隐式强转类型。
3.负数转正数，减一取反
正数转负数：取反加一
4.一个数字被另一个数字异或（^）两次，就会得到其本身
5.Import java.util .*;
这段代码表示util的所有包都导入，自然包括Scanner包
6.if，else如果只带一行代码，则可以省了｛｝