运算符

package cn.work.day01;


//运算符
public class Operator {

	public static void main (String[]args){

		int a = 1;
		int b = 2;
		System.out.println(a+++b);
		
		//算数运算符

		/*
		 * System.out.println(1 + 1);//加
		 * 
		 * System.out.println(1 - 1);//减
		 * 
		 * System.out.println(1 * 1);//乘
		 * 
		 * System.out.println(1 / 1);//除
		 */

		/*
		 * int i = 10;
		 * 
		 * System.out.println(+i + -i);
		 */

		// System.out.println(3900 / 1000 * 1000); // 3000
		// 3900是int型1000也是int型,2个int型运算得到int而不是double
		// 所以结果是3*1000

		
		/* * 
		 * System.out.println(10 % 3);
		 * 
		 * System.out.println(10 % -3);
		 * 
		 * System.out.println(-10 % 3);
		 * 
		 * System.out.println(-10 % -3);// 在做取模运算时, 和%右边的数的符号无关, 只取决于%左边的数的符号
		 * */
		 
		
		 /* %运算规律,
		 * 
		 * 
		 * 左边小于右边结果是左边;
		 * 
		 * 右边是1结果是0;
		 * 
		 * 左边等于右边结果是0;
		 * 
		 * 左边大于右边做运算;
		 * 
		 * 在做取模运算时, 和%右边的数的符号无关, 只取决于%左边的数的符号;
		 * 
		 * 任何数%2 结果不是0就是1,可以用于判断数据的奇偶!
		 */


		/*
		 * int i = 5;
		 * 
		 * System.out.println(i++);// 自增1, 先取值, 后运算. 打印出5, 然后自增为6.
		 * 
		 * int j = 10;
		 * 
		 * System.out.println(++j);// 自增1, 先运算, 后取值. 自增为11, 打印出11.
		 */


		/*
		 * 
		 * int i = 5;
		 * 
		 * int j = 10;
		 * 
		 * System.out.println(i++ * ++j + i); // 5*11+6=61,
		 */


		/*
		 * 
		 * int i = 5;
		 * 
		 * int j = 10;
		 * 
		 * System.out.println(i + (i++ + j));//结果是20?why?表达式从左到右运算,当运算到括号时,
		 * //把括号内的数据运算出结果再与i相加,5+(5+10)=20.
		 */

		/*
		 * 
		 * int i = 5;
		 * 
		 * int j = 10;
		 * 
		 * System.out.println(i + ++ j); //5+11=16 ++j先运算后取值 5+11=16
		 */

		/*
		 * 
		 * System.out.println('A' + 'B'); // 65+66=131
		 * 这里结果是字符'A'和'B'对应的Unicode码表的数据向加的结果
		 * 
		 * System.out.println("A" + "B"); // AB 这里的 + 叫做字符串连接符.
		 * 字符串数据和任何数据使用+都是相连接,最终都会变成字符串.
		 */

		// System.out.println("5+5"+5+10);//5+5510 //与字符串相连接.



//赋值运算符

		/*
		 * 
		 * int x = 5;
		 * 
		 * x = 10;
		 * 
		 * System.out.println(x);//打印结果是10? 初始化 变量x并赋值为5,最后将5修改赋值为10
		 */

		/*
		 * 
		 * int x = 5;
		 * 
		 * int y = 10;
		 * 
		 * int z = 15;
		 * 
		 * x = y = z = 20;
		 * 
		 * System.out.println(x);
		 * 
		 * System.out.println(y);
		 * 
		 * System.out.println(z);//打印结果是 20 20 20
		 */

		/*
		 * 
		 * int x = 5, y = 10, z = 15;
		 * 
		 * System.out.println(x);
		 * 
		 * System.out.println(y);
		 * 
		 * System.out.println(z);
		 */

		/*
		 * int i = 5;
		 * 
		 * System.out.println(i = 10);//打印结果 10 这个写法不常见啊 ^_*!!
		 */

		// 互换数据
		/*
		 * 
		 * int x = 5;
		 * 
		 * int y = 10;
		 * 
		 * 
		 * //推荐写法,方便容易看懂 int temp = x; //用第三变量记录x的数值,
		 * 
		 * x = y; //把y的值赋给 x
		 * 
		 * y = temp; //将第三方变量记录的曾经 x的值 赋给y
		 * 
		 * System.out.println(x);
		 * 
		 * System.out.println(y); // x与y数字交换.
		 */


		/*
		 * //加法运算,小心数据相加超过取值范围,损失精度噢 亲. int x = 5;
		 * 
		 * int y = 10;
		 * 
		 * // x = x + y;// x = 15, y = 10
		 * 
		 * // y = x - y;// x = 15, y = 5
		 * 
		 * // x = x - y;// x = 10, y = 5
		 * 
		 * // x = y + (y = x) - x; //加法运算的简写模式
		 * 
		 * 
		 * 
		 * System.out.println(x);
		 * 
		 * System.out.println(y);
		 */



		/*
		 * 
		 * int x = 5;
		 * 
		 * x += 10;// x = x + 10
		 * 
		 * System.out.println(x);
		 * 
		 * x -= 5;// x = x - 5
		 * 
		 * System.out.println(x);
		 */



		/*
		 * 
		 * int x = 10;
		 * 
		 * x %= 3;// x = x % 3
		 * 
		 * System.out.println(x);
		 */



		/*
		 * 
		 * byte b = 1;
		 * 
		 * b = b + 1; // 类型自动提升, 出错
		 */



		/*
		 * 
		 * byte b = 1 + 1;// 两个常量相加, 编译时, 直接转换为 byte b = 2;
		 */



		/*
		 * 
		 * byte b = 1;
		 * 
		 * b += 1;// 这里不会出错, 没有做把int值赋回byte变量的操作
		 */



		/*
		 * 
		 * byte b = 1;
		 * 
		 * b = ++b;// 自增时也不会改变数据类型
		 */



		/*
		 * 
		 * byte b = 1;
		 * 
		 * b = b++;
		 * 
		 * System.out.println(b);// 1
		 */

		/*
		 * short s = 3
		 * 
		 * s+=4 代表的意思是 s = (short)(s + 4 ) 自动类型提升并完成赋值的动作.
		 */

//比较运算符

		/*
		 * 
		 * int x = 6;
		 * 
		 * System.out.println(x % 2 == 0);// 判断x是否是偶数
		 */



		/*
		 * 
		 * int x = 6;
		 * 
		 * System.out.println(x == 5);// == 就是判断符号两边是否相等, 想的就得到true, 不相等就得到false
		 */



		/*
		 * 
		 * int x = 6;
		 * 
		 * System.out.println(x != 5);// != 判断两边是否不相等, 不相等就得到true, 相等就false
		 */

		/*
		 * 
		 * int x = 7;
		 * 
		 * System.out.println(x % 2 != 0);// 判断x是否是奇数
		 */


		/*
		 * 
		 * int x = 10;
		 * 
		 * System.out.println(x < 10);// 判断运算符左边是否小于右边, 小于就是true, 不小于就是false
		 */



		/*
		 * 
		 * int x = 10;
		 * 
		 * System.out.println(x <= 9);
		 */

		/*
		 * 
		 * System.out.println("abc" instanceof String);// 继承, 判断子类父类类型
		 */


		//逻辑运算符


		/*
		 * & 与(并且) AND 左右两边都为true, 结果才为true,有一个false,那么结果就是 false,
		 * 
		 * System.out.println(true & true);
		 * 
		 * System.out.println(false & true);
		 * 
		 * System.out.println(true & false);
		 * 
		 * System.out.println(false & false);
		 */



		/*
		 * 
		 * // | 与(并且) AND 左右两边都为false, 结果才为false,有一个true,那么结果就是 true,
		 * 
		 * System.out.println(true | true);
		 * 
		 * System.out.println(false | true);
		 * 
		 * System.out.println(true | false);
		 * 
		 * System.out.println(false | false);
		 */





		/*
		 * 
		 * int i = 41;
		 * 
		 * int j = 21;
		 * 
		 * System.out.println(i % 2 == 0 & j % 2 == 0);// 判断i和j是否都是偶数
		 */


		/*
		 * 
		 * // | 或(或者) OR 左右两边有一边为true, 结果就为true
		 * 
		 * System.out.println(true | true);
		 * 
		 * System.out.println(false | true);
		 * 
		 * System.out.println(true | false);
		 * 
		 * System.out.println(false | false);
		 */


		/*
		 * 
		 * int i = 2;
		 * 
		 * int j = 24;
		 * 
		 * System.out.println(i % 2 == 0 | j % 2 == 0);// 判断i和j中是否有偶数
		 */



		/*
		 * 
		 * // ^ 异或 XOR 两边不同就是true, 相同就是false
		 * 
		 * System.out.println(true ^ true);
		 * 
		 * System.out.println(false ^ true);
		 * 
		 * System.out.println(true ^ false);
		 * 
		 * System.out.println(false ^ false);
		 */



		/*
		 * 
		 * // ! 非 NOT 取反, 原来是true结果就是false, 原来是false结果就是true
		 * 
		 * System.out.println(!true);
		 * 
		 * System.out.println(!false);
		 */

		/*
		 * 
		 * // && 和 & 运行结果相同, 具有短路效果. 如果前半为false, 那么后半不执行
		 * 
		 * System.out.println(true && true);
		 * 
		 * System.out.println(false && true);
		 * 
		 * System.out.println(true && false);
		 * 
		 * System.out.println(false && false);
		 */



		/*
		 * 
		 * // || 和 | 运行结果相同, 具有短路效果. 如果前半为true, 那么后半不执行
		 * 
		 * System.out.println(true || true);
		 * 
		 * System.out.println(false || true);
		 * 
		 * System.out.println(true || false);
		 * 
		 * System.out.println(false || false);
		 */


		/*
		 * 
		 * int x = 1;
		 * 
		 * int y = 2;
		 * 
		 * System.out.println(x++ == y & ++x > y++); //false & true 结果是false
		 * 
		 * System.out.println(x); //3
		 * 
		 * System.out.println(y); //3
		 */

		/*
		 * 
		 * int x = 1;
		 * 
		 * int y = 2;
		 * 
		 * System.out.println(x++ == y );//flale
		 * 
		 * System.out.println(++x > y++);//true
		 */

		/*
		 * 
		 * int x = 1;
		 * 
		 * int y = 2;
		 * 
		 * System.out.println(x++ == y && ++x > y++); // false&&不再执行,短路
		 * 
		 * System.out.println(x); // 2
		 * 
		 * System.out.println(y); // 2
		 */

		/*
		 * 
		 * int x = 1;
		 * 
		 * int y = 2;
		 * 
		 * System.out.println(x++ == y | ++x > y++); //false|true 结果是true
		 * 
		 * System.out.println(x); //3
		 * 
		 * System.out.println(y); //3
		 */

		/*
		 * 
		 * int x = 1;
		 * 
		 * int y = 2;
		 * 
		 * System.out.println(x++ == y || ++x > y++); //false||true 结果是true
		 * 
		 * System.out.println(x); //3
		 * 
		 * System.out.println(y); //3
		 */

		/*
		 * 
		 * int x = 1;
		 * 
		 * int y = 2;
		 * 
		 * System.out.println(x++ != y || ++x > y++); //true||不再执行 结果是true
		 * 
		 * System.out.println(x); //2
		 * 
		 * System.out.println(y); //2
		 */

		/*
		 * 
		 * int x = 1;
		 * 
		 * int y = 2;
		 * 
		 * System.out.println(x++ != y && ++x > y++); //true&&ture 结果是true
		 * 
		 * System.out.println(x); //3
		 * 
		 * System.out.println(y); //3
		 */

		// 参考题.

		/*
		 * 
		 * System.out.println(5 & 10);// 用5的二进制和10的二进制中每一位进行与运算, 0当作false,
		 * 1当作true
		 * 
		 * System.out.println(15 & 20);
		 */

		/*
		 * 
		 * System.out.println(30 % 16);
		 * 
		 * System.out.println(30 & 15);// &15和%16是一样的
		 * 
		 * System.out.println(40 % 16);
		 * 
		 * System.out.println(40 & 15);
		 */

		/*
		 * 
		 * System.out.println(30 % 8);
		 * 
		 * System.out.println(30 & 7);
		 */

		/*
		 * 
		 * System.out.println(5 | 10);
		 * 
		 * System.out.println(15 | 20);// 将二进制的每一位做或运算
		 */

		/*
		 * 
		 * System.out.println(5 ^ 10);
		 * 
		 * System.out.println(15 ^ 20);
		 */

		// 移位运算符

		/*
		 * 
		 * System.out.println(1 << 1);// 1 * 2
		 * 
		 * System.out.println(1 << 2);// 1 * 4
		 * 
		 * System.out.println(1 << 3);// 1 * 8
		 * 
		 * System.out.println(1 << 4);// 1 * 16
		 */

		/*
		 * 
		 * System.out.println(16 >> 1);
		 * 
		 * System.out.println(16 >> 2);
		 * 
		 * System.out.println(16 >> 3);
		 * 
		 * System.out.println(16 >> 4);
		 */

		/*
		 * 
		 * System.out.println(-16 >> 1);
		 * 
		 * System.out.println(-16 >> 2);
		 * 
		 * System.out.println(-16 >> 3);
		 * 
		 * System.out.println(-16 >> 4);
		 */

		/*
		 * 
		 * System.out.println(-16 >>> 1);// 无论正负, 高位全都补0
		 * 
		 * System.out.println(-16 >>> 2);
		 * 
		 * System.out.println(-16 >>> 3);
		 * 
		 * System.out.println(-16 >>> 4);
		 */

		// 小练习.

		/*
		 * 
		 * int i = 1;
		 * 
		 * System.out.println(i++ + ++i + i++ + ++i);//1+3+3+5=12
		 */

	}
}

