【JAVA】数据类型与变量

本章目录

        1.字面常量

        2.数据类型

        3.变量

1.字面常量

常量即程序运行期间，固定不变的量称为常量，比如：一个礼拜七天，一年12个月等。

int a = 10; 
short sh = 9;
char ch = 'a';
String str = "hello";

public class Demo{  
  public static void main(String[] args){  

       System.Out.println("hello world!");  
       System.Out.println(100);   
       System.Out.println(3.14);   
       System.Out.println('A');    
       System.Out.println(true);    
       System.Out.println(false);  
 }

}

其中：100、3.14、‘A’、true/false都是常量，将其称为字面常量。

字面常量的分类

1. 字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。

2. 整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000

3. 浮点数常量：程序中直接写的小数，比如：3.14、0.49

4. 字符常量：由 单引号 括起来的当个字符，比如：‘A’、‘1’

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

6. 空常量：null(后面了讲)

注意：字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型。

---

2.数据类型

在Java中数据类型主要分为两类：基本数据类型和引用数据类型。

基本数据类型有四类八种：

1. 四类：整型、浮点型、字符型以及布尔型

2. 八种：

在java中的数据类型分为两种

1.基本数据类型：以上【8种】

2.引用数据类型（姑且不谈）

注意：

1.不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节

2.整形和浮点型都是带有符号的

3.整型默认为int型，浮点型默认为double

4.字符串属于引用类型

什么是字节?

字节是计算机中表示空间大小的基本单位.

计算机使用二进制表示数据. 我们认为 8 个二进制位(bit) 为一个字节(Byte).

我们平时的计算机为 8GB 内存, 意思是 8G 个字节.

其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.

所以 8GB 相当于 80 多亿个字节.

了解一下冯诺依曼体系

---

3.变量

3.1变量概念：

在程序中，除了有始终不变的常量外，有些内容可能会经常改变，比如：人的年龄、身高、成绩分数、数学函数的计算结果等，对于这些经常改变的内容，在Java程序中，称为变量。而数据类型就是用来定义不同种类变量的。

 

变量简单来说：相当于一个箱子，这个箱子有大有小，可以存放东西

在细究基本数据类型前再介绍一下包装类：每个基本数据类型，都会对应一个类类型，这个类类型就是包装类。

---

现在开始分别介绍8种基本数据类型

1.整形 int

    /**
     *整型：
     * 1.大小： 4个字节
     * 2.在java中，int没有所谓的无符号整数，所以，int既能表示正数，又能表示负数
     * @param args
     */
    public static void main1(String[] args) {
        //数据类型  变量名 = 数值
        int a = 10;
        System.out.println(a);
        System.out.println("最大值：" + Integer.MAX_VALUE);
        System.out.println("最小值：" + Integer.MIN_VALUE);

        /*int b;
        System.out.println(b);//err
        //局部变量不初始化，会报错*/
    }

int 的包装类是Integer，Integer通俗来说就是int的大写

 

 注意事项：

1. int不论在何种系统下都是4个字节

2. 推荐使用方式一定义，如果没有合适的初始值，可以设置为0

3. 在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出

4. 变量在使用之前必须要赋初值，否则编译报错

5. int的包装类型为 Integer

---

2.长整型 long

    /**
     * 长整形 long
     * 1.大小  8个字节  范围： -2^63 ~ 2^63-1
     * @param args
     */
    public static void main(String[] args) {
        long a = 10L;//在数值后加上L
        System.out.println(a);
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
    }

 

 注意事项：

1. 长整型变量的初始值后加L或者l，推荐加L

2. 长整型不论在那个系统下都占8个字节

3. 长整型的表示范围为： -2^63 ~ 2^63-1

4. long的包装类型为Long

---

3.短整型变量 short

    /**
     * 短整型 short
     * 1.大小：2个字节-》16位-》15  范围： -2^15 ~ 2^15-1
     * 2.没有无符号的，只有有符号的
     * 3.包装类-》 Short
     * @param args
     */
    public static void main(String[] args) {
        short sh = 20;
        System.out.println(sh);
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
    }

 注意事项：

1. short在任何系统下都占2个字节

2. short的表示范围为：-32768 ~ 32767

3. 使用时注意不要超过范围(一般使用比较少)

4. short的包装类型为Short

---

4.字节型变量 byte（C语言中没有的）

    /**
     * 字节数据类型 - byte
     * 1.大小：1个字节 -》8位-》7位  范围： -2^7 ~ 2^7-1
     * @param args
     */
    public static void main(String[] args) {
        byte b = 10;
        System.out.println(b);

       // byte b1 = 130;//字面值常量超出范围 - err

        /*byte b2 = 127;
        byte b3 = b2 + 1;//这行代码的错误是，实现了整型运算，4个字节byte无法接收*/

        byte b2 = 127;
        byte b3 = (byte)(b2+1);//强制类型转换 -128
        System.out.println(b3);
    }

上述代码段中一行错误代码： byte a = 130;//err

错误解释：在创建局部变量的时候，编译器会自动进行检查你赋值的字面值常量是不是超出当前数据能够表示的数据范围。

byte的最大值位127，赋值130显然超出byte的范围，故出错。

以此类推->其他数据类型也是这样规定的

 

下面我们看两个代码

byte a = 127;
byte b = a + 1;//err

在编译器中这样写会报错，因为a + 1中的1默认是一个整形，所以a+1会出现整型提升，变成一个4字节的整型，而b变量是两个字节，无法存下a+1这个整型；

