03_Java-运算符-标识符命名规则规范-键盘输入-进制

/**
 * 演示算术运算符的使用 
 */
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); //java是2.5
		// 注释快捷键 ctrl + /, 再次输入 ctrl + / 取消注释
		double d = 10 / 4;//java中10 / 4 = 2, 2=>2.0 
		System.out.println(d);// 是2.0

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

		System.out.println(-10 % 3); // -1
		System.out.println(10 % -3); //1
		System.out.println(-10 % -3);//-1

		//++的使用
		//
		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; 
		int k = j++; // 等价 k =j;j=j+1;
		System.out.println("k=" + k + "j=" + j);//8 9
	}
}

//练习

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


		// int i=1;
		// i=++i; //规则使用临时变量: (1) i=i+1;(2) temp=i;(3)i=temp;
		// System.out.println(i); //2
		// 
		// 测试输出
		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


	}
}

//课堂练习

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 + "天");

		//1.需求
		//定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为
		//：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度
		//
		//2思路分析
		//(1) 先定义一个double huaShi 变量保存 华氏温度
		//(2) 根据给出的公式，进行计算即可5/9*(华氏温度-100)
		//    考虑数学公式和java语言的特性
		//(3) 将得到的结果保存到double sheShi
		//3走代码
		double huaShi = 1234.6;
		double sheShi = 5.0 / 9 * (huaShi - 100);
		System.out.println("华氏温度" + huaShi 
			+ " 对应的摄氏温度=" + sheShi);

	}
}

//演示关系运算符的使用
//

public class RelationalOperator { 

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

		int a = 9;  //老韩提示:  开发中，不可以使用  a, b 
		int b = 8;
		System.out.println(a > b);	//T 
		System.out.println(a >= b); //T
		System.out.println(a <= b); //F
		System.out.println(a < b);  //F
		System.out.println(a == b); //F
		System.out.println(a != b); //T
		boolean flag = a > b; //T
		System.out.println("flag=" + flag);
	}
}

/**
 * 演示逻辑运算符的使用
 */

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
		
	}
}

//演示| || 使用

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");
		}

		//|逻辑或使用
		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) { // 可以换成 | 测试
			System.out.println("ok300");
		}
		System.out.println("a=" + a + " b=" + b); //4 9

	}
}

//!和^案例演示

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);//T
	}
}

//验证

public class Test { 

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

		// int x = 5;
		// int y=5;
		// if(x++==6 & ++y==6){ //逻辑与
		// 	x = 11;
		// }
		// System.out.println("x="+x+",y="+y);
		// //6, 6
		// int x = 5,y = 5;

		// if(x++==6 && ++y==6){
		// 	x = 11;
		// }
		// System.out.println("x="+x+",y="+y);
		// //6, 5
		// 
		// int x = 5,y = 5;
		// if(x++==5 | ++y==5){
		// 	x =11;
		// }
		// System.out.println("x="+x+",y="+y);
		//11, 6
		//
		// int x = 5,y = 5;
		// if(x++==5 || ++y==5){
		// 	x =11;
		// }
		// 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((x=false) || (++z==49))  z++; 
		System. out.println("z="+z); //50 

	}
}

//演示赋值运算符的使用

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 = (byte)(b + 2);
		b++; // b = (byte)(b+1);
		
	}
}

//三元运算符使用

public class TernaryOperator { 

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

		int a = 10;
		int b = 99;
		// 解读
		// 1. a > b 为 false
		// 2. 返回 b--, 先返回 b的值,然后在 b-1
		// 3. 返回的结果是99 
		int result = a > b ? a++ : b--;
		System.out.println("result=" + result);
		System.out.println("a=" + a);
		System.out.println("b=" + b);

	}
}

//三元运算符细节

public class TernaryOperatorDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		//表达式1和表达式2要为可以赋给接收变量的类型
		//(或可以自动转换/或者强制转换)
		int a = 3;
		int b = 8;
		int c = a > b ? (int)1.1 : (int)3.4;//可以的
		double d = a > b ? a : b + 3;//可以的，满足 int -> double
	}
}

