JavaSE——运算符

/*
算术(数字)运算符
	+：①加法运算  ②字符串拼接  ③正号
	-：①减法运算  ②负号
	*：乘法运算
	/：除法运算(取商)
	%：取模运算(取余)
   ++：自增运算(+1)
		   ①前置自增：先自增后使用
		   ②后置自增：先使用后自增
   --：自减运算(-1)
		   ①前置自减：先自减后使用
		   ②后置自减：先使用后自减
		   
赋值运算符
	=：赋值符 (从右向左赋值)
	(混合运算符)所有的混合赋值运算符都会强转
   +=：加后赋值
   -=：减后赋值
   *=：乘后赋值
   /=：除后赋值
   
比较运算符(关系运算符)（运算结果要么为true要么为false）
   ==：相等 (表达式两边的值是否相同)
   !=：不相等
    <：小于
	>：大于
   <=：小于或等于
   >=：大于或等于
 
逻辑运算符 （运算结果要么为true要么为false）(能进行逻辑运算符运算的表达式都是布尔表达式(布尔表达式：计算结果为false或者true的表达式)，最终运算结果也一定是true或者false)
   &&：与(并且)（运算符左右的表达式都满足，那么结果为true，否则为false）
   ||：或	   （运算符左右的表达式都满足或者只满足一个，那么结果为true，都不满足时，结果为false）
    !：非(取反)（数据原先为true加上!后变为false，数据原先为false加上!后变为true）

三元运算符
   (布尔表达式)? 表达式1 : 表达式2
   如果布尔表达式的结果为true 则执行表达式1
   如果布尔表达式的结果为false 则执行表达式2
*/

