运算符基础

算术运算符：

1).+ (加)
2).- (减)
3).* (乘)
4)./ (除)

public static void main(String[] args) {
//1.+,-,*,/
int a = 10;
int b = 20;
int c = 30;
int d = 40;
int e = a + b - c * d / 2;
System.out.println(e);//-570
//可以使用"小括号"改变运算顺序
int f = a + (b - c) * (d / 2);
System.out.println(f);//-190
//注意：整数除法，结果肯定是整数，不论是否整除，结果直接取"商"
int a1 = 10;
int a2 = 3;
System.out.println(a1 / a2);
System.out.println(10 / 0);//运行时异常
System.out.println(10 / 0.0);//打印：Infinity(无穷)
}

5).% (取余)

//取余：%，取做除法的余数
int a3 = 10;
int a4 = 3;
System.out.println(a3 % a4);//10 % 3 = 1

6).++ (自增1)
7).-- (自减1)

//自增1：++ : 将变量的值自增1
int a5 = 10;
++a5;
System.out.println(a5);
//4.自减1：-- : 将变量的值自减1
--a5;
System.out.println(a5);
//注意：变量++/--和 ++/--变量，的内部的运算顺序不一样
//如果表达式做多件事情，会影响最终的结果
int n1 = 10;
// int n2 = n1++;//先将n1的值赋给n2,然后n1再自增1
int n2 = ++n1;//先将n1自增1，然后再将n1的值赋给n2
System.out.println(n2); 

注意事项：
①.运算中的数据类型提升：在一个运算表达式中，运算过程中会将“窄”类型自动提升为“表达式中的最宽类型”。

byte a = 10;
int b = 20;
long c = 30;
long d = a + b + c;//a和b全部自动提升为long类型
int n1 = a + b;//a 会自动提升为int -------------------------------------------------------- Java内部对于“短整型”：byte，short，char，运算时会自动提升为int类型。
byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;//编译错误，编译时不看b1和b2的值是多少，只看数据类型
byte b3 = b1 + 20;//编译错误
byte b3 = 10 + b2;//编译错误
byte b3 = 10 + 20;//OK的。编译时确定结果就是30，所以可以。
int b3 = b1 + b2;//OK的。b1和b2全部自动提升为int
同理：
byte b1 = 10;
short b2 = 20;
int b3 = b1 + b3;

②.浮点运算：可能有丢失精度的情况：以后我们做浮点运算不用基本类型，用类。

doubl e d1 = 1. 9;
doubl e d2 = 2. 8;
System. out. pri ntl n(d1 + d2) ; //计算结果是: 4. 699999999999999

③.+符号在字符串中的应用：字符串连接

String s1 = "Hello";
String s2 = "World";
System.out.println(s1 + s2);//HelloWorld
例子：
System.out.println(5 + 5 + "5 , 5" + 5 + 5);
// 10 + "5 , 5" + 5 + 5
// "105 , 5" + 5 + 5
// "105 , 55" + 5
// "105 , 555"

赋值运算符：
1).= :

int a = 10;

2).+= : 将变量自增指定的值；

int a = 10;
a += 20;//相当于：a = (int)(a + 20);//结果：a = 30

3).-= : 将变量自减指定的值；

int a = 10;
a -= 20; //相当于：a = (int)(a - 20);//结果：a = -10

4).*= :

int a = 10;
a *= 20 ; //相当于：a = (int)(a * 20);//结果：a = 200

5)./= :

int a = 10;
a /= 2; //相当于： a = (int)(a / 2);//结果：a = 5;

6).%= :

int a = 10;
a %= 3 ; //相当于：a = (int)(a % 3);//结果：a = 1

比较运算符：

1).== : 判断两个数是否“相等”

public static void main(String[] args) {
//2.创建对象
Scanner sc = new Scanner(System.in);
//3.接收数据
System.out.println("请输入第一个数：");
int n1 = sc.nextInt();
System.out.println("请输入第二个数：");
int n2 = sc.nextInt();
boolean b = n1 == n2;
System.out.println("这两个数是否相等：" + b);
}

2).!= : 判断两个数是否“不相等”

public static void main(String[] args) {
//2.创建对象
Scanner sc = new Scanner(System.in);
//3.接收数据
System.out.println("请输入第一个数：");
int n1 = sc.nextInt();
System.out.println("请输入第二个数：");
int n2 = sc.nextInt();
boolean b = n1 != n2;
System.out.println("这两个数是否不相等：" + b);
}

3).> : 判断左数是否大于右数

int a = 10;
int b = 5;
int c = 5;
System.out.println(a > b);//true
System.out.println(b > a);//false
System.out.println(b > c);//false

4).< : 判断左数是否小于右数

System.out.println(a < b);//false
System.out.println(b < a);//true
System.out.println(b < c);//false

5).>= : 判断左数是否"大于或者等于"右数

System.out.println(a >= b);//true
System.out.println(b >= c);//true

6).<= : 判断左数是否"小于或者等于"右数

System.out.println(b <= c);//true

逻辑运算符：

1).逻辑运算符：是对“多个判断的结果”再进行逻辑“与(并且)”，“或(或者)”，“非(不是)”的判断，最终仍然会产生一个boolean类型的结果。
2).例如：需求：判断一个年龄，是否在23到25岁之间
int age = 24;
boolean b = (age >= 23 && age <= 25);
System.out.println(b);
3).逻辑运算符：
1).&& : 逻辑“与”，语义“并且”。左右两边都为true，结果才为true。
左右两边有一个false，结果为false。
例如：
int age = 24;
boolean b = (age >= 23 && age <= 25);
System.out.println(b);
2).|| ：逻辑“或”，语义“或者”。左右两边有一个为true，结果为true。
左右两个都为false，结果为：false
例如：
Scanner sc = new Scanner(System.in);
System.out.println(“你要为我介绍男朋友吗：”);
System.out.println(“请输入他的身高：”);
double h = sc.nextDouble();//1.70
System.out.println(“请输入他的月薪：”);
int s = sc.nextInt();//40000
boolean b = (h >= 1.8 || s >= 35000);
System.out.println(“结果：” + b);//true
3).! : 逻辑“非”，语义“不是…”。对boolean值进行取反：!true = false
!false = true
例如：
int a = 10;
//判断a是否不大于10
boolean b = !(a > 10);//相当于：boolean b = (a <= 10);
4).逻辑运算符&&，||的“短路行为”：
1).“短路行为”是指：进行逻辑&&或||运算时，如果左边的表达式能够确定整个表达式
的结果，这时将不会再执行右边的表达式。
public static void main(String[] args) {
int a = 10;
int b = 20;
boolean e = a > 50 && ++b < 50;//(短路：++b < 50 没有被执行)
System.out.println(e);//false
System.out.println(b);//20
int x = 10;
int y = 20;
boolean e2 = x > 5 || ++y > 50;//(短路：++y > 50 没有被执行)
System.out.println(e2);//true
System.out.println(y);//20
}

三元运算符：

格式： 逻辑表达式 ? 表达式1 ：表达式2;
格式说明：
1).逻辑表达式：必须包含“比较运算符”或者“逻辑运算符”的表达式，其结果必须是一个boolean结果。
2).表达式1：如果“逻辑表达式”为true，则返回：表达式1
否则：返回表达式2.
举例：用户输入两个数，找出最小数：

public static void main(String[] args) {
//需求：请用户输入两个数，我们程序找出最大的数，并打印
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数：");
int n1 = sc.nextInt();
System.out.println("请输入第二个数：");
int n2 = sc.nextInt();
int n3 = n1 < n2 ? n1 : n2;
System.out.println("最小的数：" + n3);
}