从0开始学Java(003)_Java数据类型_package com.xl; public class login{ public char fu-优快云博客

本文链接：https://blog.youkuaiyun.com/Loiterer_Y/article/details/83048252

Java数据类型分为两大类：基本数据类型和引用数据类型,
两者的区别在于基础数据类型不需要进行内存分配，而引用数据类型需要进行内存分配。

基本数据类型

数据类型	类型关键字	默认值
整型	`byte`、`short`、`int`、`long`	0
浮点型	`float`、`double`	0.0
字符型型	`char`	\u0000
布尔型	`boolean`	false

引用数据类型

数据类型	类型关键字	默认值
引用数据类型	数组、类、接口等	null

数据类型的选择原则

整数用int，小数用double；
描述日期时间或内存大小，用long；
实现数据传输或编码转换用byte；
逻辑控制用boolean；
避免中文乱码用char。

整型

整数常量属于int型数据，如数字30。
常量与变量的区别在于：常量的内容是固定的，变量的内容是可变的。

范例:定义int型变量

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        // 一个变量名在同一块代码中只允许声明一次
        // 变量赋值语法：value_type value_name = value ;
        int num = 10; 
        num = num * 2;
        System.out.println(num);
    }
}

数据类型的存储范围

每种数据类型都有其对应的存储范围

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE;  // int型数据的最大值
        int min = Integer.MIN_VALUE;  // int型数据的最小值
        System.out.println(max);      // 2147483647
        System.out.println(max + 1);  // 数据溢出(最小值)：-2147483648
        System.out.println(min);      // -2147483648
        System.out.println(min - 1);  // 2147483647
        System.out.println(min - 2);  // 2147483646
    }
}

当数据超过int型数据的保存范围时，数值会按照循环的形式出现，即（最大值+1）= 最小值，再+1变为最小值+1，以此类推。
这是因为数据是按照二进制进行的，第一位是符号位，而其他31位是数据位。这种现象称为数据溢出，解决方法是扩大数据范围：

范例：用long数据类型解决int型数据溢出问题

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE;
        int min = Integer.MIN_VALUE;
        // int变量 + long变量 = long变量,扩大了数据的范围
        // long result = max + 1;
        //System.out.println(result); // -2147483648
        System.out.println(max + 1L); // 2147483648
        System.out.println(min - (long)1); // -2147483649
        System.out.println((long)min - 2); // -2147483650
    }
}

上述代码中result仍然为数据溢出后的值，是因为代码的计算顺序是从等号右边到左边的，即先计算max+1，再见max+1的值赋值给result。

数据类型的转换规律

范围小的数据类型与范围大的数据类型计算时，自动转换为范围大的所数据类型；
范围大的数据类型只能通过强制转换变为范围小的数据类型。
常量进行强制转换，可通过使用常量标记（如L，l可将int型常量变为long型）或使用(数据类型)常量。

范例：强制转换

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        // 1000是int型，使用long型变量接收，发生自动转换
        long num = 1000;
	    // long型变为int型，强制转换
        int x = (int) num; 
        System.out.println(x); // 1000
    }
}

当进行强制转换的数值超出范围小的数据类型的范围时，依然会发生数据溢出。

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        // 2147483650L是long型数据，超出int型的范围
        long num = 2147483650L ;
        int x = (int) num; 
        System.out.println(x); // -2147483646，数据溢出
    }
}

byte型数据的取值范围为-128~127。当int型数据在这个范围内时，会自动转型；超出byte范围时,需要强制转换且会发生数据溢出。

public class Hello {
    public static void main(String[] args) {
        // 10是int类型，int类型范围大于byte
        // 理论上来说需要进行强制转换
        // 但因为其数据量仍在byte范围内，不需要强制转换
        byte data = 10;
        System.out.println(data);
    }
}

处于byte存储范围内的整数常量可以进行自动类型转换；整数变量只能进行强制类型转换。

public class Demo {
    public static void main(String[] args) {
        int num = 10;
        // Error:(11, 21) java: 不兼容的类型: 从int转换到byte可能会有损失
        byte data = num;
        System.out.println(data);
    }
}

