Java数据类型和运算符

Java数据类型和运算符

修改（2022.06.12）：增加条件运算符说明。

一、数据类型

1.1 概念

① 基本数据类型（8个）

​ 数值型：

​ 整型：byte、short、int、long。

​ 浮点型：float、double。

​ 非数值型：

​ char(字符型)、boolean(true/false)。

② 引用数据类型（3个）

​ 类（String）、接口、数组。

1.2 数据类型转换：

自动类型转换：小范围的数据转换为大范围的数据。

强制类型转换：大范围的数据转换为小范围的数据。

注意：强制类型转换有可能造成数据精度丢失（数据不准确）。

public static void main(String[] args) {
	//声明一个byte类型的变量num1并存储数据10
	byte num1 = 10;
	//将num1存储到int类型的变量num2中
	int num2 = num1;
	System.out.println(num1);
	System.out.println(num2);
		
	//声明一个int类型的变量num3并存储数据20;
	int num3 = 130;
	//将num3存储到byte类型的变量num4中
	// byte num4 = num3; //存储报错
	byte num4 = (byte)num3;
	System.out.println(num3);
	System.out.println(num4);
}

二、运算符

2.1 赋值运算符

赋值运算符：=

变量名 = 表达式;

表达式是操作符和数据的结合体

public static void main(String[] args) {
	int num1 =10;
	int num2 =20;
	int sum = num1+num2;
}

扩展：

实现两个变量中数据的交换。

public static void main(String[] args) {
    int num1 =8;
    int num2 =9;
    System.out.println("num1="+num1); //num1=8
    System.out.println("num2="+num2);//num2=9

    //创建一个临时变量temp来作为中转站
    int temp;
    //将num1的值存储到临时变量中
    temp = num1; //temp = 8;
    //将num2的值存储到num1中
    num1= num2; //num1=9
    //将temp的值存储到num2中
    num2 = temp; //num2 = 8
    System.out.println("num1="+num1); //num1=8
    System.out.println("num2="+num2);//num2=9
}

2.2 算术运算符

基本算术运算符：

① - * / %(取模运算符/取余运算符)

public static void main(String[] args) {
    int num1 = 10;
    int num2 =3;
    int result1 =num1+num2;
    System.out.println("num1+num2="+result1);
    int result2 =num1-num2;
    System.out.println("num1-num2="+result2);
    int result3 =num1*num2;
    System.out.println("num1*num2="+result3);
    int result4 =num1/num2;
    System.out.println("num1/num2="+result4);
    int result5 =num1%num2;
    System.out.println("num1%num2="+result5);
}

② ++(自增运算符) --(自减运算符)

public static void main(String[] args) {
    int a =100;
    System.out.println("a="+a);//a=100
    //a++;
    ++a;
    System.out.println("a="+a);//a=101

    int b = 1000;
    System.out.println("b="+b);
    // b--;
    --b;
    System.out.println("b="+b);
}

注意：

1. ++/–在变量前或者变量后，此变量都会自增1或者自减1。

2. ++/–修饰的变量参与运算，++/–在变量前或变量后，对结果有影响。

3. ++/–在变量前，先进行自增或者自减运算，然后再参与其它运算。

4. ++/–在变量后，先去参与运算，然后再进行自增或者自减运算。

public static void main(String[] args) {
    int m =100;
    System.out.println("m="+m);//m=100
    int n =m++;
    System.out.println("m="+m);//m=101
    System.out.println("n="+n);//n=100

    int k = 100;
    System.out.println("k="+k);//k=100
    int h =++k;
    System.out.println("k="+k);//k=101
    System.out.println("h="+h);//h=101
}

复合算术运算符：+= -= *= /= %=：

public static void main(String[] args) {
    int num = 100;
    //num =num+10;
    num+=10;
    System.out.println("num="+num); //num=110

    num-=20; //num=num-20;
    System.out.println("num="+num);//num=90

    num*=3; //num=num*3;
    System.out.println("num="+num);//num=270

    num/=7; // num=num/7;
    System.out.println("num="+num);//num=38

    num%=5; //num=num%5;
    System.out.println("num="+num);//num=3
}

2.3 关系运算符

关系运算符：== != > >= < <=

① 关系运算符的结果是布尔类型，要么为true要么为false。

② >、<、>=、<= 运算符的优先级别高于==、!=。

③ >、<、>=、<=运算符只支持数值类型的数据比较。

public static void main(String[] args) {
	int num1 =10;
    int num2 =20;

    boolean result1 =num1==num2;
    System.out.println("num1==num2:"+result1); //false

    boolean result2 =num1!=num2;
    System.out.println("num1!=num2:"+result2); //true

    boolean result3 =num1>num2;
    System.out.println("num1>num2:"+result3); //false

    boolean result4 =num1>=num2;
    System.out.println("num1>=num2:"+result4); //false

    boolean result5 =num1<num2;
    System.out.println("num1<num2:"+result5); //true

    boolean result6 =num1<=num2;
    System.out.println("num1<=num2:"+result6); //true
}

2.4 逻辑运算符

逻辑运算符：& &&(短路与) | ||(短路或) ！

① 参与逻辑运算的表达式结果要是布尔值。

② 逻辑运算符本身的结果也为布尔值，要么为true，要么为false。

