Java 运算符

//*****************************************************************************************************//
//**********************************************64***************************************************//
//*****************************************************************************************************//
/**
 * 演示算术运算符的使用 
 */
public class ArithmeticOperator { 

	//编写一个main方法
	public static void main(String[] args) {
		// /使用
		System.out.println(10 / 4); //从数学来看是2.5, java中 2
		System.out.println(10.0 / 4); //2.5
		System.out.println(float(10) / 4); //2.5

		// 注释快捷键 ctrl + /, 再次输入 ctrl + / 取消注释
		double d = 10 / 4; // 10/4=2, 2=>2.0
		System.out.println(d);// 是2.0

		 % 取模 ,取余
		 在 % 的本质 看一个公式!!!! a % b = a - a / b * b
		 -10 % 3 =-1     正负--->前面的数字-10      (-)10 % 3 =(-)1
		10 % -3 = 1      +---->+                  (10) % (-)3 =(+) 1
		 -10 % -3 =-1     ----->-                 (-)10 % -3 =(-)1
		System.out.println(10 % 3); //1

		++的使用
		单独时候：i++=====++i.
		int i = 10;
		i++;//自增 等价于 i = i + 1; => i = 11   （单独使用）
		++i;//自增 等价于 i = i + 1; => i = 12   （单独使用）
		System.out.println("i=" + i);//12


		作为表达式使用
        前++：++i先自增后赋值
        后++：i++先赋值后自增

		int j = 8;
		int k = ++j; //等价 j=j+1;k=j;
		System.out.println("k=" + k + "j=" + j);//9 9

		int k = j++; // 等价 k =j;j=j+1;
		System.out.println("k=" + k + "j=" + j);//8 9
	}
}
//*****************************************************************************************************//
//**********************************************65*****************************************************//
//*****************************************************************************************************//
//练习
public class ArithmeticOperatorExercise01 {
	//编写一个main方法
	public static void main(String[] args) {
		 int i = 1;//i->1
		 i = i++; //规则使用临时变量: (1) temp=i;核心！！！(2) i=i+1;(3)i=temp;
		System.out.println(i); // 1    第一步就给了1，所以i＝1

		 int i=1;
		 i=++i; //规则使用临时变量: (1) i=i+1;(2) temp=i;(3)i=temp;
		 System.out.println(i); //2
//*****************************************************************************************************//
//*******************************************66*******************************************************//
//*****************************************************************************************************//
		 测试输出
		int i1 = 10;
		int i2 = 20;
		int i = i1++;
		System.out.print("i="+i);//10
		System.out.println("i2="+i2);//20
		i = --i2;
		System.out.print("i="+i);//19
		System.out.println("i2="+i2);//19
	}
}
//*****************************************************************************************************//
//************************************************67***************************************************//
//*****************************************************************************************************//
//课堂练习
public class ArithmeticOperatorExercise02 {
	//编写一个main方法
	public static void main(String[] args) {

		//1.需求:
		//假如还有59天放假，问：合xx个星期零xx天
		//2.思路分析
		//(1) 使用int 变量 days 保存 天数
		//(2) 一个星期是7天 星期数weeks： days / 7 零xx天leftDays days % 7
		//(3) 输出

		//3.走代码
		int days = 25911;
		int weeks = days / 7;
		int leftDays = days % 7;
		System.out.println(days + "天 合" + weeks + "星期零"
				+ leftDays + "天");
//*****************************************************************************************************//
//************************************************68***************************************************//
//*****************************************************************************************************//
		//1.需求
		//定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为
		//：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度
		//
		//2思路分析
		//(1) 先定义一个double huaShi 变量保存 华氏温度
		//(2) 根据给出的公式，进行计算即可5/9*(华氏温度-100)
		//    考虑数学公式和java语言的特性
		//(3) 将得到的结果保存到double sheShi
		//3走代码
		double huaShi = 1234.6;
		//double sheShi = 5 / 9 * (huaShi - 100);------>5/9=0,错误！！
		        就像1/2+1/3+1/4···--->1.0/2+1.0/3+1.0/4···
		double sheShi = 5.0 / 9 * (huaShi - 100);
		System.out.println("华氏温度" + huaShi
				+ " 对应的摄氏温度=" + sheShi);

	}
}
//*****************************************************************************************************//
//****************************************70 ********************************************************//
//*****************************************************************************************************//
//演示关系运算符的使用
public class RelationalOperator {
	//编写一个main方法
	public static void main(String[] args) {

		int a = 9;  //老韩提示:  开发中，不可以使用  a, b
		int b = 8;
		System.out.println(a > b);    //true
		System.out.println(a >= b);   //true
		System.out.println(a <= b);   //false
		System.out.println(a < b);    //false
		System.out.println(a == b);   //false
		System.out.println(a != b);   //true
		boolean flag = a > b;
		System.out.println("flag=" + flag); //flag=true
	}
}
//*****************************************************************************************************//
//******************************************72*********************************************************//
//*****************************************************************************************************//
/**
 * 演示逻辑运算符的使用
 */