public class OperateDemo{
	public static void main(String []args){
	//算术运算
		// +
			//①加法运算
			int a = 3;
			int b = 4;
			System.out.println(a+b);//7 //分别取出a、b的值进行加法运算
			//②字符串拼接
			System.out.println("你"+"好");//你好  //从左向右进行拼接
			//③正号
			System.out.println(+3);//3
			
			//拓展
			//①加法运算
			int c = 3;
			double d = 4.0;
			System.out.println(c+d);//7.0 //不同类型的数据在做运算的时候,会先把范围小的类型转换为范围大的类型再运算.即：先把c转换为double类型再与d相加
			//②字符串拼接(从左向右进行拼接)
			System.out.println("5+5="+5+5);//5+5=55   //从左到右 检测到 "5+5="+5 +号的一端"5+5="是一个字符串 另一端是一个数字5 会把5强行转化为字符串格式 于是就变成了字符串拼接运算 得出"5+5=5" 再将"5+5=5"与最后面那个5相加 同理也变成了字符串拼接运算 得出5+5=55  
			System.out.println("5+5="+(5+5));//5+5=10  //想让哪一部分先运算就给那一部分加上小括号
			System.out.println(5+5+"=5+5");//10=5+5
		
		// -
			//①减法运算
			int e = 5;
			int f = 4;
			System.out.println(e-f);//1
			//②负号
			System.out.println(f-e);//-1
			
		// * 乘法运算
			System.out.println(f*e);//20
	    // / 除法运算
			System.out.println(f/e);//0 
		// % 取模运算
			System.out.println(e%f);//1
			
			//拓展
			//除法运算与取模运算
				//利用除法运算与取模运算可以得出一个数字的某个位数所对应的数
				int number = 47;
				System.out.println(47%10);//7 得到个位数
				System.out.println(47/10);//4 得到十位数
			
		// ++ 
			//①前置自增
			int m = 3;
			int n = ++m;//++m相当于m=m+1，m先自增，此时m由3变成了4，再将自增后的m的值赋给n。
			System.out.println(m);//4 m已经自增了变化成了4
			System.out.println(n);//4
			//②后置自增
			int p = 3;
			int q = p++;//先将p的值赋给q，此时q=3；然后p再自增，此时p变成了4
			System.out.println(p);//4
			System.out.println(q);//3
		// --
			//①前置自减
			int r = 3;
			int s = --r;//--r相当于r=r-1，r先自减，此时r由3变成了2，再将自减后的r的值赋给s。
			System.out.println(r);//2 m已经自减了变化成了2
			System.out.println(s);//2
			//②后置自减
			int t = 3;
			int u = t--;//先将t的值赋给u，此时u=3；然后t再自减，此时t变成了2
			System.out.println(t);//2
			System.out.println(u);//3
//注：
//1、相同类型的数据进行算术运算时，得到的结果的类型一定是该数据所对应的类型。即：两个int类型的数据做算数运算时得到的结果也一定是一个int类型的数据
//2、不同类型的数据进行算术运算时，会先把范围小的类型转换为范围大的类型再进行运算。
//3、字符串在进行拼接的时候，严格按照从左到右的顺序进行拼接。
//4、想要对哪一部分的先进性运算，就给那一部分加上小括号。
	
	//赋值运算 (先计算再赋值给自身)
		// =:赋值符
			int v = 3+4;//先计算赋值符右边的表达式3+4，然后再将结果赋值给赋值符左边的变量a
			System.out.println(v);//7
			
		// +=：加后赋值
			int w = 5;
			w+=7;//w+=7相当于w=w+7 即w=5+7 将5+7的结果再赋值给w
			System.out.println(w);//12
		// -=：减后赋值
			int x = 5;
			x-=7;//x-=7相当于x=x-7 即x=5-7 将5-7的结果再赋值给x
			System.out.println(x);//-2
		// *=：乘后赋值
			int y = 5;
			y*=7;//y*=7相当于y=y*7 即y=5*7 将5*7的结果再赋值给y
			System.out.println(y);//35
		// /=：除后赋值
			int z = 5;
			z/=7;//z/=7相当于z=z/7 即z=5/7 将5/7的结果再赋值给z
			System.out.println(z);//0
//注：所有的混合赋值运算符都会强转
		byte a0=1;//定义了一个byte类型的数据a0，a0的值为1
		a0=a0+3;//先计算表达式a0+1再将计算的结果赋值给a0
				//表达式a0+3中，a0为byte类型，3为int类型。编译器在进行a0+3的操作时，会将a0自动转换为int类型，所以表达式a0+3的结果为4，是一个int类型。
				//这个时候要求把4赋值给a0由于第一行代码定义的a0为byte类型，4是int类型，而int类型是不能直接转换为byte类型的所以会报错。
				//为了不报错需要我们手动对它进行一个强转
				//即：a0=a0+3应该修改为 a0 = (byte)(a0+3)
		System.out.println(a0);//报错  错误: 不兼容的类型: 从int转换到byte可能会有损失
		//-------此处是分割线----------//
		byte b0=1;
		b0+=3;
		System.out.println(b0);//4 不会报错
		//这个时候我们会产生一种疑问，b0+=3不是相当于b0=b0+3吗？那么应该会像上面a0的例子一样结果会报错才对，但是为什么这里反而没有报错？
		//事实上，尤其是对于不同类型的混合运算符运算，它在底层会有一个隐式的操作————自动强转
		//即：b0+=3 在底层是进行的 b0=(byte)(b0+3)操作，所以不会报错。
		
	//比较运算符
	    // ==：相等于
			int c0 = 7;
			int d0 = 5;
			System.out.println(c0==d0);//false
		// !=：不等于
			System.out.println(c0!=d0);//true
		// <：小于
			System.out.println(c0<d0);//false
		// >：大于
			System.out.println(c0>d0);//true
		// <=：小于或等于
			System.out.println(c0<=d0);//false
		// >=：大于或等于
			System.out.println(c0>=d0);//true 
			
		//拓展：
		int e0 = 10;
		double f0 = 10.0;
		System.out.println(e0!=f0);//false 两个不同类型的数据在进行运算时(不管进行什么类型的运算)都会进行数据类型的转换
								   //先将int类型的e0转换为double类型变成了10.0
								   //于是就变成了10.0与10.0之间进行!=运算 结果当然为true
								   
	//逻辑运算符
		// && 与
			System.out.println(5>3 && 4>3);//true  左边为true  右边为true
			System.out.println(6>5 && 2>4);//false 左边为true  右边为false
			System.out.println(2>4 && 6>5);//false 左边为false 右边为true
			System.out.println(3>4 && 2>5);//false 左边为false 右边为false
		// ||或
			System.out.println(5>3 || 4>3);//true  左边为true  右边为true
			System.out.println(6>5 || 2>4);//true  左边为true  右边为false
			System.out.println(2>4 || 6>5);//true  左边为false 右边为true
			System.out.println(3>4 || 2>5);//false 左边为false 右边为false
		// !非
		    int g0 = 10;
			int h0 = 4;
			System.out.println(g0>h0);//true
			System.out.println(!(g0>h0));//false
//注：&&运算与||运算中，只要能判断出结果则后边的部分就不再进行判断
	
		int i0 = 3;
		boolean j0 = true && ++i0>2; //++i0>2得到true
		System.out.println(i0);//4 i0进行了自增变为了3
		System.out.println(j0);//true
		
		int k0 = 3;
		boolean m0 = false && ++k0>2;// ++k0>2得到true
		System.out.println(k0);//3 i0没有进行自增 这是因为在boolean m0 = false && ++k0>2;左边表达式的结果为false由此就可以判断出整个与运算的结果为false所以不需要再对右边的表达式进行操作
		System.out.println(m0);//false
		
		int p0 = 3;
		boolean q0 = true || ++p0>2;
		System.out.println(p0);//3 p0没有进行自增 这是因为在boolean q0 = true || ++p0>2;左边表达式的结果为true由此就可以直接判断出整个或运算的结果为true所以不需要再对右边的表达式进行操作
		System.out.println(q0);//true
		
		int r0 = 3;
		boolean s0 = false || ++r0>2;// ++k0>2得到true
		System.out.println(r0);//4 r0进行了自增 因为在或运算中一边的表达式的结果为false时还需要判断另一边的表达式的情况才能判断出整个或运算的结果为true还是false
		System.out.println(s0);//true
		
	//三元运算符
			System.out.println(3>2?"大":"不大");//大
			int t0 = 10;
			int u0 = 30;
			boolean v0 = t0>=u0?true : false;
			System.out.println(v0);//false
	}
}