package cn.temptation;
public class Sample01 {
public static void main(String[] args) {
// 运算符：对常量 或是 变量进行操作的符号
// 分为：算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符
// 1、算术运算符：+、-、*、/、%、++、--
int i = 7;
int j = 2;
System.out.println(i + j); //
System.out.println(i - j); //
System.out.println(i * j); // 14
// int类型的变量 和 int类型的变量做除法，得到的结果是int类型
System.out.println(i / j); // 3
// 要求：就想得到3.5的结果，怎么办？
// 下面的写法不会得到3.5的结果，只会得到3.0的结果，因为只是声明了一个double类型的变量来接收int类型变量和int类型变量相除的结果
// 对于相除的结果没有内容上的影响
double result = i / j;
System.out.println(result); // 3.0
System.out.println((double)(i / j)); // 3.0
// 做一个尝试：使用double类型的字面量常量 和 int类型的字面量常量做除法，会得到double类型的字面量常量
// 即int类型的字面量常量在做除法时进行了类型提升
System.out.println(7.0 / 2); // 3.5
// 类型的提升：把int类型的变量先和double类型的字面量常量1.0做乘法，让结果为double类型，再除以int类型的变量，得到的是double类型的结果
System.out.println(i * 1.0 / j); // 3.5
System.out.println(i % j); //
}
}
package cn.temptation;
public class Sample02 {
public static void main(String[] args) {
// 减号 - 还可以做负号
byte i = 1;
// Type mismatch: cannot convert from int to byte
// byte j = -i;
byte j = (byte) -i;
System.out.println(i);
System.out.println(j);
byte x = -128;
byte y = (byte) -x;
System.out.println(x); // -128
System.out.println(y); // -128
/*
* x： -128（没有超出byte范围）
* -x： 128（int类型）：0000 0000 0000 0000 0000 0000 1000 0000
* 因为强制类型转换为byte类型的变量y，所以要做截取
*
* 补码： 1000 0000 符号位的1表明是负数
* 反码： 1111 1111
* 原码： 1000 0000
*/
// 产生异常：java.lang.ArithmeticException: / by zero
// int k = 123 / 0;
// System.out.println(k);
// 产生异常：java.lang.ArithmeticException: / by zero
// int k = 0 / 0;
// System.out.println(k);
// double k = 123.45 / 2;
// System.out.println(k); // 61.725
//
// double m = 123.45 / 0;
// System.out.println(m); // Infinity（正无穷大）
//
// double n = -123.45 / 0;
// System.out.println(n); // -Infinity（负无穷大）
//
// double result1 = 0.0 / 0;
// System.out.println(result1); // NaN（Not a Number 不是一个数）
//
// double result2 = -0.0 / 0;
// System.out.println(result2); // NaN（Not a Number 不是一个数）
// float k = 123.45F / 2;
// System.out.println(k); // 61.725
//
// float m = 123.45F / 0;
// System.out.println(m); // Infinity（正无穷大）
//
// float n = -123.45F / 0;
// System.out.println(n); // -Infinity（负无穷大）
//
// float result1 = 0.0F / 0;
// System.out.println(result1); // NaN（Not a Number 不是一个数）
//
// float result2 = -0.0F / 0;
// System.out.println(result2); // NaN（Not a Number 不是一个数）
int result1 = 11 % 4;
System.out.println(result1); //
double result2 = 11.0 % 3;
System.out.println(result2); // 2.0
double result3 = 11.0 % 3.5;
System.out.println(result3); // 0.5
// 产生异常：java.lang.ArithmeticException: / by zero
// int result4 = 11 % 0;
// System.out.println(result4);
double result5 = 11.0 % 0;
System.out.println(result5); // NaN（Not a Number 不是一个数）
}
}
package cn.temptation;
public class Sample03 {
public static void main(String[] args) {
// ++ 自增运算符 -- 自减运算符
int i = 2;
System.out.println(i); // 2
// 1、单独使用自增运算符：不论++放在需要自增的变量的后面还是前面，都会在操作后让变量的值自增1
// 自增运算符放在需要自增的变量的后面
// i++;
// 自增运算符放在需要自增的变量的前面
// ++i;
// System.out.println(i); // 3
// 2、非单独使用自增运算符
// 下句语句一上来先把i的值赋值给j，然后i自己做自增（先赋值再自增）
// int j = i++; // j = 2, i = 3
// 下句语句一上来先i自己做自增，然后把i的值（自增后的值）赋值给j（先自增再赋值）
int j = ++i; // j = 3, i = 3
System.out.println("j的值为：" + j);
System.out.println("i的值为：" + i);
}
}
package cn.temptation;
public class Sample04 {
public static void main(String[] args) {
// 关于自增的一道题
int i = 2;
int j = 3;
j = i++;
System.out.println("i的值为：" + i); //
System.out.println("j的值为：" + j); // 2
// j = i++ + ++i+i*4;
// 上句等价于
j = (i++) + (++i) + (i * 4);
/*
* 计算过程：
* i++这个表达式，此时i为3，首先是赋值，再让i自增，所以这个表达式(i++)的结果为3，i操作后的值为4
* ++i这个表达式，此时i为4，首先让i自增，再赋值，所以i操作后的值为5，这个表达式(++i)的结果为5
* i * 4这个表达式，此时i为5，进行乘法，所以这个表达式(i*4)的结果为20
*
* 最后三个表达式的结果相加：3 + 5 + 20 = 28
*/
System.out.println(j);
}
}
package cn.temptation;
public class Sample05 {
public static void main(String[] args) {
// 加号 + 的用法：
/*
* 1、作为算术运算符的加号
* 2、作为正数的符号 +
* 3、作为字符串的连接符号
*/
int result = 1 + 2;
System.out.println(result);
int x = +99;
System.out.println(x);
System.out.println("北京" + 2008);
}
}
package cn.temptation;
public class Sample06 {
public static void main(String[] args) {
// 2、赋值运算符：=、+=、-=、*=、/=、%=
// Java中的一个等号 = 表示的是将等号（赋值号）右侧的内容赋值给等号（赋值号）左侧的变量，习惯上称之为赋值号
int i = 2;
// 完整描述：把整型的字面量常量2 赋值给 整型类型的变量i
// 赋值号左侧的部分称为声明
// 赋值号右侧的部分称为赋值
System.out.println(i);
// 一行语句中声明多个变量
int x, y;
// 下句语句先把123赋值给变量y，再将y赋值给x，所以最后x和y的值均为123
x = y = 123;
System.out.println(x);
System.out.println(y);
// 以+=为例，表示的是将赋值号（+=）左侧的变量 和 右侧的内容按照=之前的运算符进行相应的运算，操作后的结果再赋值给左侧的变量
int j = 3;
System.out.println(j); // 3
// j += 4;
// 上句等价于
j = j + 4;
System.out.println(j); // 7
// byte k = 5;
// // Type mismatch: cannot convert from int to byte
// k = k + 3;
// System.out.println(k);
// 对于非默认数据类型的数据，使用带有算术运算符的赋值运算符时，会自动进行强制类型转换
byte k = 5;
// k += 3;
// 上句等价于
k = (byte) (k + 3);
System.out.println(k);
}
}
package cn.temptation;
public class Sample07 {
public static void main(String[] args) {
// 3、比较运算符：==、!=、>、<、>=、<=
// Java中使用 == 表示相等（内容相等）
// 比较的结果必然是一个boolean类型的值
int i = 2;
int j = 3;
int k = 2;
// System.out.println(i == j); // false
// System.out.println(i == k); // true
// System.out.println(i + j == j + k); // true
// 上句等价于
// System.out.println((i + j) == (j + k)); // true
System.out.println(i != j); // true
System.out.println(i != k); // false
System.out.println(i > j); // false
System.out.println(i < j); // true
System.out.println(i >= j); // false
System.out.println(i <= j); // true
System.out.println(k <= k); // true
}
}
package cn.temptation;
public class Sample08 {
public static void main(String[] args) {
// 逻辑运算符：&、|、!、^、&&、||
// 参与运算的变量或表达式的值均为boolean类型
/*
* &：逻辑与，有一个是false得到的结果就是false
* |：逻辑或，有一个是true得到的结果就是true
* !：逻辑非，颠倒黑白
* ^：逻辑异或，类似吸铁石
*/
// System.out.println(true & true); // true
// System.out.println(true & false); // false
// System.out.println(false & true); // false
// System.out.println(false & false); // false
// System.out.println(true | true); // true
// System.out.println(true | false); // true
// System.out.println(false | true); // true
// System.out.println(false | false); // false
// System.out.println(!true); // false
// System.out.println(!false); // true
// System.out.println(true ^ true); // false
// System.out.println(true ^ false); // true
// System.out.println(false ^ true); // true
// System.out.println(false ^ false); // false
/*
* &&：逻辑与（聪明与/短路与）如果参与运算的第一个变量或表达式为false，得到的结果就是false，其他的变量或表达式就不去执行；如果多个逻辑与参与运算，以此类推
* ||：逻辑或（聪明或/短路或）如果参与运算的第一个变量或表达式为true，得到的结果就是true，其他的变量或表达式就不去执行；如果多个逻辑或参与运算，以此类推
*/
// System.out.println(true && true); // true
// System.out.println(true && false); // false
// // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
// System.out.println(false && true); // false
// // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
// System.out.println(false && false); // false
// eclipse会显示警告：Dead code（位于后一个变量或表达式上）
System.out.println(true || true); // true
// eclipse会显示警告：Dead code（位于后一个变量或表达式上）
System.out.println(true || false); // true
System.out.println(false || true); // true
System.out.println(false || false); // false
// 在实际的开发中，常用的是：!、^、&&、||
}
}
package cn.temptation;
public class Sample09 {
public static void main(String[] args) {
// 结合自增 和 逻辑运算符的一道题
int i = 2;
int j = 3;
System.out.println((++i == 2) && (j++ == 3)); // false
// 因为++i先自增再赋值，表达式++i的结果为3，所以++i == 2这个表达式的结果为false
// 又因为使用聪明与，第一个表达式为false，后续的表达式不会执行，所以i = 3， j = 3
// 问：最终显示i和j的值为多少？
System.out.println(i); //
System.out.println(j); //
}
}
package cn.temptation;
public class Sample10 {
public static void main(String[] args) {
// 位运算符：&、|、~、^、>>、>>>、<<
/*
* 规则：（在二进制中）操作的是补码
* &：位与，进行操作的两个数的同一位上，有一个是0，该位运算的结果就是0
* |：位或，进行操作的两个数的同一位上，有一个是1，该位运算的结果就是1
* ~：位非，进行操作的数按位取反
* ^：位异或，进行操作的两个数的同一位上，两个相同为0，两个不同为1
*/
// System.out.println(2 & 3); // 2
// System.out.println(2 | 3); // 3
// System.out.println(~2); // -3
// System.out.println(2 ^ 3); //
/*
* 2：0000 0010
* 3：0000 0011
*
* 2
* 原码：0000 0000 0000 0000 0000 0000 0000 0010
* 反码：0000 0000 0000 0000 0000 0000 0000 0010
* 补码：0000 0000 0000 0000 0000 0000 0000 0010
*
* ~2：（操作补码）
* 补码：1111 1111 1111 1111 1111 1111 1111 1101
* 反码：1111 1111 1111 1111 1111 1111 1111 1100
* 原码：1000 0000 0000 0000 0000 0000 0000 0011
*/
// 位异或^的用法：
// 规律：一个数连续两次和另一个数做位异或运算，得到其本身的值
// 可以应用在简单的加密解密中，连续两次进行位异或的那个数可以设置为密钥
System.out.println(2 ^ 3 ^ 3); //
/*
* <<：左移，左边的高位删除，右边的低位补0
* >>：右移，因为左侧的最高位是符号位，所以要区分是0还是1：左侧的最高位是0，左侧补0；左侧的最高位是1，左侧补1
* >>>：无符号右移，不论左侧的最高位是0还是1，左侧补0
*/
System.out.println(2<<1); //
System.out.println(2>>1); //
System.out.println(-2>>1); // -1
System.out.println(-2>>>1); //
/*
* -2：
* 原码：1000 0000 0000 0000 0000 0000 0000 0010
* 反码：1111 1111 1111 1111 1111 1111 1111 1101
* 补码：1111 1111 1111 1111 1111 1111 1111 1110
*
* 右移1位操作（操作补码）
* 补码：1111 1111 1111 1111 1111 1111 1111 1111
* 反码：1111 1111 1111 1111 1111 1111 1111 1110
* 原码：1000 0000 0000 0000 0000 0000 0000 0001
*
* 无符号右移1位操作（操作补码）
* 补码：0111 1111 1111 1111 1111 1111 1111 1111
* 反码：0111 1111 1111 1111 1111 1111 1111 1111
* 原码：0111 1111 1111 1111 1111 1111 1111 1111
*/
}
}
package cn.temptation;
public class Sample11 {
public static void main(String[] args) {
// 依据参与运算的元素个数分类：
// 1、一元运算符：!、~
// 2、二元运算符：+、-、*、/、%、&、|、&&、||、^等等
// 3、三元运算符：由两个符号组成的复合运算符 ? :
// 三元运算符：只有一个
// 格式：(比较表达式) ? (比较表达式为真值时，执行的内容) : (比较表达式为假值时，执行的内容);
int i = 2;
int j = 3;
int result = ((i > j) ? i : j);
System.out.println(result);
}
}
package cn.temptation;
public class Sample12 {
public static void main(String[] args) {
// 需求：取得给定的两个数字中较大的一个（使用三元运算符来做）
// int x = 28;
// int y = 17;
// int max = (x > y) ? x : y;
// System.out.println(max);
// 需求：取得给定的三个数字中最大的一个（使用三元运算来做）
/*
* 思路：
* 1、要获取三个数字中最大的，先拿出两个数字比一比，先找出这两个数字中较大的一个
* 2、拿着比较出来的较大的那个数字再和剩下的那个数字做比较，如果剩下的那个数字比它大，那么剩下的那个数字就是最大的
* 否则，比较出来的较大的那个数字就是最大的
*/
int a = 5;
int b = 4;
int c = 6;
// 分步操作
// // 1、要获取三个数字中最大的，先拿出两个数字比一比，先找出这两个数字中较大的一个
// int temp = (a > b) ? a : b;
// // 2、拿着比较出来的较大的那个数字再和剩下的那个数字做比较
// int max = (temp > c) ? temp : c;
// System.out.println("最大的数字为：" + max);
// 如果就要在一行语句中写，如何实现？需要使用三元运算符的嵌套
// 如下写法，在实际开发中不要这样写，可读性很差，纯炫技耳！
int max = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
System.out.println("最大的数字为：" + max);
}
}
package cn.temptation;
import java.util.Scanner;
public class Sample13 {
public static void main(String[] args) {
// 需求：通过键盘的录入，把输入的数据赋值给变量（交互操作的需求）
// 创建一个扫描器对象
Scanner input = new Scanner(System.in);
System.out.println("输入一个数字：");
// 接收用户的键盘的录入，并赋值给声明的变量
int i = input.nextInt();
// 扫描器对象使用完毕后，关闭
input.close();
System.out.println("用户通过键盘录入的数字为：" + i);
}
}
package cn.temptation;
import java.util.Scanner;
public class Sample14 {
public static void main(String[] args) {
// 需求：通过键盘录入三个数字，比较获取其中最大的一个
// 声明三个变量来接收键盘录入的三个数字
Scanner input = new Scanner(System.in);
System.out.println("输入第一个数字：");
int i = input.nextInt();
System.out.println("输入第二个数字：");
int j = input.nextInt();
System.out.println("输入第三个数字：");
int k = input.nextInt();
input.close();
// 分步操作
int temp = (i > j) ? i : j;
int max = (temp > k) ? temp : k;
System.out.println("输入的数字：" + i + "," + j + "," + k + "中，最大的数字为：" + max);
}
}