public class LogicOperator01 {
	//编写一个main方法
	public static void main(String[] args) {
		//&&短路与  和 & 案例演示
		int age = 50;
		if(age > 20 && age < 90) {
			System.out.println("ok100");
		}

		//&逻辑与使用
		if(age > 20 & age < 90) {
			System.out.println("ok200");
		}

		//区别
		int a = 4;
		int b = 9;
		//对于&&短路与而言，如果第一个条件为false ,后面的条件不再判断
		//对于&逻辑与而言，如果第一个条件为false ,后面的条件仍然会判断
		&&效率高！！！！  &无脑执行判断
		if(a < 1 & ++b < 50)    错 & ？--->都执行！！无论如何
			System.out.println("ok300");
		System.out.println("a=" + a + " b=" + b);// 4 10
                                            对 & ？===对 && ？ （没区别）

		if(a < 1 && ++b < 50)   错 & ？--->错之后，立刻停止！！不执行？  高效！基本上算法题，只用&&。
			System.out.println("ok300");    第一个×之后，100%确定肯定是对的。
		System.out.println("a=" + a + " b=" + b);// 4 9
	}
}
//*****************************************************************************************************//
//*********************************************73******************************************************//
//*****************************************************************************************************//
//演示| || 使用
public class LogicOperator02 {
	//编写一个main方法
	public static void main(String[] args) {

		//||短路或  和 |逻辑或 案例演示
		//|| 规则: 两个条件中只要有一个成立，结果为true,否则为false
		//| 规则: 两个条件中只要有一个成立，结果为true,否则为false
		int age = 50;
		if(age > 20 || age < 30)    √ & ？--->√之后，立刻停止！！不执行？  高效！基本上算法题，只用&&。
			System.out.println("ok100");   第一个√之后，100%确定肯定是对的。


		//&逻辑与使用
		if(age > 20 | age < 30)     √ & ？--->都执行！！无论如何
			System.out.println("ok200");

		//看看区别
		//(1)||短路或：如果第一个条件为true，
		//则第二个条件不会判断，最终结果为true，效率高
		//(2)| 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低
		int a = 4;
		int b = 9;
		if( a > 1 || ++b > 4)       √ & ？--->√之后，立刻停止！！不执行 ++b
			System.out.println("ok300");
		System.out.println("a=" + a + " b=" + b); //4 9

		if( a > 1 | ++b > 4)  // 可以换成 | 测试
			System.out.println("ok300");
		System.out.println("a=" + a + " b=" + b); //4 10
	}
}
//*****************************************************************************************************//
//********************************************74*******************************************************//
//*****************************************************************************************************//
//!和^案例演示

public class InverseOperator {
	//编写一个main方法
	public static void main(String[] args) {

		//! 操作是取反 T->F  , F -> T
		System.out.println(60 > 20); //T
		System.out.println(!(60 > 20)); //F

		//a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为true, 否则为false
		boolean b = (10 > 1) ^ ( 3 < 5);   √^√-->×
		System.out.println("b=" + b);   //false

		boolean b = (10 > 1) ^ ( 3 > 5);   √^×-->√
		System.out.println("b=" + b);  //true
	}
}
//*****************************************************************************************************//
//********************************************75******************************************************//
//*****************************************************************************************************//
//验证

public class Test {

