数据类型

数据类型: Java是一门强语言类型,Java对每一种数据都提供了对应的类型

Java数据类型分为基本数据类型和引用类型

基本数据类型

常量: 在程序的执行过程中,其值不会发生改变的量

    常量的分类:
    字面值常量
            整型常量
                    二进制 由0,1组成,由0b开头 0101010101
                    八进制 由0~7组成,由0开头
                    十进制 由0~9组成,默认就是十进制
                    十六进制 由0~9,A,B,C,D,E,F 组成,由0x开头
            小数常量
                    0.2F float类型的小数常量
                    0.2D double类型的小数常量
                  
            布尔常量
                    只能取两个值
                    true false
            字符常量
                                     
                    什么是字符?字符的本质是什么？数字 整数   a 97 1                         
                    什么是字节?字节本质是什么? 数字 数据传输的最基本单位
                    a 1 张 换行 制表符 都是字符 65535  
                   
                    字符在计算机中存储本质还是数字
                   
                    1byte = 8bit 
                    1kb = 1024byte
                    1mb = 1024kb
                    1gb = 1024mb
                    1tb = 1024gb
                   
                    1bit 能够表示多少种状态 2种  0 1  
                    2bit 4  10 01 11 00
                    3bit 8  
                    8bit 256
                    16bit 65536
                   
                    Java使用2个字节表示一个字符
                    0000 0000 0000 0000 65536
                   
                    一般2个字节表示一个汉字GBK
                   
                    1.字符常量由 '' 包裹
                    2.里面只能够有一个字符
                    3.转义字符可以由两个字符组成,第一个是\
                   
                    记住常见的字符编码:
                            a 97  b 98
                            A 65  B
                            0 48
                           
                            \t 制表
                            \n 换行
                            \r\n 换行
                            \'
                            \\
                            \"
                           
            字符串常量
                    1.由双引号包裹
                    2.里面可以有一个字符也可以有多个字符
                    3.字符串里面可以是空串
            null常量
                    表示的是引用类型的常量
                   
            自定义常量                 
    注意:
            1.System.out.println();输出的都是数值的十进制
            2.默认整型常量默认是 int 类型
            3.默认小数类型就是 double 类型
            4.字符的数量不会超过65535
            5.windows系统的换行符是 \r\n \n \R
            6.计算机最多能表示36进制
                  0-9+a-z =10+26=36进制

变量: 在程序的执行过程当中,其值可以发生改变的量,类似于数学的未知数X

    变量的内存分配
            int x = 10;
            int x; // 1.声明
            x = 10; // 2.赋值
            System.out.println(x); // 3.使用
   
    数据类型: Java是一门强语言类型,Java对每一种数据都提供了对应的类型
                      比如JavaScript就是弱语言类型
                      int x = 10; double d = 20;
                      var x = 10; var d = 20.5;
                          
    变量的定义:
            变量的三要素:
                    1.声明
                    2.赋值
                    3.使用
            注意:
                    1.变量一定要先声明再赋值再使用
                    2.变量不能够重复定义
                    3.变量不能够连续定义 int a = b = c = 10;
                    4.建议一行只写一条语句

举例代码如下

public class VariableDemo {
        public static void main(String[] args){
                // 变量的定义
                // int i; // 变量的声明
                // i = 100; // 变量的赋值
                // System.out.println(i);
               
                int i = 100;
                System.out.println(i);
               
                int j = 200;
                System.out.println(j);
               
                // int a = b = c = 10;
                // System.out.println(a);
               
                // int a,b,c = 10;
                /*
                        int a;
                        int b;
                        int c = 10;
                */
                int a = 10, b = 10, c = 10;
                System.out.println(a);
                System.out.println(b);
                System.out.println(c);
               
                int x = 10;
                int y = 20;
                int z = 30;
               
                byte by = 15;
                System.out.println(by);
               
                // byte by1 = 128;
                // System.out.println(by);
               
                // short s = 32768;
                // System.out.println(s);
                                 // 2147483648
                long l = 1111111111111111L;
                System.out.println(l);
               
                float f = 2.5F;
                System.out.println(f);
               
                char ch = 'a';
                System.out.println(ch);
               
                char ch2 = 97;
                System.out.println(ch2);
               
                char ch3 = '\t';
                System.out.println((int)ch3);
               
                String ss = "今晚打老虎dada";
                System.out.println(ss);
        }
}

