阿里云大学 Java编程入门（五）Java数据类型划分

本系列内容为阿里云大学 java学习路线里的内容
阿里云大学 java学习路线传送门.

五、Java数据类型划分

5.1、Java数据类型简介

程序是一套数字处理的游戏框架，也就是说在整个程序的开发过程之中所达到的最终目的就是对数据的处理过程，所以就需要有各种类型的数据定义。

5.1.1 数据分类

基本数据类型：具体的数字单元。例如：1、1.1；
    数值型：
        整型：byte、short、int、long；  默认值：0
        浮点型：float、double；         默认值：0.0
    布尔型：boolean；                   默认值：false
    字符型：char；                      默认值：'\u0000'
引用数据类型：牵扯到内存关系的使用；
    数组、类、接口(包含包装类)            默认值：Null

基本类型

基本类型有对应的范围：

不同类型保存不同范围的数据，需要涉及类型选择。

参考原则

1. 描述数字，首选int double；
2. 数据传输或者文字编码转换使用byte型(二进制操作)；
3. 处理中文使用方便的是用字符char；
4. 描述内存或大小，描述表的主键列(自动增长)，用long；
5. 时间戳用long；

5.2、整型数据类型

共四种 byte short int long,任何一个整型常量,默认都是int型

public class test {
    public static void main(String args[]) {
        // int 变量名称 = 常量（10是一个常量，整数类型为int） ;
        int x = 10 ;	// 定义了一个整型变量x
        // int型变量 * int型变量 = int型数据
        System.out.println(x * x) ;
    }
}

Output：100

public class test {
    public static void main(String args[]) {
        // int 变量名称 = 常量（10是一个常量，整数类型为int） ;
        int x = 10 ;	// 定义了一个整型变量x
        x = 20 ;		// 改变了x的已有内容
        // int型变量 * int型变量 = int型数据
        System.out.println(x * x) ;
    }
}

Output：400

任何数据都有可保存的范围,一般不会超过范围,如果超过了?

public class test {
    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(min) ;	// -2147483648
        System.out.println("------------- 无以言表的分割线 -----------") ;
        // int型变量 + int型常量 = int型计算结果
        System.out.println(max + 1) ;	// -2147483648，最大值 + 1 = 最小值
        System.out.println(max + 2) ;	// -2147483647，最大值 + 1 = 次最小值
        // int型变量 - int型常量 = int型计算结果
        System.out.println(min - 1) ;	// 2147483647，最小值 - 1 = 最大值
    }
}

Output：
2147483647
-2147483648
------------- 无以言表的分割线 -----------
-2147483648
-2147483647
2147483647

32位,首位符号位,为1则是负数,按位取反+1.

出现时表示发生数据溢出,处理方式:

预估范围,如果不够则加大范围

public class test {
    public static void main(String args[]) {
        // long long变量 = int的数值
        long max = Integer.MAX_VALUE ; // 获取int的最大值
        long min = Integer.MIN_VALUE ; // 获取int的最小值
        System.out.println(max) ;	// 2147483647
        System.out.println(min) ;	// -2147483648
        System.out.println("------------- 无以言表的分割线 -----------") ;
        // long型变量 + int型常量 = long型计算结果
        System.out.println(max + 1) ;	// 2147483648
        System.out.println(max + 2) ;	// 2147483649
        // long型变量 - int型常量 = long型计算结果
        System.out.println(min - 1) ;	// -2147483649
    }
}

Output：
2147483647
-2147483648
------------- 无以言表的分割线 -----------
2147483648
2147483649
-2147483649

也可以在常量上处理,默认整数常量都是int型,可以追加L,或转换为long

public class test {
    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(min) ;	// -2147483648
        System.out.println("------------- 无以言表的分割线 -----------") ;
        // int型变量 + long型常量 = long型计算结果
        System.out.println(max + 1L) ;	// 2147483648
        System.out.println(max + 2l) ;	// 2147483649
        // long型变量 - int型常量 = long型计算结果
        System.out.println((long)min - 1) ;	// -2147483649
    }
}

Output：
2147483647
-2147483648
------------- 无以言表的分割线 -----------
2147483648
2147483649
-2147483649

强制类型转换,范围大的转换范围小的,可能会导致数据丢失

long num = 2147483649;
int temp = num;

long num = 2147483649L;
int temp = num;

public class test {
    public static void main(String args[]) {
        long num = 2147483649L ; // 此数据已经超过了int范围
        int temp = (int) num ; // long范围比int范围大，不能够直接转换
        System.out.println(temp) ;
    }
}

Output：
-2147483647

溢出了.

程序支持数据转换处理,如果不是必须的,不建议这种转换

在进行整型处理时,byte类型要注意,-128~127

范例:定义byte变量

//byte型 = int 型
byte num = 10;
Sout(num * num )
//结果400 √
byte num = 10;
byte result = num * num;
Sout(result);

