【Java】数据类型与变量详解！！！

目录

字面常量

定义：程序无论何时运行，都是固定不变的量

字面常量分类：

数据类型

数据范围 

变量

定义：存放临时的数据。会发生改变的量。

语法格式

初始化

分类

整型变量

长整型变量

短整型变量

字节型变量

浮点型变量

单精度浮点型

双精度浮点型

字符型变量

布尔型变量

类型转换

强制类型转换（显式）

不同类型数据的运算

相同类型数据的运算

byte与byte之间运算

字符型 

字符串

字面常量和变量

---

字面常量

定义：程序无论何时运行，都是固定不变的量

字面常量分类：

1.空常量：null；

2.整形常量:直接写的数字（没有小数）；

3.浮点数常量：含有小数的数字；

4.布尔常量：只有两种true和false；

5.字符常量：由"单引号括起来的单个字符；

6.字符串常量：由“”双引号括起来的字符。

public class test {
    public static void main(String[] args) {
        System.out.println(123);//整形常量
        System.out.println(1.12);//浮点数常量
        System.out.println('a');//字符常量
        System.out.println(true);//布尔常量
        System.out.println("abc");//字符串常量
    }
}

数据类型

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

基本数据类型分为四类（共8种）：整型，浮点型，字符型，布尔型

数据范围 

• 字节是计算机中表示空间的基本单位；
• 字节单位：bit，Byte，KB，MB，GB，TB

其中8bit=1Byte 1KB=1024Byte 1MB=1024KB 1GB=1024MB

• 不论在16位系统还是在32位系统，他们所占字节大小都不变；
• 整形和浮点型都带符号；
• 整形默认为int，浮点型默认区double；
• 字符串属于引用类型；

变量

定义：存放临时的数据。会发生改变的量。

语法格式

数据类型  变量名=初始值；

public class test {
    public static void main(String[] args) {
        int a=10;
        System.out.println(a);//a=10
        a=100;
        System.out.println(a);//a=100
    }

 a是变量，它的值是可以发生改变的；

初始化

public class test {
    public static void main(String[] args) {
        //1.定义时初始化
        int a=10;
        System.out.println(a);
        //2.定义后初始化
        int b;
        b=100;
        System.out.println(b);
     
    }

• 使用前，变量一定要进行初始化，否则编译器报错；
• 初始化必须为整数，不能带小数，否则编译器报错；
• 如果没有合适的初始值可以设置为0，不可以设置为null。

分类

整型变量

public class test {
    public static void main(String[] args) {
        int c=0;
        System.out.println(c);
        //整型范围
        System.out.println(Integer.MIN_VALUE);//最小值：-2147483648
        System.out.println(Integer.MAX_VALUE);//最大值：2147483647
    }

• 变量的初始值不能超过int的表示范围，否则编译报错；
• integer为int的包装类型。

长整型变量

public static void main(String[] args) {
        long a=10;
       //为了区分int和long,一般建议在long类型变量的初始值后面加上L或者l，最后是L，l与1相似
        long b=10l;
        long c=10L;
        //长整型范围
        System.out.println(Long.MIN_VALUE);//最大值：-9223372036854775808
        System.out.println(Long.MAX_VALUE);//最大值：9223372036854775807
    }

• Long为long的包装类型。

短整型变量

public class test {
    public static void main(String[] args) {
        short a=1;
        //短整型范围：
        System.out.println(Short.MIN_VALUE);//最小值：-32768
        System.out.println(Short.MAX_VALUE);//最大值：32767
    }

• Short为short的包装类型。

字节型变量

public class test {
    public static void main(String[] args) {
        byte a=1;
        //字节型范围
        System.out.println(Byte.MIN_VALUE);//最小值：-128
        System.out.println(Byte.MAX_VALUE);//最大值： 127
    }

• Short为short的包装类型

浮点型变量

单精度浮点型