	//编写一个main方法
	public static void main(String[] args) {

		 int x = 5;
		 int y=5;
		 if(x++==6 & ++y==6)      //x==6,x+1--->x x=6 ;   y+1=6 6==6 √
		 	x = 11;               //  结果：x
		 System.out.println("x="+x+",y="+y);   //6 6

		 int x = 5,y = 5;
		 if(x++==6 && ++y==6)     //x==6,x+1--->x x=6 停止！！！
		 	x = 11;                   y不变，一直是5
		 System.out.println("x="+x+",y="+y);  //6, 5

		 int x = 5,y = 5;
		 if(x++==5 | ++y==5)      //x==5,x+1=6 √   y+1=6,6==5 ×
		 	x =11;                   结果：√,x=11
		 System.out.println("x="+x+",y="+y);   //11, 6

		 int x = 5,y = 5;
		 if(x++==5 || ++y==5)      //x==5,x+1=6 √ 停止！！
		 	x =11;                           //y一直不变！！
		 System.out.println("x="+x+",y="+y);   //11, 5

		boolean x=true;
		boolean y=false;
		short z=46;
		if( (z++==46)&& (y=true) )   z++;  ----->if( (z++==46)&& (true) )
			                                       z==46 √，z+1=47  && true--->√，z++--->z=48
		if((x=false) || (++z==49))  z++;   ----->if((false) || (++z==49))
			                                          ×  判断：z=48 先z+1=49  49==49,所以√，总的结果：√，z++=50
		System. out.println("z="+z); //50

		有个细节：x=false  x==false 有区别！！    (x=false)---->(false)  (x==false),结果跟x有关，判断值
	}
}
//*****************************************************************************************************//
//*******************************************77********************************************************//
//*****************************************************************************************************//
//演示赋值运算符的使用
public class AssignOperator {
	//编写一个main方法
	public static void main(String[] args) {

		int n1 = 10;
		n1 += 4;// n1 = n1 + 4;
		System.out.println(n1); // 14
		n1 /= 3;// n1 = n1 / 3;//4
		System.out.println(n1); // 4

		//复合赋值运算符会进行“强制类型”转换
		byte b = 3;             b+=2  不等价于 b=b+2  因为，b(byte) = b+2(int),不能直接转换！！
		b += 2; // 等价 b = (byte)(b + 2);     复合赋值运算符，会自动给你“强制转换”！！！注意细节
		b++; // b = (byte)(b+1);    同样，这个也是给你“强制转换”了
	}
}
//*****************************************************************************************************//
//*****************************************************************************************************//
//*****************************************************************************************************//
public class Main {
	public static void main(String[] args) {
		int a = 9;  //老韩提示:  开发中，不可以使用  a, b
		int b = 8;
		int c=10;
		int g=a=b=c;
		System.out.println(g); //10
		System.out.println(a); //10
		System.out.println(b); //10
		System.out.println(c); //10
	}
}
//*****************************************************************************************************//
//************************************************78**************************************************//
//*****************************************************************************************************//
//三元运算符使用
public class TernaryOperator {
	public static void main(String[] args) {

		int a = 10;
		int b = 99;
		int result = a > b ? a++ : b--;     a：输出10，自己+1  or  b：输出99，自己-1
		System.out.println("result=" + result);   //x--->b 99
		System.out.println("a=" + a);   // 10
		System.out.println("b=" + b);   //98
	}
}
//*****************************************************************************************************//
//**********************************************79****************************************************//
//*****************************************************************************************************//
//三元运算符细节
public class TernaryOperatorDetail {
	//编写一个main方法
	public static void main(String[] args) {
		//表达式1和表达式2要为可以赋给接收变量的类型
		//(或可以自动转换/或者强制转换)
		int a = 3;
		int b = 8;
		int c = a > b ? 1.1 : 3.4;  //double--x-->int 错误！
		int c = a > b ? (int)1.1 : (int)3.4;//可以的
		double d = a > b ? a : b + 3;//可以的，满足 int -> double
		等价于：            double d+1 = a > b ? a : b + 3; 不行！！
		if (a>b)                  必须是变量或者常量。不能是运算符号。因为： d+3=a 错的！
			d=a;             解决方法：t=d+1;
		else						 t=a > b ? a : b + 3; 通过t来代替。这就行啦~
		d=b+3
	}
}
//*****************************************************************************************************//
//************************************************80**************************************************//
//*****************************************************************************************************//

