表达式自动提升类型

在程序中直接写出来的数字，如果是整数程序会默认是int类型，如果是小数程序会默认是double类型。

一个表达式中包含多种数据类型，结果的数据类型会自动提升，规则如下：

• byte,short,char会自动提升为int
• 整个表达式的类型会自动的提升到最高的数据类型

package com.HQYJ;

public class DataType {
    public static void main(String[] args) {
        float f1=3.14F;//直接写一个小数，默认为double类型
        int i1=2147483647;//直接写一个整数的数字，默认为int类型

        byte b1=3;
        byte b2=2;
        int sum1=b1+b2;//b1和b2自动提升为int类型

        short s1=3;
        short s2=2;
        int sum2=s1+s2;//s1,s2自动提升为int类型

        char c1='1';
        char c2='2';
        int sum3=c1+c2;//c1,c2自动提升为int类型
        System.out.println(sum3);//输出为99，char类型的数据相加输出的是它的ASCII码值

        long l1=8;
        long sum4=l1+s1+b1;//因为表达式中有一个long类型，所以整个表达式的结果自动提升为long类型
        
        //练习
        short s3=5;
        //s3=s3-2;//表达式中2是int类型，表达式的结果也应该为int类型，这个语句语法是错误的
        

    }
}

字面量（直接量）

在代码中直接出现的数字或者是字符串，叫做字面量。

//字面量
int m=20;//20称为字面量
float f5=3.14F;//3.14称为字面量
String str1="字符串";//字符串 称为字面量

自动装箱和自动拆箱

每一种基本类型都对应一种包装类型（类），基本类型与包装类型之间可以自动转换，

从基本类型转换为包装类型称为自动装箱

从包装类型转换为基本类型称为自动拆箱

package com.HQYJ;

public class Box {
    public static void main(String[] args) {
        int i=10;
        Integer integer=i;//基本类型直接赋值给包装类型，自动装箱
        int i2=integer;//包装类型直接赋值给基本类型，自动拆箱

        //包装类型常用的方法
        String str="123";//NumberFormatException：数字的格式异常
        Integer value = Integer.valueOf(str);//把字符串转换为Integer类型
        System.out.println(1 + value);
        int i1 = Integer.parseInt(str);//把字符串转换为int类型
        System.out.println(2 + i1);


    }
}

数字的格式异常：NumberFormatException

Java里的数据类型

运算符

运算符是一种特殊的符号，用于数据计算、赋值和比较。运算符将多个操作连接在一起，就成为了表达式。

Java运算符包含以下几类：

算术运算符

Java里的算术运算符包含：+ - * / % ++ –

• +运算符除了可以进行加法运算，还可以用来进行字符串的拼接

package com.HQYJ;

public class Opreater {
    public static void main(String[] args) {
        int sum1=3+2;
        String str1="加法的和等于：" + sum1;//+用于字符串，自动把后面int类型的数字转换为字符串
        System.out.println(str1);

        String str2=sum1 + "这个数的和";//字符串与其他类型拼接时与顺序无关
        System.out.println(str2);

        String str3="字符串与布尔类型拼接" + true;//字符串可以和所有的基本数据类型拼接
        System.out.println(str3);
    }
}

• -做减法运算
• *做乘法运算
• /做除法运算

整除的结果也为整数（舍弃小数部分）；整除时不能用0 作为除数。

浮点数相除结果有小数；浮点数相除0可以做除数，结果为Infinity(无穷大)

package com.HQYJ;

public class Opreater {
    public static void main(String[] args) {
        int res1=8/4;
        System.out.println("8/4=" + res1);
        //两个数相除，得到的结果是整数，舍弃了小数部分
        res1=8/3;
        System.out.println("8/3=" + res1);
//        res1=8/0;
//        System.out.println("8/0=" + res1);//整数做除法时0不能做除数，会抛出异常。ArithmeticException：算数异常

        double res2=8/2.5;//只要有一个操作数为小数，除出来的结果就是小数
        System.out.println("8/2.5=" + res2);
        res2=10/3.0;
        System.out.println("10/3.0=" + res2);//输出为：3.3333333333333335
        res2=5.0/0;
        System.out.println("5.0/0=" + res2);//输出为：Infinity（无穷大），浮点数做除法时除数可以为0
    }
}

算数异常：ArithmeticException

• %模运算用于得到除法的余数

整数取模，除数不能为0

