今天我们主要学习，各种运算符，包括算术运算符，赋值运算符，关系运算符，逻辑运算符，位运算符和三目运算符，以及最后简单学习了利用Scanner接收键盘输入的代码。
重点：
算术运算符： +(3中含义)， /（除数和被除数都是整数时结果丢弃小数位），%, ++及--(理解++和--运算符在变量之前和变量之后的区别)。
赋值运算符：注意复合赋值运算的含义比如：+=，-=，/=, %=等等
关系运算符：注意不要把== 写成 =
逻辑运算符： && 和 ||的短路效果的含义，以及 & | ！^四个运算符的含义，最后要注意利用 &&运算符来表示范围的判断, 比如 a>= 3 && a <=10
位运算：熟悉 <<，>>, >>>， &，|，^,这几个位运算符的含义
三目运算符：熟悉三目运算符的格式，及使用
public class Demo1 {
public static void main(String[] args) {
//关于 默认值 1, 2 默认类型是int
long a = 88888888888L; //通过给整数字面量加后缀L或l声明字面量为l
// 3.0, 2.1 默认类型double
float b = 3.0F; //通过给小数字面量，加f后缀声明，小数字面量的类型是float类型
//关于小数的表示
double c = 314.0;
//科学计数法
c = 3.14e2; // 3.14 * 10^2
System.out.println(c);
//关于字符的问题
// 编码表，一个字符，要被保存到计算机中，只能以数值的形式
// 一个字符对应的数值，也就是字符和字符对应的数值对应关系，编码表
// ascII码表
// 'a' 97
// 'b' 98
System.out.println('a');//输出结果为a
System.out.println('a'=1);
//输出结果为98.'a'先转换成int类型，再+1
/*
1.byte，short，char -> int -> long -> float -> double
2.byte,short,char相互之间不转换，他们参与运算首先转换为int类型。
*/
System.out.println((char)('a' + 1));//输出结果为b
}
1.算术运算符
算术运算符的注意事项：
对于+运算符
加法
正数
字符串拼接： "hello" + "world" ="helloworld"
public class AddOperator {
public static void main(String[] args) {
//1加法
int a = 1;
int b = 2;
System.out.println(a + b);
//2. 表示正数的正号
a = +1;
//3.字符串拼接
// 操作数1 + 操作数2 两个操作数中，只要至少有一个是字符串，+操作执行的就是字符串拼接
System.out.println("hello" + 'a' + 1); // helloa1
System.out.println('a' + 1 + "hello"); // 98hello
System.out.println("5+5="+5+5); //5+5=55
System.out.println(5+5+"=5+5");//10=5+5
}
}
对于/运算符
整数相除只能得到整数
%
/**
*
* /: 除法运算
* %: 求余数的操作
*/
public class DivideOperator {
public static void main(String[] args) {
int a = 3;
int b = 2;
//当参与除法运算的除数和被除数，他们都是整数的时候，此时除法运算的结果，
// 会丢弃小数部分，只保留整数部分
int c = a / b;
double d = a / b; //1 -> 1.0，这里只是把a/b的结果1转化为double类型
//隐式类型转化
double e = 1.0 * a / b;
System.out.println(e); //结果为1.5。1.0默认为double型
// %
int f = 5 % 3; //2
System.out.println(f);
}
}
++和--
(++或--)单独使用效果, 若参与运算，位置不同，效果不同
++: 让一个变量自增1 ，a++ 等价于 a = a + 1
--: 让一个变量的值自减1， b-- 等价于b = b - 1
注意事项：
1. ++，--,他们都既可以放在变量之后(a++ b--), 也可以被放在变量之前(++a, --b)
2. 当++ 或者 --,他们不参与任何其他运算的时候，++或--，在变量前或者变量之后是没有区别的
3. 但是一旦++或者--，参与其他运算的时候，它们就会有一点区别：
对于 ++ 而言：
当++在后的时候，参与运算的时候，首先a原本的值参与运算，a的值再自增1，即 a++ + 1，运算过程相当于先a +1再运算a++
++在前，++a + 1 ，参与运算的时候，首先自增，再参与运算
对于--而言：--在前和--在后，区别与 ++在前和++在后
public class IncAndDes {
public static void main(String[] args) {1
//++
int a = 1;
a++;
System.out.println("a++ = " + a);
a = 1;
++a;
System.out.println("++a = " + a);
//--
int b = 2;
b--;
System.out.println("b-- = " + b);
b = 2;
--b;
System.out.println("--b = " + b);
//++在前和在后的区别
a = 1;
int result = a++ + 1;
//System.out.println(result);
//System.out.println(a);
a = 1;
result = ++a + 1;
//System.out.println(result);
//System.out.println(a);
//--
b = 2;
result = b-- - 1;
System.out.println(result);
System.out.println(b);
b = 2;
result = --b - 1;
System.out.println(result);
System.out.println(b);
//
a = 4;
// 4 + 6 + 60
b = (a++) + (++a) + (a * 10);
System.out.println(b);
}
}
2.赋值运算符
符号：= , +=, -=, *=, /=, %=，其中=为基本的赋值运算符，其他的为扩展的赋值运算符
3.比较运算符
关系运算符的结果只有两种true or false
注意和“=”区分不要把“==”写成“=”
4.逻辑运算符
注意事项:
关于数值范围的描述的表达，比如 1 < a < 10
单“&”与双“&&”的区别(短路)
异或(^) VS 或(|)运算符
/**
* 逻辑运算符
* &: true & false = false true & true = true false & true = false false & false = false
* 只要至少有一个操作数是false，结果就是false，只有当两个操作数都是true的时候，&运算的结果，才是true
*
* |: true | false = true true | true = true false & true = true false | false = false
* 只要至少有一个操作数是true，结果就是true，只有当两个操作数都是false，|运算的结果采薇false
*
* !: !true = false !false = true
*
* 注意事项:
1.关于数值范围的描述的表达，比如 1 < a < 10
异或(^) VS 或(|)运算符
单“&”与双“&&”的区别(短路)
* && VS & 都是与运算，他们有什么区别呢？
* false 与 （a > b）
*
* && 与运算比较智能, 当它发现&&运算符的第一个操作数结果已经是false，
* 第二个操组数(对应的表达式)不去管他，直接得到结果&&的结果false
*
* & 这种与运算，比较的死板，即使&第一个操作数，它已经是false，此时它仍然会计算第二个操作数(表达式)，
* 在把计算好的两个操作数的结果，做与运算，得到最终结果
*
* &&: 有短路效果，当第一个操作数为false，直接得出与运算的结果
*
* 或运算符只要至少有一个操作数是true，结果就是true
* true 或（a == b）
*
* ||
* |
*
* ||或运算比较智能，有短路效果
*
* 异或运算 ^: 相同为false， 不同为true
* true ^ true = false false ^ false = false
* true ^ false = true false ^ true = true
*
*/
public class Demo {
public static void main(String[] args) {
int a = 2;
int b = 3;
boolean c = a > b & a++ == 0;
System.out.println(a);
a = 2;
//证明&& 操作符比较智能
c = a > b && a++ == 0;
System.out.println(a);
//证明||有短路效果
a = 2;
c = a < b || a++ == 0;
System.out.println(a);
//异或运算
c = true ^ false;
c = true ^ true;
System.out.println(c);
//表示一个范围
a = 3;
//判断a变量的值是否在[1,10) 1 <= a < 10
//c = 1 <= a < 10;
c = a >= 1 && a < 10; //判断变量a的值是否在[1,10)
}
}
5.位运算符
/**
*
* 位运算符: 针对变量的二进制位来进行运算
* 移位运算：
* a.左移运算符： 3 << 2 = 3 * 2 * 2 = 12
* 左移一位相当于给操作数 * 2(左移之后的结果仍然在，相应数据类型的表示范围之内)
* 00000000,00000000,00000000,00000011
* 移动一位
* 0000000,00000000,00000000,000000110
* 在移动一位
* 000000,00000000,00000000,0000001100 -> 12
*
* b.带符号的移位： -2 >> 1 , 相当于给操作数除以2(只针对，未溢出切，可以被除尽)
* 10000000,00000000,00000000,00000010 -> 补码 11111111,11111111,11111111,11111101
* + 1
* 11111111,11111111,11111111,11111110
* 对于带符号位的右移运算而言：右移运算，高位补符号位
* 111111111,11111111,11111111,1111111 -> 10000000,00000000,00000000,00000000
* +1
*
* 10000000,00000000,00000000,00000001 -1
* 不能除尽的情况
* 000000000,00000000,00000000,00000011 -> 0000000000,00000000,00000000,0000001
*
*
* c. 无符号右移：移位的动作和带符号数一模一样的，右移之后，高位直接填充0,
* 无符号右移，同常用来处理正整数，对正整数而言，无符号右移一位相当于除以2
*
* &： 只针对二进制的一位 0或者1，只有两个二进制都为1的时候结果为1，其余全为0
* 0 & 1 = 0 0 & 0 = 0 1 & 0 = 0 1 & 1 = 1
*
* |: 只有两位全为0的时候结果才为0
* 0 | 1 = 1 0 | 0 = 0 1 | 0 = 1 1 | 1 = 1
*
* ^: 相同为0，不同为1
* 0 ^ 1 = 1 0 ^ 0 = 0 1 ^ 0 = 1 1 ^ 1 = 0
* 性质：
* 1. 一个数和它自己异或运算的结果：a ^ a = 0
* 2. 0和任何数做异或运算：0 ^ a = a
*
* ~: 按位取反(包括符号位)
* ~6 = -7
* 00000000,00000000,00000000,00000110
* 11111111 11111111 11111111 11111001 -> 10000000,00000000,00000000,00000110
* +1
* 10000000,00000000,00000000,00000111
*
*/
public class Demo {
public static void main(String[] args) {
//举例数据溢出 正整数 + 1 -> 负数
// 0111 1111,1111 1111,1111 1111,1111 1111
// +1
// 1000 0000 0000 0000 0000 0000 0000 0000
int a = 0x7fffffff; //int类型所能表示的最大正整数
System.out.println(a + 1);
//1000 0000,0000 0000,0000 0000,0000 0000
a = 0x80000000;
System.out.println(a);
//验证左移 <<
a = 3;
int b = 2;
a = a << 2; //如果要将让操作数变成移位之后的结果，必须要赋值才行
System.out.println(a << 2);
//验证带符号右移 >>
a = -1; //1,xxxxxxxxx, 111111111,111111111,11111111,1111111
System.out.println(a >> 2);
//无符号右移 >>>
a = -2;
// 11111111,11111111,11111111,11111110 -> 无符号右移1位 011111111,11111111,11111111,1111111
//System.out.println(a >>> 1); //2147483647
//验证一下异或运算的性质
a = 90; //异或运算满足交换律
System.out.println(a ^ a); //性质1
System.out.println(a ^ 0); //性质2
System.out.println(~6);
}
}
面试题：
1.请用最有效率的方式写出计算2乘以8的结果
2.请自己实现两个整数变量的交换
/**
*
*
* 1. 请用最有效率的方式写出计算2乘以8的结果 2. 请自己实现两个整数变量的交换
*/
public class Exercise {
public static void main(String[] args) {
//1.请用最有效率的方式写出计算2乘以8的结果 最有效率的方式？ 2 * 8 位运算最为高效的操作
// 2 * 8 = 2 * 2^3
System.out.println(2 << 3);
//2.请自己实现两个整数变量的交换(才是开发中常用的)
int a = 10;
int b = 200;
//两个变量的交换
int tmp = a;
a = b;
b = tmp;
System.out.println("a = " + a + "----- b = " + b);
//变量交换的实现方式2： //ctrl + alt + l
a = 10;
b = 200;
a = a + b;
b = a - b; // a + b - b = a
a = a - b; // a + b - a = b
System.out.println("a = " + a + "----- b = " + b);
//实现方式3：
a = 10;
b = 200;
a = a ^ b;
b = a ^ b;// a ^（b ^ b) = a
a = a ^ b;// a ^ b ^ a -> a ^ a ^ b
System.out.println("a = " + a + "----- b = " + b);
//实现方式4
a = 10;
b = 200;
// (a + b) - a = b
a = (a+b) - (b=a); //(b = a) 表达式的值是赋值之后的b的值
System.out.println("a = " + a + "----- b = " + b);
}
}
6.三目运算符
格式： 关系表达式 ？表达式1 : 表达式2
如果关系表达式结果为为true，运算后的结果是表达式1；
如果关系表达式结果为false，运算后的结果是表达式2；
实例： 用关系表达式判断两数是否相同
练习：三数取大 (目前如果没说数据类型，默认就是int类型的数据)
/**
* 关系表达式 ？表达式1 : 表达式2
* 如果关系表达式的结果为true，3目运算的结果，就是表达式1的值
* 如果关系表达式的结果为false，3目运算的结果，就是表达式2的值
*
*/
public class Demo {
public static void main(String[] args) {
int a;
int b;
//使用键盘输入
Scanner sc = new Scanner(System.in);
a = sc.nextInt();
b = sc.nextInt();
//用关系表达式判断两数是否相同
String s = a == b ? "两数相等" : "两数不相等";
System.out.println(s);
// 3数取大
int c = 100;
//两数取大，第三个数和两数中的大者比较，取它们的大者就是最大值
int tmp = a > b ? a : b;
int result = tmp > c ? tmp : c;
System.out.println("最大的是： " + result);
//三目运算的，3数取大的嵌套形式
//int tmp = a > b ? a : b;
//int result = tmp > c ? tmp : c;
result = (a > b ? a : b) > c ? (a > b ? a : b) : c;
System.out.println("最大的是： " + result);
}
}
7.键盘录入数据
键盘录入数据
我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，所以，我准备把数据改进为键盘录入，提高程序的灵活性。
如何实现键盘录入数据呢?(目前先记住使用)
导包语句(放到class定义的上面)：
import java.util.Scanner;
创建对象
Scanner sc = new Scanner(System.in);
从键盘输入读取数据
int x = sc.nextInt();
import java.util.Scanner;
/**
* @author zhangshuai@Cskaoyan.onaliyun.com on 2020/2/4.
* @version 1.0
*
* 如何实现键盘录入数据呢
*/
public class Demo {
public static void main(String[] args) {
//键盘录入数据 必须通过Scanner对象来使用其功能
Scanner sc = new Scanner(System.in); //alt + enter
//Scanner strSc = new Scanner(System.in); //读取一行字符串
//通过对象使用scanner的功能接收键盘输入
//读取字符串
//String s = sc.nextLine(); // "hello" String
//System.out.println(s);
int i = sc.nextInt();
boolean b = sc.nextBoolean(); //它们都默认以空格分隔不同的输入
String s = sc.nextLine(); //以回车作为数据的分隔符
System.out.println(i);
System.out.println(b);
System.out.println("s = " + s);
//用完之后记得关闭
sc.close();
// 推荐做法，如果即要读取普通数据，也要读取nextLine(读取一行字符串)，用两个Scanner对象
}
}
练习:
1.键盘录入两个数据，并对这两个数据求和，输出其结果
2.键盘录入两个数据，获取这两个数据中的最大值
3.键盘录入三个数据，获取这三个数据中的最大值
4.键盘录入两个数据，比较这两个数据是否相等