public class TernaryOperatorExercise {
	//编写一个main方法
	public static void main(String[] args) {

		//案例：实现三个数的最大值
		int n1 = 553;
		int n2 = 33;
		int n3 = 123;
		//思路
		int max1 = n1 > n2 ? n1 : n2;        //1. 先得到 n1 和 n2 中最大数 , 保存到 max1
		int max2 = max1 > n3 ? max1 : n3;    //2. 然后再 求出 max1 和  n3中的最大数，保存到 max2
		System.out.println("最大数=" + max2);

		使用一条语句实现, 推荐使用上面方法：
		 int max = (n1 > n2 ? n1 : n2) > n3 ? (n1 > n2 ? n1 : n2) : n3;
		// System.out.println("最大数=" + max);

//*****************************************************************************************************//
//************************************************82**************************************************//
//*****************************************************************************************************//
//代码变量规范
		int 2ab=10;  错！！开头不能是数字！
		int abcclass = 10;     //包含关键字可以
		int n = 40;
		int N = 50;
		System.out.println("n=" + n);//40
		System.out.println("N=" + N);//50

		//? abc 和 aBc 是两个不同变量
		int abc = 100;
		int aBc = 200;

		int a b = 300;   //只能是 _ $ 数字 字母
		int a-b=10;  错误！！  改进： int t=a-b;  t=10; 这样可以！
		int goto1 = 10;
		int goto = 10; 错误！！goto 是保留字
	}
}
//*****************************************************************************************************//
//******************************************86********************************************************//
//*****************************************************************************************************//
import java.util.Scanner;  //表示把java.util下的Scanner类导入
public class Input {