小数取模，除数可以为0，得到的结果是NaN(Not a Number)

package com.HQYJ;

public class Opreater {
    public static void main(String[] args) {
        //取模运算
        int res1=5%3;//结果是余数
        System.out.println(res1);
//        res1=5%0;//模运算0不能作为除数
//        System.out.println("5%0=" + res1);
        double res2=5.0%3;
        System.out.println("5.0%3=" + res2);
        res2=5.1%3;
        System.out.println("5.1%3=" + res2);//2.0999999999999996


    }
}

• ++称为单目运算符(只有一个操作数)，自己加1，可以放在操作数左边或者右边。
• –同于++

package com.HQYJ;

public class Opreater {
    public static void main(String[] args) {
        //++ --的运算
        int k=1;
        res1=5+k++;//k先参与运算，然后再加1
        System.out.println(res1);//6
        System.out.println(k);//2
        int j=1;
        res1=5 + ++j;//操作数加1后参与运算
        System.out.println(j);//7
        System.out.println(k);//2

    }
}

赋值运算符

• =赋值运算，把=右边值赋给左边，右边的值可以是字面量，表达式，变量，方法调用

package com.HQYJ;

import java.util.Scanner;

public class Opreater {
    public static void main(String[] args) {
        int sum1=3+2;
        String str1="加法的和等于：" + sum1;//+用于字符串，自动把后面int类型的数字转换为字符串
        System.out.println(str1);

        String str2=sum1 + "这个数的和";//字符串与其他类型拼接时与顺序无关
        System.out.println(str2);

        String str3="字符串与布尔类型拼接" + true;//字符串可以和所有的基本数据类型拼接
        System.out.println(str3);

        int res1=8/4;
        System.out.println("8/4=" + res1);
        //两个数相除，得到的结果是整数，舍弃了小数部分
        res1=8/3;
        System.out.println("8/3=" + res1);
//        res1=8/0;
//        System.out.println("8/0=" + res1);//整数做除法时0不能做除数，会抛出异常。ArithmeticException Create breakpoint

        double res2=8/2.5;//只要有一个操作数为小数，除出来的结果就是小数
        System.out.println("8/2.5=" + res2);
        res2=10/3.0;
        System.out.println("10/3.0=" + res2);//输出为：3.3333333333333335
        res2=5.0/0;
        System.out.println("5.0/0=" + res2);//输出为：Infinity（无穷大），浮点数做除法时除数可以为0

        //取模运算
        res1=5%3;//结果是余数
        System.out.println(res1);
//        res1=5%0;//模运算0不能作为除数
//        System.out.println("5%0=" + res1);
        res2=5.0%3;
        System.out.println("5.0%3=" + res2);

        //++ --的运算
        int k=1;
        res1=5+k++;//k先参与运算，然后再加1
        System.out.println(res1);//6
        System.out.println(k);//2
        int j=1;
        res1=5 + ++j;//操作数加1后参与运算
        System.out.println(j);//7
        System.out.println(k);//2
        
//................代码如下..............................

        //赋值运算
        int n=5;//赋值字面量
        n=3+2;//赋值表达式
        n=k-j;//赋值含有变量的表达式
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数字：");
        n=scanner.nextInt();//赋值一个方法的返回值
        System.out.println(n=4+6);//10，赋值的语句会返回结果


    }
}

• 复合运算符

n+=2;//等同于n=n+2
n-=2;//等同于n=n-2
n*=2;//n=n*2
n/=2;//n=n/2
n%=2;//n=n%2

比较运算符

用于判断两个操作数的大小是否相等，包含< > == <= >= !=

//比较运算符
System.out.println(3>2);//true
System.out.println(3<2);//false
System.out.println(2==2);//true
System.out.println(2!=2);//false
System.out.println(3>=3);//true
System.out.println(3<=5);//true

逻辑运算符

• && 短路与
• & 与
• || 短路或
• | 或
• ! 非
• ^ 异或

package com.HQYJ;