    public static void main(String[] args) {
        float a=1f;
        float l=1.0F;
        float b=0.1f;
        float f=0.001f;
        float d=0.0001f;
        float s=0.00000123f;
        float h=0.12345f;
        float g=0.123456789f;
        float k=1.00000f;
        System.out.println(a);//1.0
        System.out.println(l);//1.0
        System.out.println(b);//0.1
        System.out.println(f);//0.001
        System.out.println(d);//1.0E-4 科学计数法表示
        System.out.println(s);//1.23E-6 科学计数法表示
        System.out.println(h);//0.12345
        System.out.println(g);//0.12345679
        System.out.println(k);//1.0 保留一位小数，省略剩下的0
        //单精度浮点型范围
        System.out.println(Float.MIN_VALUE);//最小值：1.4E-45
        System.out.println(Float.MAX_VALUE);//最大值：3.4028235E38
    }

• 单精度浮点型变量的赋值需要加上f或F；
• 单精度浮点型在及时初始化没有小数输出时，也会带有1位小数；
• 单精度浮点型的赋值时，小数点后有多个0，会使用科学计数法进行输出
• 若小数点尾数都为0，那么将舍去，至少保留1位小数
• Float为float的包装类型

双精度浮点型

public class test {
    public static void main9(String[] args) {
        double a=0;
        double b=1.0;
        double c=0.1;
        double d=0.00000001;
        double f=0.1234567;
        double h=0.1d;
        double k=0.00000;
        double l=1.00000;
        System.out.println(a);//0.0
        System.out.println(b);//1.0
        System.out.println(c);//0.1
        System.out.println(d);//1.0E-8
        System.out.println(f);//0.1234567
        System.out.println(h);//0.1
        System.out.println(k);//0.0
        System.out.println(l);//1.0
        //双精度浮点型的计算
        double a=1;
        double b=20;
        System.out.println(a/b);//0.05
        double c=1.0;
        double d=20.0;
        System.out.println(c/d);//0.05
        double f=1.1;
        System.out.println(f*f);//1.2100000000000002
        //双精度浮点型范围
        System.out.println(Double.MIN_VALUE);//最小值：1.4E-45
        System.out.println(Double.MAX_VALUE);//最大值：3.4028235E38
    }

•  双精度浮点型的初始化赋值后面可加d或D也可不加；
• 双精度浮点型赋值时，小数点后有多个0，会使用科学计数法来输出；
• 若小数点尾数都为0，那么将舍去，至少保留1位小数；
• Double为double的包装类型；
• double类型的内存布局遵守IEEE 754 标准（和C语言一样），尝试使用有限的内存空间表示无限的小数，势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

字符型变量

  public static void main11(String[] args) {
        char a='1';
        char b='a';
        char c='啊';
        System.out.println(a);//1
        System.out.println(b);//a
        System.out.println(c);//啊
        public static void main(String[] args) {
        //字符型范围
        System.out.println((int)Character.MIN_VALUE);//最小值：0
        System.out.println((int)Character.MAX_VALUE);//最大值：65535
    }
    }

• 字符型变量的初始化只能是‘’单引号，不能是""双引号，""双引号是字符串类型，字符串是引用类型，不是数据类型；
• 字符型变量的初始化中只能有单个字符，不能有多个字符；

布尔型变量

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

• boolean只有true和false，不是0和1；
• Boolean为boolean的包装类型。

类型转换

在Java中，当参与运算数据类型不一样时，会进行类型转换。

Java类型转换分为两类：自动类型转换（隐式）和强制类型转换（显示）。

自动类型转换（隐式）

定义：代码不需要靖任何处理，在代码编译时，编译器会自动处理。

特点：数据范围由小的转换为大的会自动进行。

public class test {
    public static void main(String[] args) {
        int a=1;
        short d=1;
        double b=1;
        float c=3.14f;
        a=d;
        System.out.println(a);//1
        b=c;
        System.out.println(b);//3.140000104904175
    }

• 当数据范围小的数据赋值给数据范围大的数据，在赋值时，编译器会自动将小范围的数据自动升为大范围的数据，但有时候会出现数据丢失的情况

强制类型转换（显式）

定义：当进行操作时，代码需要经过一定的格式处理，不能自动完成。

特点：数据由大范围强制转换为小范围数据

public class test {
    public static void main(String[] args) {
        int a=10;
        byte b=2;
        //大范围转为小范围
        b=(byte)a;//int->byte
        System.out.println(b);//10
        short d=4;
        d=(short)a;//int->short
        System.out.println(d);//10
        long c=12;
        a=(int)c;//long->int
        System.out.println(a);//12
        double g=12.5;
        float h=11.2f;
        h=(float)g;//double->float
        System.out.println(h);//12.5
        //小范围转为大范围
        g=h;//float->double
        a=b;//byte->int
        System.out.println(g);//12.5
        System.out.println(a);//10
        g=(double)h;//float->double
        a=(int)b;//byte->int
        System.out.println(g);//12.5
        System.out.println(a);//10
    }

• 强制类型可以将小范围转换为大范围，也可以将小范围转换为大范围，但由于编译器在小范围转换为大范围时会自动进行类型转换，所以直接赋值即可；但将大范围转换为小范围需要通过强制类型转换
• 强制类型的转换，有时候可能会精度丢失
• boolean不能与其他类型进行强制转换，否则编译器会报错；
• 强制类型转换不一定会成功，不相干的类型不能相互转换

不同类型数据的运算

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

public class test2 {
    public static void main(String[] args) {
        int a=1;
        byte b=2;
        int k=a+b;//不能为byte k=a+b，否则编译器报错
        System.out.println(a+b);//3
        System.out.println(a-b);//-1
        System.out.println(a*b);//2
        System.out.println(a/b);//0，以整形的形式去掉小数点
        System.out.println(b/a);//2
        int f=4;
        double g=20.0;//20与20.0的结果相同
        double l=f+g;//同样，l类型不能为int，编译器会进行报错
        System.out.println(f+g);//24.0
        System.out.println(f-g);//-16.0
        System.out.println(f*g);//80.0
        System.out.println(f/g);//0.2
        System.out.println(g/f);//5.0
    }
}

• 不同数据类型的计算，计算结果的数值与平常加减乘除一致；
• 不同的是，不同数据类型的计算，会将范围小数据的类型转换为范围大的数据，最终得出的结果是大范围的数据类型；
• 布尔类型的结果只有true和false，不能与其他包括自己进行计算。

相同类型数据的运算

