第3章 操作符
3.1 更简单的打印语句
本节介绍了静态导入，通过封装程序，简化打印语句。
传统打印：
public static void main(String[] args) {
System.out.println("hello java");
}
工具类：
package com.ding.three.util;
public class Print {
public static void outPut(Object o){
System.out.println(o);
}
}
封装后：
package com.ding.three;
import static com.ding.three.util.Print.*;
public class Test {
public static void main(String[] args) {
outPut("hello java");
}
}
3.2 使用Java操作符
操作符： 接收一个或多个参数，并生成一个新值。
副作用： 有些操作符会改变操作数自身的值。
操作符大部分是操作“基本类型”，但是“=” “==” ”！=“ 可以操作对象，String类可以使用”+“和”+=“。
3.3 优先级
当一个表达式中存在多个操作符时，操作符的优先级决定了各部分的计算顺序。
public class Test {
public static void main(String[] args) {
// String后的+跟随非String时，编译器会将非String转换为String
outPut("a = "+ 1);
}
}
3.4 赋值
别名现象
public static void main(String[] args) {
User user1 = new User();
User user2 = new User();
user1.age = 10;
user2.age = 20;
outPut("1: " + user1.age + "-" + user2.age); // 1: 10-20
user1 = user2;
user1.age = 30;
outPut("2: "+user1.age + "-" +user2.age); // 2: 30-30
}
方法调用中的别名
public static void f(User user){
user.age = 1;
}
public static void main(String[] args) {
User user = new User();
user.age = 10;
outPut("1-" + user.age); // 1-10
f(user); // 方法中的参数传递
outPut("2-" + user.age); // 2-1
}
总结： 基本数据类型赋值是赋的本身，对象赋的是内存地址。对其的理解为变量是一块内存空间，右边的内存空间是什么，左边的变量的内存空间就会是什么，因为基本数据类型右边装的就是其本身，所以左边也会是其本身，而变量是内存地址，所以右边也会是内存地址。User user = new User();可以认为是做了两件事，在堆中开辟一块内存空间，创建User的实例，并将该内存空间的地址赋值给user变量。
3.5 算术操作符
public static void main(String[] args) {
// 指定一个种子，产生的数会固定；一般不指定，会以当前时间作为种子，达到伪随机
Random random = new Random(47);
// 获取0-100一个随机整数
int a = random.nextInt(100) + 1; // +1防止出现0
int b = random.nextInt(100) + 1;
outPut(a); // 59
outPut(b); // 56 random获取一个数列，nextInt()不断获取下一个
outPut(a + b); // 115
outPut(a - b); // 3
outPut(a * b); // 3304
outPut(a / b); // 1 去掉小数，不是四舍五入
outPut(a % b); // 3
a %= b;
outPut(a); // 3
outPut(-a); // -3 一元操作符（可以将小类型提升到int）
outPut(+a); // 3 一元加号
}
3.6 自动递增和递减
public static void main(String[] args) {
int i = 1;
outPut(++i); // 2 先执行运算
outPut(i++); // 2 后执行运算
outPut(i); // 3
outPut(--i); // 2
outPut(i--); // 2
outPut(i); // 1
}
3.7 关系操作符
public static void main(String[] args) {
// > < >= <= == !=
Integer n1 = new Integer(10);
Integer n2 = new Integer(10);
// 比较对象的引用
outPut(n1 == n2); // false
// 比较对象的值
outPut(n1.equals(n2)); //true
}
3.8 逻辑操作符
public static boolean test1(int n) {
outPut("test1");
return n == 1;
}
public static boolean test2(int n) {
outPut("test2");
return n == 2;
}
public static void main(String[] args) {
// 短路与&& 短路或|| 非！
outPut(true && true); // true
outPut(true && false); // false
outPut(false && false); // false
outPut(true || true); // true
outPut(true || false); // true
outPut(false || false); // false
outPut(!true); // false
outPut(!false); // true
// 短路现象:当前边的条件可以判断整个逻辑表达式时，后边的就不会执行
boolean b1= test1(2) && test2(2); // test1
boolean b2 = test1(1) || test2(2); // test1
}
3.9 直接常量
public static void main(String[] args) {
int i = 0;
double d = 0;
// float类型
d = 7f;
d = 7F;
// double类型
d = 7l;
d = 7L;
// 八进制
i = 07;
// 十六进制
i = 0x7;
// 转为二进制
outPut(Integer.toBinaryString(i)); // 111
// 幂/返回double类型
outPut(1.24e2); // 124.0
outPut(1.24E-2); // 0.0124
}
3.10 按位操作符
public static void main(String[] args) {
// 按位操作符：按二进制计算
outPut(Integer.toBinaryString(3)); // 11
outPut(Integer.toBinaryString(7)); // 111
// 按位与
outPut(3 & 7); // 3
// 按位或
outPut(3 |7); // 7
// 按位异或
outPut(3 ^7); // 4
outPut(Integer.toBinaryString(5)); // 101
// 按位非
outPut(~5); // -6
// 布尔类型可以执行& | ^ 但不会短路
outPut(true & true); // true
outPut(true & false); // false
}
3.11 移位操作符
原码： 最高位是符号位，非符号位是该数字绝对值的二进制表示。
反码： 正数的反码与原码一致；负数的反码是除最高位外对原码按位取反。
补码： 正数的补码与原码一致；负数的补码是该数的反码加1。
获得负数二进制的两种方法：
- 符号位+数字绝对值->除符号位取反->最后位+1->负数的二进制；
- 对应正整数->取反（所有）->最后位+1->负数的二进制。
计算机数字运算均是基于补码的。
int 数据类型是32位、有符号的以二进制补码表示的整数，最小值是 -2,147,483,648（-2^31）；最大值是 2,147,483,647（2^31 - 1）。
public static void main(String[] args) {
// << 左移位：二进制向左移动，末尾补0
outPut(Integer.toBinaryString(2)); // 10
outPut(Integer.toBinaryString(2<<1)); // 100
// >> 右移位：二进制向右移动，从后向前，消去对应的数量
outPut(Integer.toBinaryString(4)); // 100
outPut(Integer.toBinaryString(4>>1)); // 10
// 负数会在开头补1
outPut(Integer.toBinaryString(-4)); // 11111111111111111111111111111100
outPut(Integer.toBinaryString(-4>>2)); // 11111111111111111111111111111111
outPut(Integer.toBinaryString(-4<<2));
// >>> 无符号右移，无论正负，在开头补0
outPut(Integer.toBinaryString(-4>>>2)); // 111111111111111111111111111111
outPut(-4>>>2); // 1073741823
// 应用
outPut(3<<2); // 3*2^2快速计算 12
outPut(20>>2); // 20/2^2快速计算 5
}
3.12 三元操作符
public static void main(String[] args) {
outPut(true ? 1 : 2); // 1
outPut(false ? 1 : 2); // 2
}
3.13 字符串操作符+和+=
public static void main(String[] args) {
String s = "a";
s += "b"; // 字符串+=运用
outPut(s);
outPut("" + 1); // 转为字符串
}
3.15 类型转换
窄化转换：将类型转化 为容纳更少信息的类型。
扩展转换： 将类型转化 为容纳更多信息的类型。
基本数据类型（除布尔外）可以相互转换。
类族之间可以进行相互转换。
public static void main(String[] args) {
// 窄化是截尾操作
outPut((int)0.7); // 0
// 四舍五入使用round()方法
outPut(Math.round(0.7)); // 1
outPut(Math.round(0.4)); // 0
}
char、byte、shot在运算时先转为int再运算，如果想赋值给他们，需要进行类型转换；
运算中最大数据类型决定了结果的数据类型。