public class Opreater {
    public static void main(String[] args) {
        //逻辑运算符
        System.out.println("------逻辑运算------");
        //&& 两个操作数都为true,结果才为true
        System.out.println(true && true);
        System.out.println(true && false);
        n=1;
        //短路与，如果第一个操作数就能得出表达式的结果，那么第二个表达式将不会被执行
        System.out.println(false && (2 == ++n));//第一个操作数是false，所以后面的表达式（2 == ++n）不会被执行，n还是1
        System.out.println(n);

        //一假即假
        System.out.println(true & true);
        System.out.println(false & true);
        int m=1;
        System.out.println(false & (2 == ++m));
        System.out.println(m);

        //一真即真
        System.out.println(true | true);//true
        System.out.println(false | true);//true
        System.out.println(false | false);//false

        //一真即真，如果第一个为真，第二个就不会执行
        System.out.println(true || true);//true
        System.out.println(false || true);//true
        System.out.println(false || false);//false

        //求反
        System.out.println(!true);//false
        System.out.println(!false);//true
        System.out.println(!(2 == 2));//等效于2!=2

        //^ 不同为真，相同为假
        System.out.println(true ^ false);//true
        System.out.println(false ^ false);//false
        System.out.println(true ^ true);//false

    }
}

位运算符

• &：按位与
• |：按位或
• ~：按位非
• ^：按位异或
• <<：向左移位
• >>：向右移位
• > > >：无符号右移

package com.HQYJ;

public class Opreater {
    public static void main(String[] args) {
        //位运算符
        System.out.println("----位运算符----");
        int a=5;//101
        int b=7;//111
        System.out.println(a & b);//得出101，但默认是int类型，所以输出5
        System.out.println(a | b);//7

        a=-5;
        System.out.println(~-a);//4,得考虑符号的问题，1为负，0为正
        /**
         * 详解：int类型是4byte,1byte=8bit,4byte=32bit
         * 所以-5的二进制为10000000 00000000 00000000 00000101，第一位为符号位。
         * 取反得：11111111 11111111 11111111 11111010，符号位不变，反码+1得补码
         * 补码：11111111 11111111 11111111 11111011，将补码取反，得~a的补码，符号位要改变
         * ~a补码：00000000 00000000 00000000 00000100，
         * 由于正数原码取反码，补码都不变，所以将~a取十进制为~a=4
         */

        a=5;
        System.out.println(a^b);//2

        /*
        * 面试题：请用性能最优的方法计算：2*8
        * */
        a=2;
        System.out.println(a << 3);//16,相当于把二进制的10左移3位得到10000

        //算数右移，符号位不变，并用符号位补溢出的最高位简(二进制)
        System.out.println(5 >> 2);//1，用符号位0补溢出的最高位(00000000 00000000 00000000 00000001+0)，结果还是1
        System.out.println(-5 >> 2);//-2，用符号1位补溢出的最高位(10000000 00000000 00000000 00000001+1)，结果为-2
        
        //无符号位移
        System.out.println(-5 >>> 2);//1073741822


    }
}

三目运算符

三目运算符用于两个分支的判断，等效于if else语句

语法：条件表达式? 为真值：为假值;

package com.HQYJ;

public class Opreater {
    public static void main(String[] args) {
        //三目运算符
        res1=3>2 ? 100 : 0;
        System.out.println(res1);


    }
}

• 练习：从控制台输入两个整数，打印出比较大的数

package com.HQYJ;

import java.util.Scanner;

public class Opreater {
    public static void main(String[] args) {
        //练习：从控制台输入两个整数，打印出比较大的数
        Scanner scanner1 = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int x=scanner1.nextInt();
        Scanner scanner2 = new Scanner(System.in);
        System.out.println("请再输入一个整数：");
        int y=scanner2.nextInt();
        //如果x>y,返回x;如果x<y,返回y
        int i = x>y? x : y;
        System.out.println(i);
        


    }
}

运算符的优先级

优先级：括号 > 单目运算符 > 算术运算符 > 比较运算符 > 逻辑运算符 > 三目运算符 > 赋值运算符

//运算符的优先级
System.out.println((3 + 2) * ++a == 8 ? true : false);//false

条件判断的语句

单分支条件判断

if(条件表达式){

​ 条件为真时执行的语句

}

package com.HQYJ;

public class Condition {
    public static void main(String[] args) {
        int rain=1;//是否下雨：1.下雨；0.没有下雨
        if(rain==1){//在下雨
            System.out.println("出门要带伞！");
        }
    }
}

两分支判断

if(条件表达式){

​ //为真执行

}else{

​ //为假执行

}

package com.HQYJ;

public class Condition {
    public static void main(String[] args) {
        //性别：1-男；2-女
        int sex=1;
        if(sex==1){
            System.out.println("男生");
        }else{
            System.out.println("女生");
        }
    }
}

废物的今天就先到这里了！