如果想避免报错，可以进行强制类型转换：

byte a = 127;
byte b = (byte)(a+1); 

但我们思考一下：

Q1：  a+1 不是等于128么？这已经超出了byte的范围，为何程序不报错？

解释：因为a是变量，不是字面值常量，只有写成byte b = 130；程序会报错，130就叫做字面值常量，与a不同，变量只能在程序运行时程序才会知道a是多大。

Q2：既然a+1 = 128，那b到底是多大

解释：

 答案是-128，而不是128；

我们知道byte最大是127，最小是-128，如果超过了127，这数值会如图数值转动，简单来说头是-128，尾是127，当超过127后，会回到开头的数值

所以127+1 不显示128，而是跳回了开头显示-128，如果127+2，则显示-127....以此类推

总结：不要赋超过数据类型范围的值

注意事项：

1. byte在任何系统下都占1个字节

2. byte的范围是：-128 ~ 127

3. 字节的包装类型为Byte

思考：byte、short、int、long都可以定义整形变量，为什么要给出4中不同类型呢？

an：那种类型合适就有那种，跟买衣服选尺码一个道理

---

 5.浮点型变量之双精度浮点型 double

    //打印小数-》双精度 浮点型 double  8字节
public class TestDemo{
    public static void main(String[] args) {
        double a = 12.5;
        System.out.println(a);
        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);

        long b =10;
        System.out.println(b);

        int c = 1;
        int d = 2;
        //double d = 2.0 ;
        System.out.println(c/d);//0

        double e = 1.1;//8个字节
        System.out.println(e * e);//1.2100000000000002  double是有精度的
        //写项目遇到小数，建议使用double；
        //小数没有精确值
    }
}

 代码一解释：要计算小数，其中必须要有浮点型

代码二解释：在计算机当中，小数是没有精确值的，它只能计算到小数点后xxx位

---

6.浮点型变量之单精度浮点型 float

    public static void main6(String[] args) {
        float f = 12.5f;
        System.out.println(f);
    }

float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float. float的包装类型为Float。

---

7.字符型 char

public class TestDemo{

    /**
     * 字符型 char 不是整数类型
     * 1.  2个字节  不能表示负数
     * 范围：0 ~ 65535
     * 2.在java中，使用的是Unicode字符集【Ascii是Unicode的子集】
     * Unicode字符集：包含了很多语言-》中文，拉丁文……
     * Ascii码表：只包含英文相关的
     * 3.包装类：Character    
     * @param args
     */
    public static void main(String[] args) {
        char ch = 'a';
        char ch1 = '秋';//中文两个字节，char可以存中文
        char ch2 = 97;//显示的是Unicode字符
        System.out.println(ch2);
    
    }
}

 注意事项:

1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.

2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文.

3. char的包装类型为Character

---

8.布尔类型 boolean（c语言中没有的）

布尔类型常用来表示真假，在现实生活中也是经常出现的，比如：听说xxx同学买彩票中了一个亿...，听到后估计大部分人第一反应就是：我x，真的假的？

    //布尔类型
    //1，在java中  布尔类型没有明确大小
    //2.在java中   布尔类型  只有两个取值  true  和  false
    //3.在java中  没有所谓的 0是假  非0为真  与C语言不同
    //java真只有 true ， 假只有 false
    //4。Boolean
    public static void main(String[] args) {
        boolean flg = true;
        System.out.println(flg);
        if(flg){
            System.out.println("hehe");
        }
       /* if(1)
        {
            //....
        }*/
    }

注意事项：

1. boolean 类型的变量只有两种取值, true 表示真, false 表示假.

2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.

3.布尔类型没有明确的大小

4.包装类：Boolean

---

8种数据类型总结：

 

---

当我们介绍完Java的基本数据类型，那我们接下来要介绍的数据类型转换固然重要

类型转换（2种）：

        1.自动类型转换（隐式类型转换）

        2.强制类型转换（显示类型转换）

    

1.自动类型转换

        //自动类型转换
        int a = 10;
        long b = 100L;
        b = a;//隐式类型转换->【小类型赋给大类型】

2.强制类型转换

 当我们把b赋给a，大类型赋给小类型，会出错，因此我们要强制类型转换

        int a = 10;
        long b = 100L;
        a = （int）b;//强制类型转换
        System.out.println(a);
    }

---

接下来看看两个错误代码

代码1：

 

 我们可以强制类型转换避免报错

 但是当我们强制类型转换后，会出现丢失数据的情况，所以当我们要强制类型转换时要对其负责

代码2：

 

 a与b分别被提升为整型进行运算，结果也为4个字节，无法存到一个字节的byte c ，所以要对其进行强制类型转换

 

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

注意事项：

1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型

2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失

3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查

4. 强制类型转换不一定能成功，不相干的类型不能互相转换

---

类型提升

1.小于4个字节的数据类型进行运算，会被提升为整型进行运算

2.当两个不同的数据类型进行运算，小类型会被提升为大类型进行运算

1. int与long之间：int会被提升为long

 2. byte与byte的运算

 a+b会被提升为整型进行运算，但byte不存整型，所以要强制类型转换

结论:

byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.

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

 

【类型提升小结:】

1. 不同类型的数据混合运算, 范围小的会提升成范围大的.

2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算. 

3.提升为了提高运算效率

---

小插曲：