02.Java中的数据类型与变量

1.数据类型概述

java中的数据类型大致有两种：

1. 基本数据类型：整型，浮点型，布尔，字符

整型包括：byte，short，int，long
浮点型包括：float，double

2. 引用数据类型：数组，字符串，类，接口，String

概括：

注意：

1. 不论是在16位的系统还是32位系统，int都占4个字节，long都占8个字节
2. 整型和浮点型都是带有符号的
3. 整型默认为int型，浮点型默认为double

2.变量

2.1整型变量

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;//4个字节
        System.out.println(a);
        // int 的包装类型为 Inteter
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        long l = 20L;//8个字节
        System.out.println(l);
        // long 的包装类型为 Long
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);

        short s = 30;//2个字节
        System.out.println(s);
        // short 的包装类型为 Short
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);

        byte b = 40;//1个字节
        System.out.println(b);
        // byte 的包装类型为 Byte
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
    }
}

2.2浮点型变量

2.2.1双精度浮点型

public static void main(String[] args) {
        double d=3.14;
        System.out.println(d);

        //神奇代码1
        int a=1;
        int b=2;
        System.out.println(a/b);//输出为0；
        double a1=1.0;
        double b1=2.0;
        System.out.println(a1/b1);//输出为1.2100000000000002

        //神奇代码2
        double num=1.1;
        System.out.println(num*num);
    }

1. 神奇代码1解释：在java中，int除以int仍然为int(会直接舍弃小数部分)，如果想得到0.5，就得使用double类型计算
2. 神奇代码2解释：在java中，小数没有一个精确的数字，只能精确到小数点后几位

注意事项：
3. double在任何系统下都占8个字节
4. 浮点数与整数在内存中的存储方式不同，不能单纯使用$2^n$的形式来计算
5. double的包装类型为Double
6. double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值

2.2.2单精度浮点型

public static void main(String[] args) {
        float f=1.23f;//也可以记作F
        System.out.println(f);
    }

float在java中占4个字节，同样遵守 IEEE 754 标准，但是由于数据的·精度范围较小，所以在工程上用到浮点数都优先考虑用double，不太推荐使用float。
float的包装类型为Float；

2.3字符型变量

public static void main(String[] args) {
        char c1='A';
        char c2='1';
        char c3='帅';
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
    }

注意事项：

1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值
2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文
3. char的包装类型为Character
4. char的大小为两个字节，因此可以存储汉字
5. 执行 javac 的时候可能出现错误时，可以加上一下命令：

javac -encoding UTF-8 Test.java

2.4布尔型变量

public static void main(String[] args) {
        boolean a=true;
        System.out.println(a);
        boolean b=false;
        System.out.println(b);
    }

注意事项：

1. boolean类型的变量只用两种取值，true表示真，false表示假
2. Java中的 int 和 boolean不能相互转化，不存在 1表示true，0表示false；
3. Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在Oracle公司的虚拟机实现中，boolean占1个字节。
4. boolean的包装类型为Boolean

3.类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验
在Java中，当参与运算数据类型不一致时，就会进行类型转换。Java中类型转换主要分为两类：自动类型转换(隐式)和 强制类型转换(显式)。

3.1自动类型转换（隐式）

自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。
特点：数据范围小的数据转换为数据范围大的数据时会自动进行

public static void main(String[] args) {
        System.out.println(3.14);
        System.out.println(1024);

        int a=100;
        long l=10L;
        b=a;//a和b都是整型，a的范围小，b的范围大，当把a的值赋值给b时，编译器会自动将a提升为long类型，然后赋值
        a=b;//编译报错，long的数据范围比int范围大，会有数据丢失，不安全；

        float f=3.14F;
        double d=5.12;
        d=f;// 编译器会将f转换为double，然后进行赋值
        f=d; double表示数据范围大，直接将float交给double会有数据丢失，不安全

        byte b1=100;// 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
        byte b2=257; 编译失败，257超过了byte的数据范围，有数据丢失
    }

3.2强制类型转换（显式）

public static void main(String[] args) {
        System.out.println(3.14);
        System.out.println(1024);

        int a=100;
        long l=10L;
        b=a;//int ——> long,数据范围由小到大，隐式转换
        a=(int)b;//long ——> int,数据范围由大到小，需要强转，否则编译失败

        float f=3.14F;
        double d=5.12;
        d=f;//float ——> double,数据范围由小到大，隐式转换
        f=(float)d;//double ——> float,数据范围由大到小，需要强转，否则编译失败

        a=d;//报错。类型不兼容
        a=(int)d;//double ——> int,数据范围由大到小，需要强转，否则编译失败

        byte b1=100;// 100默认为int,没有超过byte范围，隐式转换
        byte b2=(byte)257;//257默认为int，超过byte范围，需要显式转换，否则报错

        boolean flag = true;
        a = flag; // 编译失败：类型不兼容
        flag = a; // 编译失败：类型不兼容
    }

注意事项：

1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
4. 强制类型转换不一定能成功，不相干的类型不能互相转换

3.3类型提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的；

3.3.1 int 与 long：int 会被提升为long

public static void main(String[] args) {
        int a=10;
        long b=20L;
        int c=a+b;//编译失败：a+b ————> int + long —————>long  +long,赋值给int时就会出错
        long d=a+b;//编译成功：a+b ————> int + long —————>long  +long,赋值给long
    }

3.3.2 byte与byte的运算

public static void main(String[] args) {
        byte a=10;
        byte b=20;
        byte c=a+b;//编译出错
        byte c=(byte)(a+b);//编译成功
    }

结论：
byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误

由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于 4 个字节的类型, 会先提升成 int, 再参与计算

类型提升总结：

1. 不同类型的数据混合运算, 范围小的会提升成范围大的.
2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算

4.字符串类型

在Java中使用String类型定义字符串：

public static void main(String[] args) {
        String s1="hello";
        String s2="world";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1+s2);//s1+s2，直接将s1和s2拼接
    }

字符串和整型之间的相互转换

1.int 转换为String

public static void main(String[] args) {
        int num=10;
        //方法1
        String str1=num+"";
        //方法2
        String Str2=Integer.valueOf(num);
    }

2.String 转换成int

public static void main(String[] args) {
        String s="100";
        int num=Integer.parseInt(s);
        System.out.println(num);
    }