3.Java程序基础

Java提供了两种变量类型：`基本类型`和`引用类型`

基本类型包括整型，浮点型，布尔型，字符型。

变量可重新赋值，等号是赋值语句，不是数学意义的等号。

常量在初始化后不可重新赋值，使用常量便于理解程序意图。

1、变量

变量是一种使用方便的占位符，用于引用计算机内存地址，该地址可以存储Script运行时可更改的程序信息。

• 变量必须先定义后使用，在定义变量的时候，可以给它一个初始值。不写初始值，就相当于给它指定了默认值。默认值总是0。
• 变量的一个重要特点是可以重新赋值
  变量不但可以重新赋值，还可以赋值给其他变量。

2、基本数据类型

整数类型：byte（-128 ~ 127），short（-32768 ~ 32767），int（-2147483648 ~ 2147483647），long（-9223372036854775808 ~ 9223372036854775807）
浮点数类型：float，double
字符类型：char
布尔类型：boolean

• 对于float类型，需要加上f后缀。
  浮点数可表示的范围非常大，float类型可最大表示3.4x1038，而double类型可最大表示1.79x10308。
• 字符类型char表示一个字符。Java的char类型除了可表示标准的ASCII外，还可以表示一个Unicode字符：
  注意char类型使用单引号'，且仅有一个字符，要和双引号"的字符串类型区分开。

引用类型

除了上述基本类型的变量，剩下的都是`引用类型`。例如，引用类型最常用的就是String字符串：
		String s = "hello";
引用类型的变量类似于C语言的指针，它内部存储一个“地址”，指向某个对象在内存的位置，后续我们介绍类的概念时会详细讨论。

3、常量

定义变量的时候，如果加上final修饰符，这个变量就变成了常量：

final double PI = 3.14; // PI是一个常量(最终变量)
double r = 5.0;
double area = PI * r * r;
PI = 300; // compile error!

• 常量在定义时进行初始化后就不可再次赋值，再次赋值会导致编译错误。
• 根据习惯，常量名通常全部大写

4、var关键字

有些时候，类型的名字太长，写起来比较麻烦。这个时候，如果想省略变量类型，可以使用var关键字：
编译器会根据赋值语句自动推断出变量sb的类型是StringBuilder。对编译器来说，语句：

var sb = new StringBuilder();

实际上会自动变成：

StringBuilder sb = new StringBuilder();

因此，使用var定义变量，仅仅是少写了变量类型而已。

5、变量的作用范围

在语句块中定义的变量，它有一个作用域，就是从定义处开始，到语句块结束。超出了作用域引用这些变量，编译器会报错。

• 定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域，并且，不要重复使用变量名。

6、整数运算

Java的整数运算遵循四则运算规则，可以使用任意嵌套的小括号。四则运算规则和初等数学一致。

溢出

整数由于存在范围限制，如果计算结果超出了范围，就会产生溢出，而溢出不会出错，却会得到一个奇怪的结果：

public class Main {
    public static void main(String[] args) {
        int x = 2147483640;
        int y = 8;
        int sum = x + y;
        System.out.println(sum); // -2147483648 
    }
}

解决以上问题：可以把int换成long类型，由于long可表示的整型范围更大，所以结果就不会溢出

自增/自减

Java还提供了++运算和--运算，它们可以对一个整数进行加1和减1的操作。
注意：++写在前面和后面计算结果是不同的，++n表示先加1再引用n，n++表示先引用n再加1。不建议把++运算混入到常规运算中，容易自己把自己搞懵了。

移位运算

可以对整数进行移位运算。对整数7左移1位将得到整数14，左移两位将得到整数28：

int n = 7;       // 00000000 00000000 00000000 00000111 = 7
int a = n << 1;  // 00000000 00000000 00000000 00001110 = 14
int b = n << 2;  // 00000000 00000000 00000000 00011100 = 28
int c = n << 28; // 01110000 00000000 00000000 00000000 = 1879048192
int d = n << 29; // 11100000 00000000 00000000 00000000 = -536870912

