# 变量和数据类型

# 变量

# 概述

变量是指在内存中的一个存储单元，可以存储任意数据类型的数据。比如：一个空房间（理解为内存），放一张椅子（理解为变量），椅子上可以坐一个人也可以放一本书（人、书可以理解为不同类型的数据）。 java 中分为两种变量类型：基本数据类型变量和引用数据类型变量（后续说明）。
java 中变量必需先定义后使用，变量类型必需要有，定义变量时可以先赋予初始值。注意： = 是赋值语句。

例如：
```java
// int 变量类型，x 变量名，初始值赋值为 30
int x = 30;
int y = 20;
int z = x + y;

1
2
3
4
5
6

说明：

变量定义时要声明变量的类型
变量要先定义后使用。
变量可以定义就赋值，也可以先定义后赋值。
一行可以定义多个变量。
在同一作用域中，变量名不能重复。
变量类型定义后，值必需是相同类型的值。例如：定义整型 int 类型值，那么值也必需是 int 类型的值。
没有声明的变量，无法使用
变量名字
- 字母、数字、"_"、"$"，组成，但不能以数字开头。
- 不能使用保留字（java语言中使用的词，例如：int、public、static ...）
- 中文可以，但不提倡
- 驼峰式写法，要见名知意，

public class Var {
  public static void main(String[] args) {
    // 定义就赋值
    int x = 30; 
    System.out.println(x);// 30
    // 先定义后赋值
    int y;
    y = 60;
    System.out.println(y);// 60
    // 一行可以定义多个变量
    int a, b, c = 20;
    a = 10;
    b = a;
    System.out.println(a);// 10
    System.out.println(b);// 10
    System.out.println(c);// 20
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 变量分类

变量根据声明的位置不同可分为：成员变量(也可以叫全局变量或实例变量)和局部变量。方法体内的变量是局部变量，方法体外类体内的变量是成员变量。static 关键字修饰的称为静态成员变量。
局部变量只能在当前方法体内使用，成员变量可以在类体内任意方法体内使用。

public class Var2 {
  int x = 10; // 全局变量/实例变量/成员变量
  static int y = 20; // 静态全局变量/实例变量/成员变量

  // int a，int b 局部变量
  public static void sun(int a,int b) {
      // 局部变量
      int c = 30;
  }
}

1
2
3
4
5
6
7
8
9
10

# 变量作用域

局部变量只能在当前方法体内使用，成员变量可以在类体内任意方法体内使用，这就是变量作用域的概念。

使用下面代码试一下：

public class VarScope {
    static int x = 10;
    public static void main(String[] args) {
        int y = 20;
        System.out.println("xֵ:"+x);
        System.out.println("yֵ:"+y);
        System.out.println("zֵ:"+z); //编译报错，z未定义
    }

    public void getVal() {
        int z = 30;
        System.out.println("xֵ:"+x);
        System.out.println("yֵ:"+y); //编译报错，y未定义
        System.out.println("zֵ:"+z);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

报错如下：

VarScope.java:7: 错误: 找不到符号
        System.out.println("z?:"+z); //编译报错，z未定义
                                 ^
  符号:   变量 z
  位置: 类 VarScope
VarScope.java:13: 错误: 找不到符号
        System.out.println("y?:"+y); //编译报错，y未定义
                                 ^
  符号:   变量 y
  位置: 类 VarScope
2 个错误

1
2
3
4
5
6
7
8
9
10
11

# 数据类型

# 概述

java 中数据类型分为两种：基本数据类型和引用数据类型。

基本数据类型（包括四大类八小类）
- 整型 byte,short,int,long
- 浮点型 float,double
- 布尔型 boolean
- 字符型 char
引用数据类型
- 数组 []
- 类 class
- 接口 interface
- 枚举 enum
- ...

备注：

整型不是四舍五入，而是舍弃小数部分
字符串-使用双引号 "abc"，字符-使用单引号 'a'

# 基本类型

基本数据类型占用空间大小、取值范围：

基本数据类型	占用空间大小(单位:字节)	取值范围	缺省值
byte（字节型）	1	-128~127	0
short（短整型）	2	-32768~32767	0
int（整型）	4	-2147483648~2147483647	0
long（长整型）	8	-9223372036854775808~9223372036854775807	0L
float（单精度）	4	-3.4E38~3.4E38	0.0f
double（双精度）	8	-1.7E308~1.7E308	0
boolean（布尔型）	1	true/false	false
char（字符型）	2	0~65535	'\u0000'

public class DataType {
    public static void main(String[] args) {
        // 基本数据类型 -----------
        // byte 字节型: -128 ~ 127
        byte b1 = 127;
        byte b2 = -128;
        // 整型
        // short 短整型: -32768 ~ 32767
        short s1 = 32767;
        short s2 = -32768;
        // int 整型: -2147483648 ~ 2147483647
        int i1 = 2147483647;
        int i2 = -2147483648;
        // long 长整型: -9223372036854775808 ~ 9223372036854775807
        long l1 = 9223372036854775807L;
        long l2 = -9223372036854775808L;
        // 浮点型
        // float 单精度浮点型: -3.4E-038 ~ 3.4E-038
        float f1 = 3.4E-038f;
        float f2 = -3.4E-038f;
        // double 双精度浮点型: -1.7E-308 ~ 1.7E-308
        double d1 = 1.7E-308;
        double d2 = -1.7E-308;
        // 布尔型
        boolean bo1 = true;
        boolean bo2 = false;
        // 字符型
        char c1 = 'a';
        char c2 = '\u0041';
        char c3 = '中';
        // 引用数据类型 -----------
        // 字符串
        String str1 = "hello";
        String str2 = "中国";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

根据上面表格所展示的，每个类型不超过对应的取值范围，否则会报错。

备注：

在java语言当中，整数型（byte、short、int、long）字面量默认被当做int类型处理，浮点型（例如：3.0、1.333...）的字面量被默认当做double类型处理。
长整型 long 后面加 l/L，一般是L便于识别
浮点型 float 后面加 f
布尔型 boolean 只有 true/false
字符型 char 使用单引号 'a'
字符串型 String 使用双引号 "abc"
除了基本类型，其他类型都是引用类型，常用的是 String

# 基本数据类型转换

6条规则：

八种基本数据类型，除了 boolean 剩下的都可以互相转换类型
如果整数型字面量没有超出byte,short,char的取值范围，可以直接将其赋值给byte,short,char类型的变量
小容量向大容量转换称为自动类型转换，【容量】从小到大的排序为：byte < short(char) < int < long < float < double
- 注：short和char都占用两个字节，但是char可以表示更大的正整数；
大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用
byte,short,char类型混合运算时，先各自转换成int类型再做运算
多种数据类型混合运算，各自先转换成容量最大的那一种再做运算

public class TypeConversion {
    public static void main(String[] args) {
        /**
         * - 八种基本数据类型，除了 boolean 剩下的都可以互相转换类型
         * - 如果整数型字面量没有超出byte,short,char的取值范围，可以直接将其赋值给byte,short,char类型的变量
         * - 小容量向大容量转换称为自动类型转换，容量从小到大的排序为：byte < short(char) < int < long < float < double
         *   - 注：short和char都占用两个字节，但是char可以表示更大的正整数；
         * - 大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用
         * - byte,short,char类型混合运算时，先各自转换成int类型再做运算
         * - 多种数据类型混合运算，各自先转换成容量最大的那一种再做运算
         */
        // 1000超出byte取值范围，不能直接赋值
        //byte b1 = 1000;
        // 如果想让上面程序编译通过，可以手动强制类型转换，但程序运行时会损失精度
        byte b1 = (byte)1000;
        // -24
        System.out.println(b1);

        // 20没有超出byte取值范围，可以直接赋值
        byte b2 = 20;
        // 1000没有超出short取值范围，可以直接赋值
        short s = 1000;
        //1000本身就是int类型，以下程序不存在类型转换
        int c = 1000;
        //小容量赋值给大容量属于自动类型转换
        long d = c;
        //大容量无法直接赋值给小容量
        //int e = d;
        //加强制类型转换符
        int e = (int)d;
        //int类型和int类型相除最后还是int类型，所以结果是3
        int f = 10 / 3;
        // 3
        System.out.println(f);

        long g = 10;
        //g是long类型，long类型和int类型最终结果是long类型，无法赋值给int类型
        //int h = g / 3;
        //添加强制类型转换符
        int h = (int)(g / 3);
        //long类型赋值给long类型
        long m = g / 3;
        //g先转换成byte，byte和int运算，最后是int类型，无法直接赋值给byte
        //byte x = (byte)g / 3;
        //将以上程序的优先级修改一下,多种数据类型混合运算，各自先转换成容量最大的那一种再做运算,所以g / 3是long类型
        byte x = (byte)(g / 3);
        short y = (short)(g / 3);

        short i = 10;
        byte j = 5;
        //short和byte运算时先各自转换成int再做运算，结果是int类型，无法赋值给short,规则：byte,short,char类型混合运算时，先各自转换成int类型再做运算
        //short k = i + j;
        short k = (short)(i + j);

        int n = i + j;
        char cc = 'a';
        // a
        System.out.println("cc = " + cc);
        //将字符型char转换成数字，'a'对应的ASCII是97
        System.out.println((byte)cc);
        //char类型和int类型混合运算，char类型先转换成int再做运算，最终197
        int o = cc + 100;
        System.out.println(o);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# 引用数据类型

后续更新

← 计算机内存基本知识【扩展】 java运算符 →