Java数据类型

数据类型的作用：决定了变量可以存储的类型和存储的范围。

数据类型：分为两大类 分别为 基本数据类型 和引用数据类型(后续会讲)

基本数据类型

基本数据类型分为8种：byte,short,int,long,float,double,char,boolean

常用的分为5种：

整数类型：int, long

小数类型：double

字符类型：char

布尔类型:boolean

不常用：byte(涉及到IO相关知识),short 和 float(只是为了吸引C语言程序员)

GB(吉字节)

1GB = 1024MB

MB(兆字节)

1MB = 1024KB

KB(千字节)

1KB = 1024b

b(字节)

1b = 8bit(位)

整数类型

int 类型: 在内存中占用4个字节,存储的范围 -21亿多 ~ 21亿多(2147483647)

1.整数的直接量默认为int类型,直接量是不能够超出当前类型可以存储的范围,否则会报错!

2.如果两个整数进行运算时!结果是不会保留小数位!

3.整数如果运算时,若超出当前类型可容纳的范围,则会造成溢出现象.(溢出不算错误)但是需要避免,溢出的数据没有参考价值!

package day03;

/**
 * 整数类型的使用演示类:
 * int
 * long
 */
public class DataTypeDemo {

    public static void main(String[] args) {

        //整理代码格式的快捷键: ctrl + alt + l
        //快速注释当前光标选中行代码的快捷键:ctrl + /
        //tab键 --->可以生成4个空格.

        //100 则为整数直接量
        int a = 100;//声明一个int类型的变量 名为a  并为里面存了100
//        int b = 2147483648; int最大值只能存储到2147483647  所以此行编译错误.不能超过当前类型可容纳的范围

        System.out.println(5 / 2); //不会四舍五入 截断小数点的内容.

        int number = 2147483647;
        int result = number + 8888888;
        System.out.println(result);

        //-2147483648 为int的最小值  --------->   2147483647为int的最大值

        /**
         *  +1   ---------------   (-2147483648)
         *  +1+1 ---------------   (-2147483647)
         *  +1+1+1 -------------   (-2147483646)
         */

    }

}

变量占多大内存,取决于声明变量时的类型,而不是装载的数据!

int a = 1;

int b = 2147483647;

---

long:在内存中占用8个字节,可存储的范围是:-900万万亿 ~ 900万万亿

1.长整数类型,长整数类型的直接量 需要在后缀加上L .

2.长整数类型在进行运算时,建议要在运算的第一个数据后缀加上L,规避溢出风险!

   //long类型:

	 long a = 10000000000L; //长整数的直接量需要用后缀L来表示是long类型

 

​          // 20亿没溢出 X 10L

​    long b = 1000000000 * 2 * 10L;

​    System.out.println(b); //200亿

​         //30亿已经超过了 int 最大值 所以计算数据有问题

​    long c = 1000000000 * 3 * 10L;

​    System.out.println(c);//运算的数据不准确!

 

​    long d = 1000000000L * 3 * 10;

​    System.out.println(d);

 

 

Long类型也是不常用的

小数类型

double类型(双倍精度浮点数):占了8个字节,可以存储很大很大的数据了!

1.小数的直接量默认为double类型

2.double类型的直接量,也可以在后缀加上D.

3.double类型的数据,进行运算时,可能存在误差!

//小数直接量,默认为double类型.
        double a = 3.14;//声明一个double类型的变量名为a 并存储了3.14

                double b = 3.0;
                double c = 2.9;
                System.out.println(b - c);//0.10000000000000009    可能存在误差

                double e = 6.0;
                double f = 4.9;
                System.out.println(e - f);//1.0999999999999996    可能存在误差

                double g = 6.0;
                double h = 1.9;
                System.out.println(g - h);//4.6    可能存在误差

布尔类型

boolean类型占用内存1个字节,要么存(true 成立) ,要么存(false 不成立)

boolean a = true;
System.out.println(a);
boolean b = false;
System.out.println(b);

字符类型

字符是什么? 键盘上的字母,数字,汉字,特殊符号等...

Unicode:统一字符码,万国码.Unicode中划分了很多个子集,而Java中char类型,采用是最常用的字节 ASCII 码表.

1.码表,表象是字符,本质其实是码.(一个字符对应一个码)( 0~ 65535)之间

2.字符的直接量 只能用单引号来存储,且只能存储一个字符!

3.Java中的字符无法直接存储特殊的字符,如果需要存储特殊含义的字符,需要转义! 转义符号 \ .

package day03;

/**
 * 字符的是用演示类:
 */
public class DataTypeDemo03 {

    public static void main(String[] args) {
        char temp = 'a';//声明一个char类型的变量 名为temp 存储了字符 a

        System.out.println(temp);
        System.out.println((int) temp);
//      char t1 = 'aa'; 编译错误:单引号中只能存单个字符!
        char temp2 = '\''; //存储特殊的字符符号,需要转义才可以存储
        System.out.println(temp2);

        char temp3 = '\\'; //存储\
        System.out.println(temp3);// \
    }
}

类型转换

分为两种

1.自动类型(隐式)转换:将小的类型 装载到 大类型中的过程.

从小到大: byte --->short---->int----->long---->float----->double

//自动类型转换

int a = 100;//并没有发生自动类型转换
long b = a;//发生了自动类型转换
double c = b;//发生了自动类型转换

2.强制类型(显式)转换:将大的类型 装载到 小类型中的过程.

强制类型转换的语法:在需要强转的变量前加上一组小括号,括号内填入要转换的类型即可

强转有风险,使用需谨慎 可能会出现数据溢出的情况,具体要看强制后的类型可容纳范围是否在强转前变量内存储内容之间.

//强制类型转换  :
                long d = 1000000000L;
                int e = (int)d; //强转有风险,使用需谨慎 可能会出现数据溢出的情况
                System.out.println(e);

                double f = 3.1415926;
                int g = (int)f;//将小数类型强转为整数时, 会截断删除小数.
                System.out.println(g);

规则

整数直接量是可以赋值给byte/short/char 这些的类型的,但是不能超过当前类型可容纳的范围.

byte short char 若进行运算时,系统会自动将其结果转换为 int类型!

小类型 与 大类型进行运算时,系统会自动将其结果转换为大类型.

        byte a = 127;

        byte b = 1;
        byte c = 2;
        byte d = (byte) (b + c);
//        System.out.println(d);

        char e = '2'; // 50
        char f = '2'; // 50
        System.out.println(e + f);
        char r = (char) (e+f);
        System.out.println(r);

        byte b1 = 100;
        int r1 = b1 + 20;// byte(小类型) + int (大类型) 运算的数据类型为大类型.