Java 基本变量详解 变量转换 移位运算

变量的形态

class Test {
    
    
    static int a; // 静态属性/类成员变量/类变量
    int b; // 属性/成员变量/实例变量

    public static void main(String[] args ) {
    
    // 局部变量
        int c; // 局部变量
    }
}

这里b相当于全局变量，c就是局部变量，这里的使用和C语言类似，但是静态属性和C语言就不一样了。
用static关键字修饰的静态变量和不用static关键字修饰的实例变量。静态变量属于类，在内存中只有一个复制，只要静态变量所在的类被加载，这个静态变量就会被分配空间，因此就可以被使用了。对静态变量的引用有两种方式，分别是“类.静态变量"和”对象.静态变量"
实例变量属于对象，只有对象被创建后，实例变量才会被分配内存空间，才能被使用，它在内存中存在多个复制，只有用“对象.实例变量”的方式来引用。

整形变量（int）

在Java中，一个int变量占4个字节，和操作系统没有直接关系。
4 个字节表示的数据范围是 -2^31 -> 2^31-1 , 也就大概是 -21亿 到 +21亿。

标题长整型变量（long）

long num = 10L; // 定义一个长整型变量, L
System.out.println(num
) ;

Java 中 long 类型占 8 个字节. 表示的数据范围 -2^63 -> 2^63-1

浮点变量

双精度浮点变量（double）8个字节
单精度浮点类变量（float）4个字节

float num = 1.0f;    // 写作 1.0F 也可以
System.out.println(num);

字符类型变量

1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文.

字节类型变量

byte value = 0;
System.out.println(value);

1. 字节类型表示的也是整数. 只占一个字节, 表示范围较小 ( -128 -> +127 )
2. 字节类型和字符类型互不相干.

短整型变量

1. short 占用 2 个字节, 表示的数据范围是 -32768 -> +32767
2. 这个表示范围比较小, 一般不推荐使用。

布尔类型变量

boolean value = true;
System.out.println(value);

注意事项:

1. boolean 类型的变量只有两种取值, true 表示真, false 表示假.
2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
3. boolean 类型有些 JVM 的实现是占 1 个字节, 有些是占 1 个比特位, 这个没有明确规定.

字符串类型变量

1. Java 使用 双引号 + 若干字符 的方式表示字符串字面值.
2. 和上面的类型不同, String 不是基本类型, 而是引用类型(后面重点解释).
3. 字符串中的一些特定的不太方便直接表示的字符需要进行转义.

     System.out.println("\\\"hello\\\"");
     

输出结果：“hello”

\n 换行
\r 回到行首
\t 水平制表符
’ 单引号
" 双引号
\ 反斜杠

字符串的 + 操作, 表示字符串拼接:
还可以用字符串和整数进行拼接:

变量的命名规则

1. 一个变量名只能包含数字, 字母, 下划线
2. 数字不能开头.
3. 变量名是大小写敏感的. 即 num 和 Num 是两个不同的变量.

final关键字修饰的常量

常量不能在程序运行过程中发生修改.

final int a = 10;
a = 20;    // 编译出错. 提示 无法为最终变量a分配值

类型转换

小范围可以向大范围直接转换，大范围向小范围转换需要强转，
使用 (类型) 的方式可以将 double 类型强制转成 int. 但是

1. 强制类型转换可能会导致精度丢失. 如刚才的例子中, 赋值之后, 10.5 就变成 10 了, 小数点后面的部分被忽略.
2. 强制类型转换不是一定能成功, 互不相干的类型之间无法强转.

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
       

byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和short 这种低于 4 个字节的类型, 会先提升成 int, 再参与计算.

int和String之间的相互转换

int 转成 String

int num = 10;
// 方法1
String str1 = num + "";  
// 方法2
String str2 = String.valueOf(num);

String 转成 int

String str = "100";
int num = Integer.parseInt(str);

短路求值

&& 和 || 遵守短路求值的规则.

System.out.println(10 > 20 && 10 / 0 == 0);             // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0);             // 打印 true

计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真
正被求值.

移位运算

左移 <<: 最左侧位不要了, 最右侧补 0
右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
无符号右移 >>>: 最右侧位不要了, 最左侧补 0.

int a = 0x10;
System.out.printf("%x\n", a << 1);
// 运行结果(注意, 是按十六进制打印的)
20

int a = 0x10;
System.out.printf("%x\n", a >> 1);
// 运行结果(注意, 是按十六进制打印的)
8
    

int a = 0xffffffff;
System.out.printf("%x\n", a >>> 1);
// 运行结果(注意, 是按十六进制打印的)
7fffffff

Java 的运算符的基本规则和 C 语言基本一致。