    public static void main(String[] args) {
        double g=1.0;
        double d=2.0;
        double h=g+d;
        System.out.println(h);//3.0
        byte a=1;
        byte b=2;
        int c=(byte)(a+b);
        int k=a+b;//不能书写成byte k=a+b,编译器会报错
        //a+b的运算会将a和b的类型先提升为int在进行计算，所以得出的几个类型是int而不是byte
        System.out.println(c);//3
        System.out.println(k);//3
        short i=1;
        short j=2;
        int p=(short)(i+j);
        int l=i+j;//同理，不能书写成short l=i+j，编译器会报错
        //i+j的运算会将i和j的类型先提升为int在进行计算，所以得出的几个类型是int而不是short
        System.out.println(p);//3
        System.out.println(l);//3
    }

• byte和short的同类型运算会将其类型都提升为int在进行计算 

•  为什么byte和short类型的数据会先提升为int在计算，而其他不会呢？

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

byte与byte之间运算

byte的范围是-127~128，如果byte与byte的两个数在不超出其范围的情况下相加的超出其范围的结果会是什么？

public class test2 {
    public static void main(String[] args) {
        byte a=125;
        byte b=4;
        int c=a+b;
        int d=(byte)(a+b);
        System.out.println(a+b);//129
        System.out.println(c);//129
        //以上两个都是将byte类型提升为int类型得出的结果
        System.out.println(d);//-127
        // d是将a+b的类型在提升为int的情况下强制类型转化为byte的情况下
        // 因为byte的范围是-127~128；相对于一个圆，128下一个就是-127
    }

• 如果byte被提升为int那么使用int的范围来计算
• 如果byte使用byte的范围来计算，那么结果只能在这个范围内 

字符型 

public static void main(String[] args) {
        char a='1';
        char b='2';
        int h=a+b;
        int k=(char)(a+b);
        System.out.println(a+b);//99
        System.out.println(h);//99
        System.out.println(k);//99
        char c ='3';
        char d ='5';
        int w=c+d;
        int r=(char)(c+d);
        System.out.println(c+d);//104
        System.out.println(w);//104
        System.out.println(r);//104
        char q='a';
        char t='b';
        int y=q+t;
        int x=(char)(q+t);
        System.out.println(q+t);//195
        System.out.println(y);//195
        System.out.println(x);//195
        char j='啊';
        char s='哦';
        System.out.println(j+s);//43568
    }

 

• 字符型计算使用的ascll值来计算

字符串

    public static void main(String[] args) {
        String s="123";
        String b="abc";
        //字符串运算:只能相加不能进行其他运算
        //相加：字符串连接
        String j=s+b;
        System.out.println(s+b);//123abc
        System.out.println(j);//123abc

        //字符串的转型
        int a=Integer.parseInt(s);//123 将字符串转为整形
        //int c=Integer.parseInt(b); 不可以这样转换 字符串内容不为数字时，无法将字符串转为整形
        float d=Float.parseFloat(s);//123.0 将字符串转为浮点型
        System.out.println(a);
        System.out.println(d);
    }

•  字符串属于引用类型，不属于数据类型；
• java中，字符串没有所谓的以\0结尾；
• 字符串只能进行相加，结果是字符串的连接；
• 字符串的转型只能是数字的时候才能转型，否则编译器的结果报错；
• 转型格式为，转型类型的包装.parse+数据类型（字符型变量名）；

字面常量和变量

• 变量的值是在运行时确定，常量的值是在遍历是确定；
• final修饰变量变为常量。