Java基础知识 03（算术运算符）

Java基础知识 03

自动类型提升机制案例分析

自动类型提升机制：当byte,short,char在参与运算时，会自动提升为int类型，如果还有long,float,double类型参与运算时，则会响应的提升为long,float,double类型，byte,short,char他们三个之间不参与转换，boolean不参与数学运算。
class  DataDemo{
	public static void main(String[] args) {
		//定义两个byte 类型的变量
		byte a=10;
		byte b=20;
		long c=1L;
		float f=1.1F;
		double g=2.1;
		//DataDemo.java:6: 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//*自动类型提升机制*

		//int 4个字节 byte 1个字节
		//byte r=a+b; //报错 a b 提升为了int 类型，那么他们相加的结果应该也是int类型。byte 类型就接收不了int类型的结果
		//int r2=a+b+c; 报错
		//long r3=a+b+c;

		//long r4=a+b+c+f; 报错，有floatl类型参与运算了，那么你long 这个整型，无法存小数部分
		//float r4=a+b+c+f;

		//float r4=a+b+c+f+g; 报错
		double r4=a+b+c+f+g;
		System.out.println(r4);
	}
}

强制类型转换案例分析

强制类型转换：可以把多余的字节丢弃掉，本来的结果是int类型，占4个字节，但是我们用byte类型来接受，那么就强制类型转换，既然是byte来接收结果，那么我们对于结果只保留一个字节，前面多余的三个字节丢弃掉，强制类型转换，因为要丢弃多余字节，就有可能发生精度损失，一般不建议强制类型转换，因为会发生精度损失，除非有特殊需求。
class  DataTypeDemo{
	public static void main(String[] args){
		byte a=3;
		byte b=127;
		//byte r=a+b; 报错 因为自动类型提升了 //7
		//int r=a+b;
        //强制类型转换
		byte r=(byte)(a+b);
		short s=(short)(a+b);
		System.out.println(r);
		System.out.println(s);
	}
}

常量优化机制案例分析

常量优化机制：当多个常量在参与运算时，会先把结果计算出来，然后再看这个结果，在不在这个数据类型的类型范围内，如果在，则不报错；如果不在，则报错。
class  DataDemo{
	public static void main(String[] args) {
		
		 byte r=3+4;
		// byte r=3+4+200; 这个报错，多个常量加完的结果，超过了byte类型，所以报错
		//常量优化机制
		System.out.println(r);
		/*
		B:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
	可以。因为Java语言采用的是Unicode编码。Unicode编码中的
	    GBK编码每个字符占用两个字节。

		UTF-8 编码一个汉字 占用 3个字节
	   所以，Java中的字符可以存储一个中文汉字采用GBK编码	
	*/
		//char 占两个字节
		char ch='我';
		System.out.println(ch);
	}
}

运算符

运算符：对变量和常量进行操作的变量。
运算符“+”：（1）作用一，起数学上的相加作用，作数学运算。
		  （2）作用二，起一个拼接符的作用。当“+”加号的运算两边有任意一边是一个字符串，那么“+”加号就会起一个连接符的作用，将两端的内容拼接起来形成一个新的字符串。
public class MyDemo {
    public static void main(String[] args) {
        // + 加号，有层作用，
        // 第一个作用，起数学方面的相加作用 两端是数值，他就会做数学运算
        // 第二个作用，起一个 连接符的作用。
        // 拼接符：当 + 加号的运算两边有任意一边，是一个字符串，那么加号就会起一个连接符的作用，将两端的内容拼接起来形成一个新的字符串。
        System.out.println(2+3);
        System.out.println(2+"22"); //"222"
        System.out.println("100"+100);//"100100"
        System.out.println(20+30+"50"); //"5050"
        System.out.println("100"+20+30);//"1002030"
        System.out.println("2020"+"111");//"2020111";
        //字符相加
        System.out.println('a'+5+'b'); //97+5+98
        System.out.println(2.2+3.2);
        System.out.println("hello" + 'a' + 1); // "helloa1"
        System.out.println('a' + 1 + "hello"); // "98hello"
        System.out.println("5+5=" + 5 + 5); //"5+5=55"
        System.out.println(5 + 5 + "=5+5");//  "10=5+5"
    }
}

（1）算数运算符：+，-，*，/，%，++，--
	注意事项：（1）整数相除只能得到整数，如果想要得到小数，请使用浮点数。
			（2）/ 获取到的是除法操作的商，% 获取到的是除法操作的余数。
			    % 运算结果的符号，取决于参与运算是左边的符号。