数据类型转换

类型转换的依据: 取决于数据的取值范围,而不是字节数
byte -> short -> int -> long -> float -> double
char ->
注意:
1.char和byte/short有交集关系,而没有子集关系
2.其他的都满足子集关系
3.boolean不能参与类型转换
数据取值范围图

类型转换特点

    1.自动类型转换
            将小类型赋值给大类型,系统会自动将小类型转换成大类型,不会出现任何问题
   
    2.强制类型转换
            将大类型赋值给小类型,可能会出现如下问题
            格式:强制类型转换格式：目标类型 变量名=(目标类型)(被转换的数据);
            	造成的影响：
                    a.精度的丢失
                    b.数据的溢出   byte by = (byte)129;
                                              System.out.println(by); // 128
           
    3.byte/short/char特例
   
    4.byte/short 和 char 之间参与转换,都需要强制类型转换
   
    5.表达式类型提升: 类型会自动向高类型转换
   
    6.byte short char 之间参与运算,底层都会转换成int类型来计算
   
    7.boolean类型不能够参与类型转换
   
    8.字符串和任何类型进行加法运算都是拼接操作仍是字符串类型,在JavaScript中可以进行其他运算
   
    9.变量计算和常量计算问题
            a.常量计算,编译器会自动帮我们计算结果
            b.变量计算,编译器无法帮我们识别类型和结果
           
    10.交集范围关系的两种类型之间相互转换都需要强制类型转换

举例代码如下

public class DataTypeConvertDemo {
        public static void main(String[] args){
               
                // 1.自动类型转换
                byte b = 10;
                int i = b;
               
                // 2.强制类型转换
                int i1 = 30;
                // 目标类型 变量名=(目标类型)(被转换的数据);
                byte b2 = (byte)i1;
                System.out.println(b2);
               
                float f = (float)2.5;//2.5为double类型
                System.out.println(f);
               
                float f2 = 3.5F;
                int i2 = (int)f2;
                System.out.println(i2);
               
                byte by = (byte)129;
                System.out.println(by); // 128
               
                // 3.byte/short特例 右边为整型常量默认为int类型，左边是byte类型，属于大类型赋值给小类型，但是由于30属于-129-128之间，所以这里不需要强转。
                byte by2 = 30;
                System.out.println(by2);
               
                short s = (short)32768;
                System.out.println(s);  -32678----32767会出现内容溢出
               
                // 5.表达式类型提升: 类型会自动向高类型转换
                int i3 = 100;
                float f3 = 2.5F;
                int i4 = (int)(i3 + f3);//i3+f3的结果是float类型，需作强转
                System.out.println(i4);
               
                System.out.println((float)1/2);
               
                // 6.byte short char 之间参与运算,底层都会转换成int类型来计算
                byte by3 = 97;
                char ch = (char)(by3 + 1);
                System.out.println(ch);
               
                byte by4 = 97;
                short s2 = 1;
                short s3 = (short)(by4 + s2);
                System.out.println(s3);
               
                char ch2 = 'a';
                byte by5 = (byte)ch2;
                System.out.println(by5);
               
                byte by6 = 97;
                char ch3 = (char)by6;
                System.out.println(ch3);
               
                // 8.字符串和任何类型进行加法运算都是拼接操作,在JavaScript中可以进行其他运算
                System.out.println(2 + 2 + "22" + 2 + 2); // 4 + "22"  "422" +2  "4222" + 2     42222
               
                /*
                        9.变量计算和常量计算问题
                */常量内部自动计算
                /*byte by7 = 10;
                short s4 = 5;
                short s5 = by7 + s4;
                System.out.println(s5);*/
               
       
                /*short s5 = 15;
                System.out.println(s5);*/
               
                byte by8 = 126 + 1;
                System.out.println(by8);
               
               
        }
}