左移29位时，由于最高位变成1，因此结果变成了负数。
类似的，对整数28进行右移，结果如下：

int n = 7;       // 00000000 00000000 00000000 00000111 = 7
int a = n >> 1;  // 00000000 00000000 00000000 00000011 = 3
int b = n >> 2;  // 00000000 00000000 00000000 00000001 = 1
int c = n >> 3;  // 00000000 00000000 00000000 00000000 = 0

如果对一个负数进行右移，最高位的1不动，结果仍然是一个负数：

int n = -536870912;
int a = n >> 1;  // 11110000 00000000 00000000 00000000 = -268435456
int b = n >> 2;  // 11111000 00000000 00000000 00000000 = -134217728
int c = n >> 28; // 11111111 11111111 11111111 11111110 = -2
int d = n >> 29; // 11111111 11111111 11111111 11111111 = -1

• 还有一种无符号的右移运算，使用>>>，它的特点是不管符号位，右移后高位总是补0，因此，对一个负数进行>>>右移，它会变成正数，原因是最高位的1变成了0：

int n = -536870912;
int a = n >>> 1;  // 01110000 00000000 00000000 00000000 = 1879048192
int b = n >>> 2;  // 00111000 00000000 00000000 00000000 = 939524096
int c = n >>> 29; // 00000000 00000000 00000000 00000111 = 7
int d = n >>> 31; // 00000000 00000000 00000000 00000001 = 1

对byte和short类型进行移位时，会首先转换为int再进行位移。
仔细观察可发现，左移实际上就是不断地×2，右移实际上就是不断地÷2。

位运算

位运算是按位进行与&、或|、非~和异或^的运算。
与运算的规则是，必须两个数同时为1，结果才为1：

n = 0 & 0; // 0
n = 0 & 1; // 0
n = 1 & 0; // 0
n = 1 & 1; // 1

或运算的规则是，只要任意一个为1，结果就为1：

n = 0 | 0; // 0
n = 0 | 1; // 1
n = 1 | 0; // 1
n = 1 | 1; // 1

非运算的规则是，0和1互换：

n = ~0; // 1
n = ~1; // 0

异或运算的规则是，如果两个数不同，结果为1，否则为0：

n = 0 ^ 0; // 0
n = 0 ^ 1; // 1
n = 1 ^ 0; // 1
n = 1 ^ 1; // 0

• 对两个整数进行位运算，实际上就是按位对齐，然后依次对每一位进行运算。

运算优先级

在Java的计算表达式中，运算优先级从高到低依次是：
()
! ~ ++ --
* / %
+ -
<< >> >>>
&
|
+= -= *= /=

类型自动提升与强制转型
在运算过程中，如果参与运算的两个数类型不一致，那么计算结果为较大类型的整型。
例如，short和int计算，结果总是int，原因是short首先自动被转型为int。
也可以将结果强制转型，即将大范围的整数转型为小范围的整数。强制转型使用(类型)，例如，将int强制转型为short：

int i = 12345;
short s = (short) i;

• 要注意，超出范围的强制转型会得到错误的结果，原因是转型时，int的两个高位字节直接被扔掉，仅保留了低位的两个字节：

7、浮点运算

• 浮点数运算和整数运算相比，只能进行加减乘除这些数值计算，不能做位运算和移位运算。
• 如果参与运算的两个数其中一个是整型，那么整型可以自动提升到浮点型。
• 在一个复杂的四则运算中，两个整数的运算不会出现自动提升的情况。

溢出

整数运算在除数为0时会报错，而浮点数运算在除数为0时，不会报错，但会返回几个特殊值：
NaN表示Not a Number
Infinity表示无穷大
-Infinity表示负无穷大

强制转型

