【JavaSE 第三天】

运算符

1.算术运算符

++ 自增（前）先运算后取值 a=2； b=a++ a是3，b是3
++ 自增（后）先取值后运算 a=2；b=++a a是3，b是2

除法：两个整数做除法，如果不能整除，会自动舍弃小数部分
除以零的过程中会报错，数学错误

取模也叫取余被取模的数值为负是，取模的结果也为负
取模结果是正数还是负数看被取模的数值是正数还是负数
小数取模结果可能是小数

// 字符串的连接
boolean operatorJoin01 = true;
float operatorJoin02 = 3.55f
System.out.println("" + operatorJoin01 + operatorJoin02);
// 自增一 
// 先取值后加
int operatorIncrease01 = 10;
int increaseResult = operatorIncrease01++;
System.out.println("10 increaseResult = "+increaseResult);
System.out.println("11 operatorIncrease = "+operatorIncrease01);
// 先加后取值
operatorIncrease01 = 10;
increaseResult = ++operatorIncrease01;
System.out.println("11 increaseResult = "+increaseResult);
System.out.println("11 operatorIncrease = "+operatorIncrease01);
//自减一
//先取值后减
int operatorDecrease = 10;
int decreaseResult = operatorDecrease--;
System.out.println("10 decreaseResult="+decreaseResult);
System.out.println("9 operatorDecrease="+operatorDecrease);
//先减后取值
operatorDecrease = 10;
decreaseResult = --operatorDecrease;
System.out.println("9 decreaseResult="+decreaseResult);
System.out.println("9 operatorDecrease="+operatorDecrease);

2.赋值运算符

运算的方向：从右往左运算
连续赋值运算

        int x;
        int y;
        int z;
        x=y=z=10;
        //第一步：z=10； 整个赋值表达式的值是10
        //第二部：把z=10赋值表达式的值10赋给y
        //第三步：把y=10赋值表达式的值赋给x

运算实例1：

short s=3;
//s=s+2;  //byte short char进行算数运算时要变为int类型相当于将short类型放入int类型中可能放不进去 不兼容的类型需要
s=(short)(s+2);
s+=2;//编译可以通过，说明 += 的操作底层会有自动的类型转换

运算实例2：

int i=1;
i*=0.1;
//第一步：1*0.1 结果应该是0.1
//第二步：因为i是int类型所以舍弃小数部分，变为了0；
System.out.println(i);

运算实例3：

int m=2;
int n=3;
n*=m++;
//第一步：m++ 先取值，得到2
//第二步：用2和n执行"*="的操作，就是n=n*2

运算实例4：

int n=10;
n+=(n++)+(++n)
//第一步：取n的值用来做加法
//第二步：++n先加再取值，n变为11
//第三步：执行加法，得到21
//第四步：计算 += 的操作 n=n+21
//第五步：计算n++里面的自增1，得到33
//但结果是32
//运用 java -c 文件名操作
//根据反编译字节码文件，看到实际的执行过程
//不符合常见的逻辑原则
//不建议的写法 不要写这样有歧义的

运用 java -c 文件名操作

3.比较运算符

instanceof 运算：检查是否是类的对象
规范："Hello"instanceof String
结果：true

//检查左边的对象是否是右边指定类型的对象
System.out.println("Hello" instanceof String);

4.逻辑运算符

& 逻辑与（且）
&& 逻辑且（有短路效果）
| 逻辑或
|| 逻辑或
! 逻辑取反
^ 逻辑异或（不同返回true）

boolean a=true;
boolean b=true;
// 逻辑与：不带短路效果
System.out.println(a&b);
//逻辑与：带有短路效果 前面是false后面就不必执行
System.out.println(a&&b);

        boolean a=false;
        boolean b=true;
        int i=10;
        //逻辑与，不带短路效果
        System.out.println(a&(i++>5));
        System.out.println("i="+i);//11
        //逻辑与，带短路效果
        System.out.println(a&&(i++>5));
        System.out.println("i="+i);//11
        //逻辑或，不带短路效果
        System.out.println(b|(i++>5));
        System.out.println("i="+i);//12
        //逻辑或，带短路效果
        System.out.println(b||(i++>5));
        System.out.println("i="+i);//12

通常写程序用带短路效果的

5.位运算符

运算符	运算	范例	运算结果
<<	左移	3<<2	12
>>	右移	4>>1	2
>>>	无符号右移	3>>>1	1
&	按位与	6&3	2
或	按位或	6 或 3	7
^	按位异或	6^3	5
-	按位取反	-6	-7

** 或 **
** | 符号 **