	//编写一个main方法
	public static void main(String[] args) {
		//演示接受用户的输入
		//步骤
		Scanner类 表示 简单文本扫描器，在java.util 包
		1. 引入/导入 Scanner类所在的包
		2. 创建 Scanner 对象 , new 创建一个对象,体会
		   myScanner 就是 Scanner类的对象
		Scanner myScanner = new Scanner(System.in);
		//3. 接收用户输入了， 使用 相关的方法
		System.out.println("请输入名字");

		//当程序执行到 next 方法时，会等待用户输入~~~
		String name = myScanner.next(); //接收用户输入字符串
		System.out.println("请输入年龄");
		int age = myScanner.nextInt(); //接收用户输入int
		System.out.println("请输入薪水");
		double sal = myScanner.nextDouble(); //接收用户输入double
		System.out.println("人的信息如下:");
		System.out.println("名字=" + name + " 年龄=" + age + " 薪水=" + sal);
	}
}
//*****************************************************************************************************//
//**************************************87*************************************************************//
//*****************************************************************************************************//
//演示四种进制
//
public class BinaryTest {
	//编写一个main方法
	public static void main(String[] args) {

		//n1 二进制 0b
		int n1 = 0b1010;    //10
		//n2 10进制
		int n2 = 1010;      //1010
		//n3 8进制: 0
		int n3 = 01010;     //520
		//n4 16进制：0x 0X
		int n4 = 0X10101;   //65793
		System.out.println("n1=" + n1);
		System.out.println("n2=" + n2);
		System.out.println("n3=" + n3);
		System.out.println("n4=" + n4);

		System.out.println(0x23A);   //570     A(10)*16e0+3*16e1+2*16e2
	}
}
//*****************************************************************************************************//
//**********************************************100*****************************************************//
//*****************************************************************************************************//
//位运算
public class BitOperator {
	//编写一个main方法
	public static void main(String[] args) {

		看老师的推导过程   正数：原码=补码
		1. 先得到 2的补码 => 2的原码 00000000 00000000 00000000 00000010
		                   2的补码 00000000 00000000 00000000 00000010
		2. 3的补码=>        3的原码 00000000 00000000 00000000 00000011
		                   3的补码 00000000 00000000 00000000 00000011
		3. 按位&            按位&规则：1&1=1 1&0=0&1=0&0=0  1-->true  0-->false
				2的补码 =>  00000000 00000000 00000000 00000010
		        3的补码 =>  00000000 00000000 00000000 00000011
		   &运算后的补码 =>  00000000 00000000 00000000 00000010  （补码是正数，则补码=原码）
		   运算后的原码  =>  00000000 00000000 00000000 00000010
		   结果就是  2
		System.out.println(2 & 3);  //2

		推导
		1. -2的原码  =>  10000000 00000000 00000000 00000010
		2. -2的 反码 =>	11111111 11111111 11111111 11111101  (负数反码=补码的符号位不变，其他取反)
		3. -2的 补码 =>  11111111 11111111 11111111 11111110  (负数补码=反码+1)
		4. ~-2操作： =>  00000000 00000000 00000000 00000001  <== 运算后的补码
		5. 运算后的原码 =>00000000 00000000 00000000 00000001 => 1
		System.out.println(~ -2);  //1

		推导                  正数：原码=补码    ~2:取反：1-->0 0-->1
		1. 得到2的补码 00000000 00000000 00000000 00000010
		2. ~2操作     11111111 11111111 11111111 11111101 <=运算后的补码 （发现是：负数）那么，负数补码-1=反码
		3.运算后的反码 11111111 11111111 11111111 11111100  （-1）						反码取反，符号位不变=原码
		4.运算后的原码 10000000 00000000 00000000 00000011=>-3  （反码取反，符号位不变）
		System.out.println(~2);  //-3
		原码 10000000 00000000 00000000 00000011=>-3
		原码 00000000 00000000 00000000 00000011=> 3

		推导                  正数：原码=补码
		1. 先得到 2的补码 => 2的原码 00000000 00000000 00000000 00000010
		                   2的补码 00000000 00000000 00000000 00000010
		2. 3的补码=>        3的原码 00000000 00000000 00000000 00000011
		                   3的补码 00000000 00000000 00000000 00000011
		3. 按位或 |         按位或 | 规则：1|1=1|0=0|1=1  0|0=0  1-->true  0-->false
		                   2的补码 =>  00000000 00000000 00000000 00000010
		                   3的补码 =>  00000000 00000000 00000000 00000011
				      &运算后的补码 =>  00000000 00000000 00000000 00000011  （补码是正数，则补码=原码）
		              运算后的原码  =>  00000000 00000000 00000000 00000011--->3
		System.out.println(2 | 3);  //3

		推导                  正数：原码=补码
		1. 先得到 2的补码 => 2的原码 00000000 00000000 00000000 00000010
		                   2的补码 00000000 00000000 00000000 00000010
		2.       3的补码=>  3的原码 00000000 00000000 00000000 00000011
		                   3的补码 00000000 00000000 00000000 00000011
		3. 按位异或          按位异或 ^ 规则：1^0=0^1=1 0^0=1^1=0  1-->true  0-->false
		                   2的补码 =>  00000000 00000000 00000000 00000010
		                   3的补码 =>  00000000 00000000 00000000 00000011
				      &运算后的补码 =>  00000000 00000000 00000000 00000001  （补码是正数，则补码=原码）
		              运算后的原码  =>  00000000 00000000 00000000 00000001--->1
		System.out.println(2 ^ 3);  //1
	}
}
//*****************************************************************************************************//
//***********************************************101*************************************************//
//*****************************************************************************************************//
public class BitOperator02 {

	//编写一个main方法
	public static void main(String[] args) {
		System.out.println(1 >> 2); //0
		System.out.println(1 << 2); //4
		System.out.println(4 << 3); // 4 * 2 * 2 * 2 = 32
		System.out.println(15 >> 2); // 15 / 2 / 2 = 3
		System.out.println(15 >>> 2); // 15 / 2 / 2 = 3

		System.out.println(-10.4%3); // -1.4近似值  -1.4000000000000004

		int i=66;
		System.out.println(++i+i); //134  先自增：67 然后,i+i=134
	}
}
//*****************************************************************************************************//
//*******************************************102********************************************************//
//*****************************************************************************************************//
		10/3=3;   -10.5%3=-10.5-(-10)/3*3=-10.5+9=-1.5 (有时候是近似值！)
		a是小数：a%b=a-(int)a/b*b

		int i=66;
		System.out.println(++i+i);   // i=i+1-->i=67 i+i=134

		int num1=(int)"18"  错！！应该是： int num1 = Integer.parselnt("18");
		int num2=18.0   错误！！ double--x-->int
		double num3=3d  对！ xxd--->double
		int i=48; char ch=i+1;  错！！int--x-->char
		byte b=19; short s=b+2;  错！！int--x-->byte

		记住：char byte short 运算，变成 int!!!