/*
 * 运算符
 * 
 * 1.算数运算符
 * 
 * + 在数字, 字符, 字符串相加时是不同的
 * 
 * /整数除法忽略小数部分
 * 
 * % 模数的符号忽略不计, 结果的正负只取决于被模数
 * 
 * ++自增1, 如果写在前面就是先运算后取值, 如果写在后面就是先取值后运算
 * 
 * --自减1, 和++同理
 * 
 * 2.赋值运算符
 * 
 * 赋值运算符就是给运算符左边的变量赋值
 * 
 * = 给运算符左边的变量赋值
 * 
 * += 也是给左边的变量赋值, 例如: x += 5 (含有自动转换动作)类似于 x = x + 5
 * 
 * -=, *=, /=, %= 和+=原理相同
 * 
 * 3.比较运算符
 * 
 * 比较运算符就是比较运算符两边的值, 得到一个布尔值
 * 
 * ==, !=, >, <, >=, <=
 * 
 * 4.逻辑运算符(用于连接boolean类型的表达式)
 * 
 * 对布尔值进行操作, 得到的结果也是布尔值
 * 
 * & 与(并且) AND 左右两边都为true, 结果才为true
 * 
 * | 或(或者) OR 左右两边有一边为true, 结果就为true
 * 
 * && 和 & 运行结果相同, 具有短路效果. 如果前半为false, 那么后半不执行
 * 
 * || 和 | 运行结果相同, 具有短路效果. 如果前半为true, 那么后半不执行
 * 
 * ^ 异或 XOR 两边不同就是true, 相同就是false
 * 
 * ! 非 NOT 取反, 原来是true结果就是false, 原来是false结果就是true
 * 
 * 5.位运算符
 * 
 * 将两个二进制数的每一位进行运算, 0当作false, 1当作true
 * 
 * & 将二进制的每一位做&运算
 * 
 * | 将二进制的每一位做|运算
 * 
 * ^ 将二进制的每一位做^运算
 * 
 * << 将二进制的每一位向左移动, 低位补0. 移动几位就相当于乘以2的几次方
 * 
 * >> 将二进制的每一位向右移动, 高位是0就补0, 高位是1就补1. 移动几位就相当于除以2的几次方
 * 
 * >>> 无符号右移, 无论高位是0还是1, 右移之后都补0
 * 
 * 6,三元运算符
 * 
 * A ：(条件表达式)?表达式1：表达式2；
 * 
 * *如果条件为true，运算后的结果是表达式1；
 * 
 * *如果条件为false，运算后的结果是表达式2；
 * 
 * B：条件运算符运算完之后一定有一个结果
 */

/*分析以下程序运行结果：
int x = 1;
int y = 2;
System.out.println(x++ == y & ++x > y++); 				false
System.out.println(x);  									3
System.out.println(y);  									3

int x = 1;
int y = 2;
System.out.println(x++ == y && ++x > y++);   			false
System.out.println(x);  									2
System.out.println(y);  									2

int x = 1;
int y = 2;
System.out.println(x++ == y | ++x > y++);		
System.out.println(x);  
System.out.println(y);  

int x = 1;
int y = 2;
System.out.println(x++ == y || ++x > y++);		
System.out.println(x);	
System.out.println(y);	

&& 在前半是false的时候短路
|| 在前半是true的时候短路*/