正常java程序里20是int型,为byte赋值时并没有报错: java做了自动转换,如果常量没超过范围可以自动由int变为byte. 变量还是需要强转

public class test {
    public static void main(String args[]) {
        byte num = 20 ;
        System.out.println(num) ;
    }
}

Output：
20

public class test {
    public static void main(String args[]) {
        byte num = (byte) 200 ;
        System.out.println(num) ;
    }
}

Output：
-56

由于200超过了byte范围,产生溢出.

5.3、浮点型数据

任意一个小数常量,对应的是double,所以定义小数时建议使用double

public class test {
    public static void main(String args[]) {
        // 10.2是一个小数其对应的类型为double
        double x = 10.2 ;
        int y = 10 ;
        // double类型 * int类型 = double类型
        double result = x * y ;
        System.out.println(result) ;
    }
}

Output：
102.0

自动转型,都是由小到大转.默认用double,也可以用较小的float,所以赋值时需要强制转换

public class test {
    public static void main(String args[]) {
        float x = (float) 10.2 ;
        float y = 10.1F ;
        System.out.println(x * y) ;	// float型
    }
} 

Output：
103.02004

.00004时浮点型带来的精度损失

int x = 10;
int y = 4;
Sout(x/y);    //int型,不保存小数点后的   2

int x = 10;
int y = 4;
Sout((double)x/y);    //double型  2.5

5.4、字符型

使用’ '定义的内容就是一个字符

public class test {
	public static void main(String args[]) {
		char c = 'B' ; // 一个字符变量
		System.out.println(c) ;
	}
}

Output：
B

任何编程语言,字符可以与int相互转换.也就是字符对应的内容,可以转换成系统所对应的系统代码

public class test {
    public static void main(String args[]) {
        char c = 'A' ; // 一个字符变量
        int num = c ;	// 可以获得字符的编码
        System.out.println(num) ;
    }
}

Output：
65

char范围

大写字母: A(65)~~ Z(90)
小写字母: a(97)~~ z(122)
数字范围: ‘0’(48)~~‘9’(97)
大小写差了32个数,实现大小写转换

char c = 'x';
int num = c + 32;
Sout((char)num);         //X

到目前与c一致,但char可以保存中文字符

public class test {
    public static void main(String args[]) {
        char c = '仁' ; // 一个字符变量
        int num = c ;	// 可以获得字符的编码
        System.out.println(num) ;
    }
} 

Output：
20161

java可以使用char保存中文,是因为java使用的Unicode的编码,主要特点是可以保存任意语言.

以前情况.换行时中文容易出乱码,字母1字节,中文2字节

5.5、布尔型

布尔时数学家名字,描述逻辑处理结果,java中只有true false

public class test {
    public static void main(String args[]) {
        boolean flag = true ;
        if (flag) {	// 判断flag的内容，如果是true就执行
            System.out.println("测试") ;
        }
    }
}

Output：
测试

部分编程语言,会用0代表false,1代表true. java不能混用

5.6、String字符串

在任何语言里都没有提供所谓的字符串这种数据,但从实际的使用上来讲,各个编程语言都会提供字符串的相应描述.在Java里使用String作为字符串定义

由于String类的存在较为特殊,所以其可以像普通变量那样采用直接赋值进行定义,使用" " 进行表示

public class test {
    public static void main(String args[]) {
        String str = "Hello World !" ;	// 使用“"”进行描述
        System.out.println(str) ;
    }
}

Output：
Hello World !

在进行字符串变量使用时也可以使用"+" 来进行字符串连接处理

public class test {
    public static void main(String args[]) {
        String str = "Hello" ;	// 使用“"”进行描述
        str = str + " World" ; // 字符串连接
        str += " !!!" ;		// 字符串连接
        System.out.println(str) ;
    }
}

Output：
Hello World !!!

需要考虑零一点,对于+有了两种描述(字符串连接, 加法计算)

public class test {
    public static void main(String args[]) {
        double x = 10.1 ;
        int y = 20 ;
        String str = "计算结果：" + x + y ;
        System.out.println(str) ;
    }
}

Output：
计算结果:10.120

public class test {
    public static void main(String args[]) {
        double x = 10.1 ;
        int y = 20 ;
        String str = "计算结果：" + x - y ;
        System.out.println(str) ;
    }
}

java: 二元运算符 '-' 的操作数类型错误
  第一个类型:  java.lang.String
  第二个类型: int

数据范围大的与数据范围小的进行计算时,所有类型小的数据会变成大的数据类型. + 连接的有字符串,则全部变成String型运算.

public class test {
    public static void main(String args[]) {
        double x = 10.1 ;
        int y = 20 ;
        String str = "计算结果：" + (x + y) ;
        System.out.println(str) ;
    }
}

Output：
计算结果:30.1

可以使用转义字符进行一些处理,例如:TAB(\t), "(\ "), ’ (\ '), 换行(\n) ,\ (\ \ )

String str = "Hello \n World!";
Sout(str);
//Hello
//World