2.4.1 与(&、&&)运算符

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;
    boolean result = num1 < num2 && num2 > num1;
    System.out.println(result);

    // true&true=true
    // true&&true=true
    boolean result1 = true & true;
    boolean result2 = true && true;
    System.out.println("true&true:" + result1);// true&true:true
    System.out.println("true&&true:" + result2);// true&&true:true

    // true&fale=false
    // true&&false=false
    boolean result3 = true & false;
    boolean result4 = true && false;
    System.out.println("true&false:" + result3);// true&false:false
    System.out.println("true&&false:" + result3);// true&&false:false

    // false&true=true
    // false&&true=true
    boolean result5 = false & true;
    boolean result6 = false && true;
    System.out.println("false&true:" + result5);// false&true:false
    System.out.println("false&&true:" + result6);// false&&true:false

    // false&false=true
    // false&&false=true
    boolean result7 = false & false;
    boolean result8 = false && false;
    System.out.println("false&false:" + result7);// false&false:false
    System.out.println("false&&false:" + result8);// false&&false:false
}

& &&运算规律：只有当&和&&左右两边同时为true，&和&的结果才为true。

2.4.2 或(|、||)运算符

public static void main(String[] args) {
    // true|true=true
    // true||true=true
    boolean result1 = true |true;
    boolean result2 = true || true;
    System.out.println("true|true:" + result1);// true|true:true
    System.out.println("true||true:" + result2);// true||true:true

    // true|fale=false
    // true||false=false
    boolean result3 = true | false;
    boolean result4 = true || false;
    System.out.println("true|false:" + result3);// true|false:false
    System.out.println("true||false:" + result3);// true||false:false

    // false|true=true
    // false||true=true
    boolean result5 = false | true;
    boolean result6 = false || true;
    System.out.println("false|true:" + result5);// false|true:false
    System.out.println("false||true:" + result6);// false||true:false

    // false|false=true
    // false||false=true
    boolean result7 = false | false;
    boolean result8 = false || false;
    System.out.println("false|false:" + result7);// false|false:false
    System.out.println("false||false:" + result8);// false||false:false
}

| ||运算规律：只要|和||左右两边有一个为true，|和||的运算结果为true

2.4.3 非(!)运算符

运算规律：

① 是非不分，黑白颠倒

② true进行!运算得到false

③ false进行!运算得到true

public static void main(String[] args) {
    boolean bool1=true;
    boolean bool2=false;

    //!true--->false
    boolean result1=!bool1;
    System.out.println("!true:"+result1);//!true:false

    //!false-->true
    boolean result2=!bool2;
    System.out.println("!false:"+result2);//!false:true
}

2.4.4 与（或）和短路与（或）的区别

① &和&&的异同点：

相同点：

​ 运算规律是一样的，只有当&和&&左右两边同时为true的时候，&和&&的运算结果才为true。

不同点：

​ &&有短路功能：当&&左边表达式的结果为false，不再判断&&右边表达式的结果，直接输出&&d运算结果。

​ &没有短路功能：不管&左边表达的结果为true还是false，都要先去判断&右边表达式的结果，然后再输出&运算结果。

public static void main(String[] args) {
    int x=8;
    int y=9;
    System.out.println((++x==y)&&(++x!=y)); //true
    System.out.println(x);//10

    int m=8;
    int n=9;
    System.out.println( (++m!=n)&&(++m==n));//false
    System.out.println(m);//9
}

② |和||的异同点：

相同点：

​ 运算规矩是一样的，只要|和||左右两边有一个为true，|和||的运算结果为true。

异同点：

​ ||有短路功能：当||左边表达式的结果为true，不再判断||右边表达式的结果，直接输出||运算结果。

​ |没有短路功能：不管|左边表达式的结果为true还是false，都要先去判断|右边表达式的结果，然后再输出|运算结果。

public static void main(String[] args) {
    int x=8;
    int y=9;
    System.out.println((++x==y)||(++x!=y)); //true
    System.out.println(x);//9

    int m=8;
    int n=9;
    System.out.println( (++m!=n)||(++m==n));//false
    System.out.println(m);//10
}

2.5 条件运算符（三目运算符/三元运算符）

2.5.1 语法结构

语法结构：
条件?表达式1:表达式2;
执行规律：
条件为true，执行表达式1
条件为false，执行表达式2

public static void main(String[] args) {
    // 使用条件运算符获得两个数中的最大值
    int num1 = 100;
    int num2 = 101;
    int max =num1>num2?num1:num2;
    System.out.println("最大值："+max);

    //使用键盘录入两个整数，然后通过条件运算符进行比较，输出输入的两个值里面的最小值
    //创建Scanner类对象
    Scanner  input =new Scanner(System.in);
    System.out.println("请输入第一个整数：");
    int firstNum=input.nextInt();
    System.out.println("请输入第二个整数：");
    int secondNum=input.nextInt();
    int min =firstNum>secondNum?secondNum:firstNum;
    System.out.println("你输入的两个数中最小的数是："+min);
}

2.5.2 条件运算符的嵌套：

语法结构：
条件?(条件?表达式1:表达式2):(条件?表达式1:表达式2);

public static void main(String[] args) {
    //使用条件运算符输出3个数中的最大值
    int a = 100;
    int b = 90;
    int c = 200;

    int max =a>b?(a>c?a:c):(b>c?b:c);
    System.out.println(max);
}

2.5.3 运算符的优先级

单目运算符包括! ++ --，优先级别高。
①优先级别最低的是赋值运算符。
②可以通过()控制表达式的运算顺序，()优先级最高。
③从右向左结合性的只有赋值运算符、三目运算符和单目运算符。
④算术运算符 > 关系运算符 > 逻辑运算符。