运算符	运算方式
<<	空位补0，被移除的高位丢弃，空缺位补0。
>>	当最高位是0，右移后，空缺位补0，当最高位是1，空缺位补1。
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补。
&	二进制位进行&运算，只有1&1时结果是1，否则是0;
“或”	二进制位进行"或"运算，只有0"或"0时结果是0，否则是1;
^	二进制位相同是0，二进制位不同是1
~	按补码取反

在二进制中进行移动

        //左移操作
        //正数左移
        int i=0b00101100;
        System.out.println("i="+Integer.toBinaryString(i));//用二进制来表示
        int j=i<<2;
        //00101100
        //01011000
        //10110000
        System.out.println("j="+Integer.toBinaryString(j));//用二进制来表示
        System.out.println("j="+j);
        //负数的左移
        int x=-0b00101100;
        int y=x<<1;
        System.out.println("x="+x);
        System.out.println("x="+Integer.toBinaryString(x));//用二进制来表示
        System.out.println("y="+Integer.toBinaryString(y));//用二进制来表示
        System.out.println("y="+y);
        //最大值的基础上左移一位
        int maxValue=Integer.MAX_VALUE;
        System.out.println("maxValue=0"+Integer.toBinaryString(maxValue));
        maxValue=maxValue<<1;
        System.out.println("maxValue="+Integer.toBinaryString(maxValue));
        System.out.println("maxValue="+maxValue);

相当于左移乘2
右移除以2

6.三元运算符

        int i=10;
        int j=20;
        String result=(i>j)?"i比j大":"i比j小";
        System.out.println(result);

流程控制

顺序结构

使用Scanner对象从控制台输入数据是暂时的

//导入Scanner类
import  java.util.Scanner;
public class Demo1 {
    public static void main(String[] args){
       //1.创建Scanner对象
        Scanner scanner=new Scanner(System.in);
        //2.读取int类型的数据
        System.out.println("请输入一个整数：");
        //调用scanner对象的nextInt()方法
        int age=scanner.nextInt();
        System.out.println("age="+age);
         //3.读取Boolean类型的数据
        System.out.println("请输入一个布尔值：");
        boolean flag=scanner.nextBoolean();
        System.out.println("flag="+flag);
        //4.读取字符串
        System.out.println("请输入一个字符串：");
        String stringValue=scanner.next();//next() 会因为空格终止读取
        System.out.println("stringValue="+stringValue);
        //nextLine() 方法不会因为空格而终止读取
        stringValue=scanner.nextLine();
        System.out.println("stringValue="+stringValue);
    }
}

分支结构

import java.util.Scanner;
public class Demo1 {
    public static void main(String[] args){
       //创建Scanner对象
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入i:");
        int i=scanner.nextInt();
        System.out.println("请输入j：");
        int j=scanner.nextInt();
        if(i>j){
            System.out.println("i比j大");
        }
        if(i<j){
            System.out.println("i比j小");
        }
        System.out.println("后续");
    }
}

if()…else…
if()…else if()…else…
switch…case… 语句

import java.util.Scanner;
public class Demo1 {
    public static void main(String[] args){
       //创建Scanner对象
       Scanner scanner=new Scanner(System.in);
       System.out.println("请输入一个季节:");
       String season=scanner.nextLine();
       switch (season){
           case "spring":
               System.out.println("春天");
               break;
           case "summer":
               System.out.println("夏天");
               break;
           case "autumn":
               System.out.println("秋天");
               break;
           case "winter":
               System.out.println("冬天");
               break;
           default:
           //当前面每一个都不匹配就执行它
               System.out.println("全部都");
       }
    }
}

1.switch（表达式）中表达式的可选值类型
(都是非常确定的值) byte,short,int,char,枚举,String
2.case 子句中指定的值必须是常量，不能是变量或不确定的表达式的值
同一个switch语句中所有case子句中的常量值必须互不相同
3.default 子句是可选的
default子句的位置是灵活的

冒泡排序

import java.util.Scanner;
public class Demo1 {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入：num1");
        int num1=scanner.nextInt();
        System.out.println("请输入：num2");
        int num2=scanner.nextInt();
        System.out.println("请输入：num3");
        int num3=scanner.nextInt();
        //定义空变量
        int swap=0;
        if(num1>num2){
            //交换变量
            swap=num1;
            num1=num2;
            num2=swap;
        }
        if(num2>num3){
            swap=num3;
            num3=num2;
            num2=swap;
            if(num1>num2){
                swap=num2;
                num2=num1;
                num1=swap;
            }
        }
        System.out.println("num1="+num1);
        System.out.println("num2="+num2);
        System.out.println("num3="+num3);
    }
}