Java 学习笔记（三）数据类型

数据类型

程序中的数据分为不同的类型，如：整数，小数，字符，布尔，字符串等。不同类型的数据在内存中的存储方式不同，数据的取值方式不同，允许的操作也不同。

数据类型的分类

Java 的数据类型可以分为两大类，分别是基本类型和引用类型

• 基本类型包括：整数，小数，字符，布尔

• 引用类型包括：类，接口，数组，枚举，注解

基本类型

基本数据类型，总共有四类，八种

1. 整数类型，包括：byte , short , int , long 4 种

| 类型 | 占用存储空间 | 存储范围 |

| ------- | ------------ | ---------------------- |

| byte | 1 字节 | -128~127 |

| short | 2 字节 | -32768~32767 |

| int | 4 字节 | -2147483648~2147483647 |

| long | 8 字节 | -263 ~ 263 -1 |

- 所有的整数值，默认为 int 类型

- 在对 byte 和 short 类型赋值时，会先判断该值是否超出 int 类型的取值范围，如果超了，会报错，如果没有超出，会再判断该值是否超出了 byte 或者 short 的取值范围，如果超了，会报错，如果没超，则赋值成功

- 在对 long 类型赋值时，会先判断该值是否超出 int 类型的取值范围，如果没超，会赋值成功；如果超了，会报错，需要在该值后面加上 L

1. 浮点类型

| 类型 | 占用存储空间 | 精度 |

| -------- | ------------ | ------------- |

| float | 4 字节 | 7 位有效数字 |

| double | 8 字节 | 15 位有效数字 |

- 浮点类型的值默认为 double 类型

- 在对 float 类型赋值的时候，需要在该值后面加上 f 或者 F

1. 字符类型

| 类型 | 占用存储空间 | 存储范围 |

| ------ | ------------ | -------- |

| char | 2 字节 | 0～65535 |

- 字符类型只能存放一个字符，并且使用英文的单引号引起来

- 整数类型和字符类型可以相互赋值

```java

class Example01 {

public static void main(String[] args) {

// char 类型可以存放字母，中文，数字类型的字符

char cr = 'a';

cr = '汉';

cr = '5';

/*

整数类型和字符类型可以相互赋值

ASCII:

'a':97, 'b':98...

'A':65, 'B':66...

'0':48, '1':49...

*/

cr = 100;

// 输出结果：d

System.out.println(cr);

cr = 65;

// 输出结果：A

System.out.println(cr);

int i = 1;

i = 'A';

// 输出结果：65

System.out.println(i);

}

}

```

1. 布尔类型

- 布尔类型 boolean 占一个字节

- 有且只有两个取值：true 和 false

###### 基本类型转换

除了 boolean 类型之外，其他 7 中数据类型之间是可以相互转换的

• 当取值范围小的类型给取值范围大的类型赋值，则构成自动类型转换

• 当取值范围大的类型给取值范围小的类型赋值，则需要进行强制类型转换

• short 和 char 之前需要强转

• 当对 byte short char 类型赋值时，没有超出当前数据类型取值范围，可以直接赋值

• 当对 byte short char 类型进行混合运算时，会先转为 int 类型，再进行计算

• 当多种类型进行混合运算时，结果为当前计算中取值范围大的类型

graph LR
A(byte) --> B(short)B --> C(int) D(char) -->CC --> E(long) E --> F(float)F --> G(double) 

class Example02 {    public static void main(String[] args) {        // 当取值范围小的类型给取值范围大的类型赋值，构成自动类型转换
        // byte 赋值给 short        byte be = 10;        short st = be;        // short 赋值给 int        short st1 = 1;        int i = st;        // char 赋值给 int        char cr = 'a';        int i1 = cr;        // int 赋值给 long        int i2 = 2;        long lg = i2;        // long 赋值给 float ,输出结果：3.0        long lg1 = 3;        float ft = lg1;        System.out.println(ft);        // float 赋值给 double        float ft1 = 5.9f;        double de = ft1;
        // 当取值范围大的类型给取值范围小的类型赋值，需要进行强制类型转换
        // double 强转成 float        double de1 = 6.0;        float ft2 = (float)de1;        // float 强转成 long ,输出结果：6        float ft3 = 6.6f;        long lg2 = (long)ft3;        System.out.println(lg2);        // long 强转成 int        long lg3 = 11;        int i3 = (int)lg3;        // int 转 byte short        int i4 = 99;        byte be1 = (byte)i4;        // int 转 short        int i5 = 98;        short st2 = (short)i5;    }}

运算符

算术运算符

加 + 减 - 乘 * 除 / 求余 % 自加 1 ++ 自减 1 --

++ 和 -- 都分为前置和后置，前置是先自身加/减，再进行运算；后置是先进行运算，再进行自身加/减

class Example03 {    public static void main(String[] args) {    // 前置 ++ ，先自加1，再进行计算，输出结果：i1 = 4，i2 = 8    int i1 = 3;    int i2 = ++i1 * 2;    System.out.println("i1 = " + i1 + "，i2 = " + i2);
    // 后置 ++ ，先进行计算，再自加1，输出结果：i3 = 5，i4 = 8    int i3 = 4;    int i4 = i3++ * 2;    System.out.println("i3 = " + i3 + "，i4 = " + i4);
    // 前置 -- ，先自减1，再进行计算，输出结果：i5 = 5，i6 = 10    int i5 = 4;    int i6 = ++i5 * 2;    System.out.println("i5 = " + i5 + "，i6 = " + i6);
    // 后置 -- ，先进行计算，再自减1，输出结果：i7 = 4，i8 = 10    int i7 = 5;    int i8 = i7-- * 2;    System.out.println("i7 = " + i7 + "，i8 = " + i8);    }
}

赋值运算符

= += -= *= /= %=

class Example04 {    public static void main(String[] args) {        int i = 1;        // 等价于 i = i + 1;        i += 1;    }}

关系运算符

> < >= <= == !=

关系运算符，如果满足条件，则返回结果为 true

逻辑运算符

• 逻辑与 & 表示并且，同时

- 当两个条件都为真，则结果为真

• 逻辑或 | 表示或者

- 当有一个条件为真，则结果为真

• 逻辑异或 ^

- 当两个条件的结果不相同，则结果为真

• 逻辑非 !

- 对结果取反

• 短路与 && 表示并且，同时

- 当第一个条件为假，则结果为假，不再判断第二个条件

• 短路或 || 表示或者

- 当第一个条件为真，则结果为真，不再判断第二个条件

三目运算符

语法格式：条件 ? 代码 1 : 代码 2

执行流程：如果条件成立，执行代码 1，如果条件不成立，执行代码 2

使用场景：需要根据条件从两种结果当中选择其中一个的时候

class Example05 {    public static void main(String[] args) {        // 三目运算符
        // 判断条件 1 > 2 是否成立，成立输出“大于”，不成立输出“不大于”。输出结果：不大于        System.out.println(1 > 2 ? "大于" : "不大于");
        // 输出结果：10是偶数        int i1 = 10;        System.out.println(i1 % 2 == 0 ? i1 + "是偶数" : i1 + "是奇数");
        /*        三目运算符嵌套        判断一个数，如果大于0输出大于，如果小于0输出小于，否则输出等于        此时，可以把代码2 看成一个整体，另一个三目运算符        */        int i2 = 0;        System.out.println(i2 > 0 ? i2 + "大于0" : i2 < 0 ? i2 + "小于0" : i2 + "等于0");    }}