算术运算符
/*
关于java编程中运算符之：算术运算符
+ 求和
- 相减
* 乘积
/ 商
% 求余数【取模】
++ 自加1
-- 自减1
注意： 一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。
没有必要去专门记忆运算符的优先级。
*/
public class OperatorTest01
{
public static void main(String[] args){
int i = 10;
int j = 3;
System.out.println( i + j ); // 13
System.out.println( i - j ); // 7
System.out.println( i * j ); // 30
System.out.println( i / j ); // 3
System.out.println( i % j ); // 1
// 以下以++为例，--运算符一样~
// 关于++运算符【自加1】
int k = 10;
// ++运算可以出现变量的后面【单目运算符】
k ++;
System.out.println(k); // 1
int y = 10;
// ++运算可以出现变量的q前面【单目运算符】
++ y;
System.out.println(k); // 1
// 小结：
// ++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后
// 只要++运算结束，该变量中的值一定会自加1
// ++ 出现在变量后
// 规则：先做赋值运算，再对变量中保存的值进行自加1
int a = 100;
int b = a ++;
System.out.println(a); // 101
System.out.println(b); // 100
// ++ 出现在变量前
// 规则：先进行自加1运算，然后再进行赋值操作。
int m = 20;
int n = ++ m;
System.out.println(m); // 21
System.out.println(n); // 21
int xx = 500;
System.out.println(xx);
int e = 100;
System.out.println(e ++); // 100
System.out.println(e); // 101
int s = 100;
System.out.println(++s); // 101
System.out.println(s); // 101
System.out.println(--s); // 100
System.out.println(s++); // 100
System.out.println(s--); // 101
System.out.println(s--); // 100
System.out.println(s--); // 99
System.out.println(s); // 98
}
}关系运算符
/*
关系运算符：
> 大于
>= 大于等于
< 小于
<= 小于等于
== 等于
!= 不等于
= 是赋值运算符
== 是关系运算符
关系运算符的运算结果一定是布尔类型；true/false
关系运算符的运算原理：
int a = 10;
int b = 10;
a > b 比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较。
a == b 也是如此。
*/
public class OperatorTest02
{
public static void main(String[] args){
int a = 10;
int b =10;
System.out.println(a > b); // false
System.out.println(a >= b); // true
System.out.println(a < b); // false
System.out.println(a <= b); // true
System.out.println(a == b); // true
System.out.println(a != b); // false
}
}逻辑运算符
/*
关于逻辑运算符：
& 逻辑与【并且】 （两边的算子都是true，结果才是true）
| 逻辑或【或者】 （两边的算子只要有一个是true，结果就是true）
！ 逻辑非 （取反，!false就是true，!true就是false,就是一个单目运算符）
^ 逻辑异或 （两边的算子只要不一样，结果就是true）
&& 短路与
|| 短路或
1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。
2、短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象。
3、短路或和逻辑或最终的运算结果是相同的，只不过短路与存在短路现象。
4、什么情况下发生短路现象呢？
5、什么时候选择使用逻辑与运算符？什么时候选择使用短路与运算符？
*/
public class OperatorTest03
{
public static void main(String[] args){
// 运算符优先级不确定，加小括号
System.out.println(5 > 3 & 5 > 2 ); // true
System.out.println(5 > 3 & 5 > 6 ); // false
System.out.println(5 > 3 | 5 > 6 ); // 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 | false ); // true
System.out.println(false & false ); // false
System.out.println(!false); // true
System.out.println(!true); // false
System.out.println(true ^ false ); // true
System.out.println(false ^ false ); // false
System.out.println(true ^ true ); // false
// 逻辑与和短路与
int x = 10;
int y = 8;
// 逻辑与
System.out.println( x < y & ++x < y );
System.out.println(x); // 11
// 逻辑与和短路与
int x = 10;
int y = 8;
// 短路与
// x < y 结果是false，整个表达式结果已经确实是false
// 所有后面的表达式没有再执行，这种现象被称为短路现象。
// 短路与才会有短路现象，逻辑与是不会存在短路现象的，
System.out.println( x < y & ++x < y );
System.out.println(x); // 10
/*
1、从某个角度来看，短路与更智能，由于后面的表达式可能不执行，所以执行效率较高，这种方式在实际的开发中使用较多，短路与比逻辑与使用的多，短路与更常用。
2、但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与，不能使用短路与，使用短路与可能导致右边的表达式不执行
什么情况下发生短路或？
- 第一个表达式执行结果是true，会发生短路或
什么情况下发生短路与？
- 第一个表达式执行结果是false，会发生短路与
*/
}
}赋值类运算符
/*
关于java中的赋值类运算符：
赋值类运算符包括两种：
- 基本的赋值运算符
=
- 扩展的赋值运算符
+=
-=
*=
/=
%=
1、赋值类的运算符优先级，先执行等号右边的表达式，将执行结果赋值给左边的变量。
2、注意以下代码：
byte i = 10;
i += 5; 等同于：i = (byte)(i + 5);
int k = 10;
k += 5; 等同于：k = (int)(k + 5);
long x = 10L;
int y = 20;
y += x; 等同于：y = (int)(y + x);
3、重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎么进行追加或追减，最终改变量的数据类型还是byte类型。
*/
public class OperatorTest04
{
public static void main(String[] args){
// 基本的赋值运算符
int i = 10;
System.out println(i); // 10
i = i + 5;
System.out.println(i); // 15
// 扩展的赋值运算符【+= 运算符可以翻译为“追加/累加”】
i += 5; // 等同于：i = i + 5;
System.out.println(i); // 20
i -= 5; // 等同于：i = i - 5;
System.out.println(i); // 15
i *= 2; // 等同于：i = i * 2;
System.out.println(i); // 30
i /= 4; // 等同于：i = i / 4;
System.out.println(i); // 7
i %= 2; // 等同于：i = i % 2;
System.out.println(i); // 1
//--------------------------------------------------------
// 10没有超出byte取值范围，可以直接赋值
byte b = 10;
// b = 15; // 可以编译通过，15没有超出byte取值范围
// 编译错误，为什么？
// 编译器只检查语法，不运行程序，编译器发现b+5的类型是int类型，b变量的数据类型是byte
// 大容量向小容量转换需要加强制类型转换符，所以以下程序编译错误
// b = b + 5;
// 纠正错误
b = (byte)(b + 5);
System.out.println(b); // 15
byte x = 10;
x += 5; // 等同于 x = (byte)(x + 5),其实并不等同于：x = x + 5
System.out.println(x); // 15
byte z = 0;
z += 128; // 等同于 z = (byte)(z + 128);
System.out.println(z); // -128 【损失精度】
z += 10000; // 等同于 z = (byte)(z + 10000);
System.out.println(z); // -112 【损失精度】
}
}字符串连接运算符
/*
关于java中的“+”运算符：
1、+运算符在java语言当中有两个作用：
- 加法运算，求和
- 字符串的连接运算
2、当“+”运算符两边的数据都是数字的话，一定是进行加法运算。
3、当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算，并且，连接运算之后的结果还是一个字符串类型。
数字 + 数字 ---> 数字【求和】
数字 + "字符串" ---> "字符串"【字符串连接】
4、在一个表达式当中可以出现多个“+”，在没有添加小括号的前提之下，遵循自左向右的顺序依次运算。
*/
public class OperatorTest05
{
public static void main(String[] args){
System.out.println(10 + 20); // 30 这里的加号是求和
System.out.println(10 + 20 + 30); // 60 这里的加号也是求和
System.out.println(10 + 20 + "30"); // "3030" 自左向右的顺序依次运算，第一个加号是求和，第二个加号是字符串
System.out.println(10 + (20 + "30")); // "102030"
int a = 10;
int b = 10;
// 要求在控制台上输出 "10 + 20 = 30"
System.out.println("10 + 20 = 30");
// 注意：要求以动态的方式输出
System.out.println("10 + 20 = " + a + b); // "10 + 20 = 1020"
System.out.println("10 + 20 = " + (a + b));
System.out.println("a + 20 = " + (a + b));
System.out.println(a + " + 20 = " + (a + b));
System.out.println(a + " + " + b + " = " + (a + b));
// 引用类型String
// String是SUN在JavaSE当中提供的字符串类型
// String.class字节码文件
// int是基本数据类型，i是变量名，10是int类型的字面值
int i = 10;
// String是应用数据类型，s是变量名，"abc"是String类型的字面值
// String s = "abc";
// 定义一个String类型的变量，起名username，赋值 "张三"
String username = "张三";
System.out.println("登陆成功，欢迎" + username + "回来"); // 登陆成功，欢迎张三回来
username = "jack";
System.out.println("登陆成功，欢迎" + username + "回来"); // 登陆成功，欢迎jack回来
}
}三元运算符
/*
三元运算符/三目运算符/条件运算符
1、语法规则：
布尔表达式 ? 表达式1 : 表示式2
2、三元运算符的执行原理？
当布尔表示的结果是true的时候，选择表达式1作为整个表达式的执行结果
当布尔表示的结果是false的时候，选择表达式2作为整个表达式的执行结果
*/
public class OperatorTest06
{
public static void main(String[] args){
// 编译错误：不是一个完整的java语句
// 10;
// 编译错误：不是一个完整的java语句
// '男';
// 布尔类型的变量
boolean sex = false;
// 分析以下程序是否可以编译通过？
// 编译报错，因为它不是一个完整的java语句
// sex ? '男' : '女';
char c = sex ? '男' : '女';
System.out.println(c);
sex = true;
c = (sex? '男' : '女');
System.out.println(c);
// 语法错误，编译报错，结果可能是String，也可能是char，但是前边不能用char来接受数据。
// char c1 = sex? "男" : '女';
// 编译错误，类型不兼容
/*
sex = false;
char c1 = sex? "男" : '女';
*/
System.out.println(10);
System.out.println("10");
System.out.println('1');
// 可以
System.out.println(sex ? '男' : "女");
String s = sex ?("男的" : "女的");
System.out.println(s);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