public class TernaryOperatorExercise { 

	//编写一个main方法
	public static void main(String[] args) {
		//案例：实现三个数的最大值
		int n1 = 553;
		int n2 = 33;
		int n3 = 123;
		//思路
		//1. 先得到 n1 和 n2 中最大数 , 保存到 max1
		//2. 然后再 求出 max1 和  n3中的最大数，保存到 max2
		
		int max1 = n1 > n2 ? n1 : n2;
		int max2 = max1 > n3 ? max1 : n3;
		System.out.println("最大数=" + max2);

		//使用一条语句实现, 推荐使用上面方法
		//老师提示: 后面我们可以使用更好方法,比如排序
		// int max = (n1 > n2 ? n1 : n2) > n3 ? 
		// 				(n1 > n2 ? n1 : n2) : n3;
		// System.out.println("最大数=" + max);	
		// 
		
	}
}

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;	//x
//int a-b=10;
int goto1 = 10;

hsp		//ok 
hsp12	//ok 
1hsp	//错误, 数字不能开头 
h-s		// 错误 , 不能有 - 
x h		// 错误， 有空格 
h$4		// ok 
class	//错误，class 关键字 
int 	// 错误 ,int 是关键字 
double	//错误 ,double 是关键字 
public	//错误 ,public 是关键字 
static	//错误 ,static 是关键字 
goto	//错误, goto 是保留字 
stu_name	//ok

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);

	}
}

//演示四种进制
//
public class BinaryTest { 

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

		//n1 二进制
		int n1 = 0b1010;
		//n2 10进制
		int n2 = 1010;
		//n3 8进制
		int n3 = 01010;
		//n4 16进制
		int n4 = 0X10101;
		System.out.println("n1=" + n1);
		System.out.println("n2=" + n2);
		System.out.println("n3=" + n3);
		System.out.println("n4=" + n4);
		System.out.println(0x23A);

	}
}

System.out.println(0x23A);	//570

public static void maiin(String []args) 
{ 

	int a=1>>2;	// 1 向右位移 2 位 

	int b=-1>>2;//算术右移 

	int c=1<<2;//算术左移 

	int d=-1<<2;// 

	int e=3>>>2;//无符号右移 

	//a,b,c,d,e 结果是多少 

	System.out.println("a="+a); 

	System.out.println("b="+b); 

	System.out.println("c="+c); 

	System.out.println("d="+d); 

	System.out.println("e="+e); 

} 

~2=?	// 按位取反 

2&3=?	// 2 按位与 3 

2|3=? 

~-5=? 

13&7=? 

5|4=? 

-3^3=?	//^ 按位异或

//位运算


public class BitOperator { 

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

        // 2&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. 按位&
		//   00000000 00000000 00000000 00000010
		//   00000000 00000000 00000000 00000011 
		//   00000000 00000000 00000000 00000010 & 运算后的补码
		//   运算后的原码 也是  00000000 00000000 00000000 00000010
		//   结果就是  2
		System.out.println(2&3);//2

        // ~-2
		//推导
		//1. 先得到 -2的原码 10000000 00000000 00000000 00000010
		//2. -2的 反码 	    11111111 11111111 11111111 11111101
		//3. -2的 补码       11111111 11111111 11111111 11111110
		//4. ~-2操作        00000000 00000000 00000000 00000001运算后的补码
		//5. 运算后的原码 就是 00000000 00000000 00000000 00000001 => 1
		System.out.println(~-2);//1

		//推导
		//1. 得到2的补码 00000000 00000000 00000000 00000010
		//2. ~2操作     11111111 11111111 11111111 11111101  运算后的补码
		//3. 运算后的反码  11111111 11111111 11111111 11111100
		//4. 运算后的原码  10000000 00000000 00000000 00000011=>-3
		System.out.println(~2); //-3
	}
}

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(-10.4%3); // -1.4近似值

int i=66;
System.out.println(++i+i); //134