可以将浮点数强制转型为整数。在转型时，浮点数的小数部分会被丢掉。如果转型后超过了整型能表示的最大范围，将返回整型的最大值。

8、布尔运算

对于布尔类型boolean，永远只有true和false两个值。布尔运算是一种关系运算。

比较运算符：>，>=，<，<=，==，!=
与运算 &&
或运算 ||
非运算 !

关系运算符的优先级从高到低依次是：
!
>，>=，<，<=
==，!=
&&
||

• 布尔运算的一个重要特点是短路运算。如果一个布尔运算的表达式能提前确定结果，则后续的计算不再执行，直接返回结果。
• 与&&运算和或||运算是短路运算；

三元运算符

Java还提供一个三元运算符b ? x : y，它根据第一个布尔表达式的结果，分别返回后续两个表达式之一的计算结果。

• 三元运算b ? x : y后面的类型必须相同，三元运算也是“短路运算”，只计算x或y。

基本类型的变量是`持有`某个数值，引用类型的变量是`指向`某个对象；

9、字符类型

字符类型char是基本数据类型，它是character的缩写。一个char保存一个Unicode字符。
因为Java在内存中总是使用Unicode表示字符，所以，一个英文字符和一个中文字符都用一个char类型表示，它们都占用两个字节。

• 要显示一个字符的Unicode编码，只需将char类型直接赋值给int类型即可。
• 还可以直接用转义字符\u+Unicode编码来表示一个字符。

10、字符串类型

字符串类型String是引用类型，我们用双引号"..."表示字符串。一个字符串可以存储0个到任意个字符。

• 常见的转义字符包括：
  \" 表示字符"
  \'表示字符’
  \\ 表示字符
  \n 表示换行符
  \r表示回车符
  \t 表示Tab
  \u####表示一个Unicode编码的字符

字符串连接

可以使用+连接任意字符串和其他数据类型

多行字符串

字符串可以用"""..."""表示多行字符串（Text Blocks）

不可变特性

字符串的不可变是指字符串内容不可变，变的不是字符串，而是变量s的“指向”。

空值null

引用类型的变量可以指向一个空值null，它表示不存在，即该变量不指向任何对象。

• 注意要区分空值null和空字符串""，空字符串是一个有效的字符串对象，它不等于null。

11、数组类型

定义一个数组类型的变量，使用数组类型“类型[]”，例如，int[]。和单个基本类型变量不同，数组变量初始化必须使用 new int[5] 表示创建一个可容纳5个int元素的数组。

Java的数组有几个特点：

• 数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；
• 数组一旦创建后，大小就不可改变。
  要访问数组中的某一个元素，需要使用索引。数组索引从0开始，例如，5个元素的数组，索引范围是0~4。
• 可以修改数组中的某一个元素，使用赋值语句，例如，ns[1] = 79。
• 可以用数组变量.length获取数组大小。
• 数组是引用类型，在使用索引访问数组元素时，如果索引超出范围，运行时将报错。
• 也可以在定义数组时直接指定初始化的元素，这样就不必写出数组大小，而是由编译器自动推算数组大小。例如：

public class Main {
    public static void main(String[] args) {
        // 5位同学的成绩:
        int[] ns = new int[] { 68, 79, 91, 85, 62 };
        System.out.println(ns.length); // 编译器自动推算数组大小为5
    }
}

还可以进一步简写为：
int[] ns = { 68, 79, 91, 85, 62 };

字符串数组

字符串是引用类型，因此我们先定义一个字符串数组：

String[] names = {
    "ABC", "XYZ", "zoo"
};

• 对于String[]类型的数组变量names，它实际上包含3个元素，但每个元素都指向某个字符串对象
  

数组是同一数据类型的集合，数组一旦创建后，大小就不可变；
可以通过索引访问数组元素，但索引超出范围将报错；
数组元素可以是值类型（如int）或引用类型（如String），但数组本身是引用类型；