程序案例分析：
public class MyTest {
    public static void main(String[] args) {
        //运算符：对变量或常量 进行操作的符号
        //运算符：赋值运算符 算术运算符  比较运算符 逻辑运算符  位运算符 三元运算符
        //多行注释 ctrl+shift+ /
        //单行注释 ctlr+/
       /* C:
        算数运算符有哪些
                +, - , * , / , % ,++, --*/
         int a=20;
         int b=200;
        System.out.println(a+b);
        System.out.println(a-b);
        int r=a*b;
        System.out.println("结果 r="+r);
        //上下分开
        int g=10;
        int h=3;
        int rr=g/h;
        //两个整型相除，如果有小数部分 结果只保留整数部分 小数部分丢弃掉
        System.out.println("结果 rr="+rr);
        int uu=10;
        double pp=3;
        double tt=uu/pp;
        System.out.println(tt);
        //  % 取余数
        System.out.println(10%3);
    }
}

“++”“--”运算符的作用：自加（++）自减（--）
	++：自加运算符，对原有的数据+1
	--：自减运算符，对原有的数据-1
“++”“--”在操作数前，先运算，后使用。
“++”“--”在操作数后，先使用，后运算。
程序案例分析：
public class MyTest {
    public static void main(String[] args) {
        // ++  自身增1
        // --  自身减1
        // ++  -- 单独使用你放在 前面 还是后面，没有区别
        int i=1;
        i++; // i=2
        ++i;//i=3;
        i--;//i=2
        --i;//i=1
        System.out.println("i="+i);
       //上下分开
        //混合使用
        // ++ 在前 先运算 后使用
        // ++ 在后 先使用 后运算
        int j=1;
        int h=j++;
        System.out.println("j="+j); //2
        System.out.println("h="+h);//2
        //上下分开
        //混合使用
        // ++ 在前 先运算 后使用
        // ++ 在后 先使用 后运算
        int v=1;
        int w=2+(v++)+2-(++v)-1-(v--)+2+(--v)+3;
        System.out.println("v="+v); //1
        System.out.println("w="+w);//我算的是4，如有不对，还望纠正。
    }
}

（2）赋值运算符：=，+=，-=，*=，/=，%=
	基本的赋值运算符：=，把=右边的数据赋值给左边。
	扩展的赋值运算符：+=，-=，*=，/=，%=
	“+=”运算符把左边和右边做加法，然后赋值给左边。
	赋值运算符要求左边的数据必须是一个变量。
程序案例分析：
public class MyDemo {
    public static void main(String[] args) {
      /*  A:
        赋值运算符有哪些
                =， +=,-=,*=,/=,%=
                */
        //把右边这个整数常量20 赋值给左边这个int类型的变量a
        int a=20;
        int j=10;
        //把右边这个变量j的值  赋值给左边这个int类型的变量h
        int h=j;
        //上下分开
        int r=20;
        r=r+10; //等价于  r+=10;
        System.out.println("r="+r);
        //上下分开
        byte t=10;
        //t=t+20; 报错 因为自动类型提升 t 会提升为int 类型 相加的结果，不能再赋值给 byte类型的t
        t = (byte) (t + 20); //解决方式，可以强制类型转换
        System.out.println("t="+t);
        //上下分开
        byte m=10;
        //m=m+10;
        // += 会帮你自动强制类型转换，当你这个运算结果，如果超过这个类型的范围，会自动帮你强制类型转换。
         m+=1000;
        System.out.println("m="+m);
    }
}

（3）关系运算符：==，！=，<，>，<=，>=，instanceof（随后会讲到）
	结果必须是boolean类型，只有两种：true,false.
程序案例分析：
public class MyDemo {
    public static void main(String[] args) {
        //比较运算符
       // == ,!= , < , > , <= , >= , instanceof(后面讲解)
        // ==  = 的区别？
        // 比较运算符的运算结果是布尔类型
        int a=10;
        int b=20;
         boolean r= a<b;
        System.out.println("r="+r);
         boolean r2= a > 10;
        System.out.println(r2);
        //上下分开
        // == 比较运算符  = 赋值运算符 的区别？
           boolean b1= a==b;
        System.out.println(b1);
       boolean b2=a!=b;
        System.out.println(b2);
    }
}