变量的默认值

变量声明时应设置具体数值，不使用默认值。在方法中定义的变量，其默认值是无效的。

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        // 未给变量赋值
		int num;  
		// 报错,未初始化变量,无法使用该变量
        System.out.println(num); 
    }
}

浮点型

Java中浮点数属于double型（double型是保存范围最广的类型）。

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        double num = 10.2; // 10.2是小数，属于double型
        // double型 * int型 = double型
        System.out.println(num * 2); // 20.4
    }
}

使用float数据须将double强制转换为float型：

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        float fA = 10.2F;         // 强制转型方式一
        float fB = (float) 10.2;  // 强制转型方式二
        System.out.println(fA);   // 10.2
        System.out.println(fB);   // 10.2
        System.out.println(fA * fB); // 104.03999,该bug无法解决
    }
}

整型数据不保留小数位：

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int x = 5;
        int y = 9;
        System.out.println(y / x); // 1
    }
}

因为int型/int型=int型，不保留小数位，所以要取得正确的计算结果，需要将其中一个整型变为浮点型：

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int x = 5;
        int y = 9;
        System.out.println(y / (double) x); // 1.8
    }
}

字符型

byte

byte是字节，1字符=2字节。Java使用十六进制UNICODE编码，可以保存任意符号，并且考虑到与其他语言的结合，包含了ASCII码的部分编码，以实现无缝衔接。

字符型使用char表示，

单引号'声明，一对单引号只能保存一位字符；字符型可以与int型互相转换。

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        char c = 'A';
        int num = c; // char型可以自动转换为int型
        System.out.println(c);   // A
        System.out.println(num); // 65,是A的ASCII码值
    }
}

编码：

'A'(65)~'Z'(90);
'a'（97）~'z'（122）;
'0'（48）~'9'(57)

可利用A和a的编码差为32，实现字母大小写转换：

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        char c = 'A';
        int num = c;     // char型变为int型才能进行四则运算
        num = num + 32;  // 大写与小写编码值差为32
        c = (char) num;  // int型只能强制转换为char型
        System.out.println(c); // a
    }
}

UNICODE编码

传统编程语言字符只能保存英文标记，但UNICODE可以保存任何文字包括中文。

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        char c = '游';
        int num = c;
        System.out.println(num); // 28216
    }
}

由于Java可以保存中文，因此处理断句时,可以使用字符类型。

布尔型

布尔型返回逻辑结果，主要用于逻辑控制，只保存两种数据：true和false：

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        boolean flag = false;
        //  if (布尔值){满足条件时的操作}
        if (!flag) {
            System.out.println("Hello World !");
        }
    }
}

java中boolean与int型不能转换。

初识String型

String型

String是引用数据类型(是类,Java中类名称首字母大写)，表示字符串，即多个字符的集合，使用双引号""声明。

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        String str = "Hello World !"; // str为字符串变量
        System.out.println(str);
        // "Hello World !"为字符串常量
        System.out.println("Hello World !");
    }
}

符号`+`可用于字符串连接

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        String str = "Hello";
        str = str + " World !";
        System.out.println(str);
    }
}

当四则运算与字符串连接同时存在时：

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int numA = 100;
        double numB = 99.9;
        String str = "加法计算：" + numA + numB;
        System.out.println(str); // 加法计算：10099.9
    }
}

出现上述结果是因为小范围数据会自动转型为大范围数据，即String型+任意数据类型=String型，然后进行字符串连接，可使用()来实现正确的运算：

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int numA = 100;
        double numB = 99.9;
        String str = "加法计算：" + (numA + numB);
        System.out.println(str); // 加法计算：199.9
    }
}

转义字符

Java支持转义字符，例如换行\n、制表符\t、反斜杠\\、双引号\"、单引号\'：

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        String str = "Hello \"World\" \nHello";
        System.out.println(str);
        /**
         * Hello "World"
         * Hello
         */
    }
}