Java-数据类型与变量

已于 2023-09-24 19:25:17 修改
阅读量140 收藏 20
点赞数 18
分类专栏： JavaSE 文章标签： java 开发语言
于 2023-09-24 19:19:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68440665/article/details/133070941
版权

文章目录

前言：

本篇主要讲Java的数据类型，变量占据大半篇幅，然后简单介绍一下String类型。

一、数据类型

在Java中，数据类型可以分为两类：基本数据类型和引用数据类型。

  1. 基本数据类型有四类：

整型、浮点型、字符型、布尔型

  1. 基本数据类型共有八种：

byte、short、int、long、float、double、char和boolean。

以下是8种基本数据类型的一些信息：

在这里插入图片描述

  • 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
  • 整形和浮点型都是带有符号的
  • 整型默认为int型，浮点型默认为double
  • 字符串属于引用类型，不属于基本数据类型

字节（Byte）是计算机存储单位的基本单位之一，它是信息处理和存储的最小单元。
一个字节由8个二进制位 （bit）组成。
也就是 1 Byte = 8 bit

我们平常说手机有128GB 内存，意思是 128G 个字节
其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB =1024 MB.
所以 128GB 相当于 1280 多亿个字节

二、常量

常量是在程序中固定不变的值，也可以说是一个不可更改的变量。

它们是在程序执行期间始终保持不变的，无法被修改或重新赋值。

在Java中，常量可以使用final关键字进行声明。具体的常量类型可以是字符串、整数、浮点数、字符、布尔值等。

代码如下：

public class Example {
    public static final String MESSAGE = "Hello, World!";
    public static final int MAX_VALUE = 100;
    public static final double PI = 3.14159;
    public static final char GRADE = 'A';
    public static final boolean FLAG = true;
    public static final String NULL_VALUE = null;

    public static void main(String[] args) {
        System.out.println("字符串常量：" + MESSAGE);
        System.out.println("整数常量：" + MAX_VALUE);
        System.out.println("浮点数常量：" + PI);
        System.out.println("字符常量：" + GRADE);
        System.out.println("布尔常量：" + FLAG);
        System.out.println("空常量：" + NULL_VALUE);
    }
}

效果图：

在这里插入图片描述

三、变量

变量是程序中用于存储和表示数据的一个名称。它代表着内存中的一个位置，可以在程序执行过程中存储不同的值。

3.1 语法格式

在 Java 中，定义变量的语法格式如下：

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

代码如下：

    int age = 25;//声明整数类型的变量 age 并赋初值为 25
    double weight = 68.5;//声明浮点数类型的变量 weight 并赋初值为 68.5
    char grade = 'A';//声明字符类型的变量 grade 并赋初值为 'A'
    boolean isReady = true;// 声明布尔类型的变量 isReady 并赋初值为 true
    
    //下面两种类型的变量后面的博客会具体介绍
    String name = "John";//声明字符串类型的变量 name 并赋初值为 "John"
    int[] numbers = {1, 2, 3, 4, 5};//声明数组类型的变量 numbers 并初始化一个整型数组
    
        System.out.println(age);
        System.out.println(weight);
        System.out.println(grade);
        System.out.println(isReady);
        System.out.println(name);
        System.out.println(numbers);

效果图：
在这里插入图片描述

前五个输出都可以理解， 那最后一个是什么？ 为什么输出的不是数组中的元素呢？

在 Java 中，输出一个数组会产生一个地址（或称为引用）。
这是因为数组在 Java中是对象，而不是原始数据类型。
当你将一个数组赋值给变量或进行输出时，实际上是将数组的引用传递给变量或输出语句。

这里的 [I@16b98e56 是数组的地址（引用），它指向内存中存储数组实际元素的位置。
可以将其视为数组在内存中的标识。

要注意的是，默认的 toString() 方法会将数组输出为地址形式，而不是逐个打印每个元素。
如果希望按格式输出数组中的元素，可以使用循环遍历数组，并逐个打印元素或构建自定义的输出方法。

代码如下：

        int age = 25;
        age = 100; // age是变量，age中的值是可以修改的
        System.out.println(age);
         
         // 注意：在一行可以定义多个相同类型的变量
        int num1 = 1, num2 = 2, num3 = 3;
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);

3.2 整型变量

3.2.1 整型变量

代码如下：

        // 方式一：在定义时给出初始值
        int num1 = 10;
        System.out.println(num1);

        // 方式二：在定义时没有给初始值，但使用前必须设置初值
        int num2;
        num2 = 10;
        System.out.println(num2);

        // 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
        int num3;
        System.out.println(num3);//编译时报错，未赋予初始值不能使用
        num3 = 100;

        // int型变量所能表示的范围：
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
        // 这里输出了int类型最大、最小值
    
        
       // 注意：在定义int性变量时，所赋值不能超过int的范围
        int num4 = 12345678901234; // 编译时报错，初值超过了int的范围

  1. Integer 叫包装类，是一种用于将基本数据类型转换为对象的类。 它提供了一些额外的方法和功能 这里暂且理解为int的plus版，要更加强大。

  2. 除了int和char类型的包装类是Integer和Character，其余的包装类只需要变量类型首字母大写即可

输出结果：

 System.out.println(Integer.MIN_VALUE);
 System.out.println(Integer.MAX_VALUE);
 
以上两行代码的输出结果为：  
 -2147483648   
 2147483647

注意：

  1. int不论在何种系统下都是4个字节
  2. 推荐使用方式一定义，如果没有合适的初始值，可以设置为0
  3. 在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出（取值范围：-2^31 到 2 ^31 - 1）
  4. 变量在使用之前必须要赋初值，否则编译报错
  5. int的包装类型为 Integer

3.2.2 长整型变量

        long num = 10L;//为了区分int和long类型，一般建议在long类型变量的初始值之后加L或l
        long num2 = 10l; // 一般更加以加大写L，因为小写l与1不好区分

        System.out.println(num);
        
        // long型变量所能表示的范围：
        System.out.println(Long.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);

输出结果：

10
-9223372036854775808
9223372036854775807

注意：

  1. 长整型不论在那个系统下都占8个字节
  2. 长整型的表示范围为：-2^63 到 2 ^63 - 1
  3. long的包装类型为Long

3.2.3 短整型变量

代码如下：

        short sh = 32768;//代码报错 
        //这里超过了short类型的范围会直接报错 
        //这里体现了java的严谨性
        System.out.println(sh);
        
        // short型变量所能表示的范围：
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);

效果图：

在这里插入图片描述
因为 32768 超出了short类型表示的范围，会被系统认为是int型

  • short 类型的取值范围为：-32768 ~ 32767
  • sh = 32768 > Short.MAX_VALUE=32767
    超出了取值范围 -》所以会报错

修改sh赋值后，输出结果：

代码如下：

        short sh = 32767;
        System.out.println(sh);
        
        // short型变量所能表示的范围：
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);

效果图：

在这里插入图片描述

注意：

  1. short在任何系统下都占2个字节
  2. short的表示范围为：-2^15 到 2 ^15 -1
  3. short的包装类型为Short

3.2.4 字节型变量

代码如下：

        byte num = 127;
        System.out.println(num);
        
        // byte型变量所能表示的范围：
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);

输出结果：

127
-128
127

注意：

  1. byte在任何系统下都占1个字节
  2. byte的范围是：-128 ~ 127
  3. 字节的包装类型为Byte

3.3 浮点型变量

3.3.1 双精度浮点型

代码如下：

        double num1 = 10.525;
        System.out.println(num1);
        
        //保留两位小数并换行，跟 C 语言中的用法相同
        System.out.printf("%.2f\n",num1);

输出结果：

10.525
10.53

代码如下：

        int a = 1;
        int b = 2;
        System.out.println(a/b);//输出不是0.5

输出结果：

0

在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分)。
如果想得到 0.5, 需要使用 double 类型计算。

代码如下：

       double a = 1.0;
       double b = 2.0;
       System.out.println(a / b);//输出为0.5

输出结果：

0.5

代码如下：

       double num2 = 1.1;
       System.out.println(num2*num2);
       //小数其实没有精确的 只能说 精确到某一位上

输出结果：

1.2100000000000002

注意：

  1. double在任何系统下都占8个字节
  2. double的包装类型为Double

3.3.2 单精度浮点型

代码如下：

        float num = 12.5f;
        //不加f 就默认num为double 就会报错 无法存储
        
        System.out.println(num);

注意：

  1. float 类型在 Java 中占四个字节,表示的数据精度范围较小,所以 一般用到浮点数都优先考虑 double, 不太推荐使用 float
  2. float的包装类型为Float。

3.4 字符型变量

代码如下：

        char ch1= '1';
        char ch2 = 'a';
        System.out.println(ch1);
        System.out.println(ch2);
        
        char ch3 = '加';
        System.out.println(ch3);

         //不能赋值负数,负数会报错。
        char ch4 = 97;//输出一个对应ASCII的字符
        System.out.println(ch4);

输出结果：

1
a
加
a

注意：

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

3.5 布尔型变量

代码如下：

       //JVM 没有明确boolean类型的大小
        boolean flg = true;
        System.out.println(flg);

        boolean flg2 = false;
        System.out.println(flg2);

输出结果：

true
false

注意：

  1. boolean 类型的变量只有两种取值, true 表示真, false 表示假。
  2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法。
  3. Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在Oracle公司的虚拟机实现中，boolean占1个字节。
  4. boolean的包装类型为Boolean。

3.6 类型转换

在Java中，类型转换是将一个数据类型的值转换为另一个数据类型的过程。
Java支持两种类型转换：隐式类型转换（自动类型转换）和显式类型转换（强制类型转换）。

代码如下：

        int a = 10;
        long b = 200L;
        b = a;// 可以通过编译
        a = b;// 编译失败

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

3.6.1 自动类型转换(隐式)

即代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点：数据范围小的转为数据范围大的时会自动进行。

        System.out.println(123); // 整型默认情况下是 int
        System.out.println(1.23); // 浮点型默认情况下是 double

        int a = 100;
        long b = 10L;
        b = a; // a 和 b 都是整形，a的范围小，b的范围大。当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
        a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全

        float f = 2.12F;
        double d = 3.12;
        d = f; // 编译器会将f转换为double，然后进行赋值
        f = d; //编译报错， double表示数据范围大，会有数据丢失，不安全

        byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
        byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失

3.6.2 强制类型转换(显式)

强制类型转换是指将一个高精度的数据类型转换为低精度的数据类型，这种转换需要使用强制类型转换操作符（）。强制类型转换可能导致数据丢失或溢出，因此在进行强制类型转换时需要谨慎，确保不会发生数据丢失的情况。

代码如下：

        int a = 10;
        long b = 100L;
        b = a; // int-->long，数据范围由小到大，隐式转换
        a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败

        float f = 3.12F;
        double d = 5.12;
        d = f; // float-->double，数据范围由小到大，隐式转换
        f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败

        a = d; // 报错，类型不兼容
        a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
        
        byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
        byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
        
        boolean flag = true;
        a = flag; // 编译失败：类型不兼容
        flag = a; // 编译失败：类型不兼容

注意：

  1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
  2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
  3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
  4. 强制类型转换不一定能成功，不相干的类型不能互相转换

3.7 类型提升

在不同类型的数据之间相互运算时，低精度的数据类型会被自动提升为高精度的数据类型，从而保证表达式的计算结果具有更高的精度。

代码如下：

        //int与long运算
        int a = 20;
        long b = 30;
        int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
        long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long

        //byte与byte运算
        byte a = 20;
        byte b = 30;
        byte c = a + b;// 编译报错
        System.out.println(c);

byte类型 输出结果：

在这里插入图片描述

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

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

正确的写法为：

        byte a = 20;
        byte b = 30;
        byte c = (byte)(a + b);//小于4个字节的在运算的时候，会提升为4个字节
        System.out.println(c);

小结：

  1. 不同类型的数据混合运算，范围小的会提升成范围大的。
  2. 对于 short ，byte 这种比 4 个字节小的类型,会先提升成 4 个字节的 int ， 再运算。

四、字符串类型

在Java中，字符串类型（String）用于表示一系列字符。字符串是不可变的，即一旦创建，就不能修改其内容。

代码如下：

public static void main(String[] args) {
        String s1 = "hello";
        String s2 = " everyone";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接
    }

输出结果：

hello
 everyone
hello everyone

字符串和整型数字之间可以进行转换：

1.int 转成 String

        int num = 10;
        String str1 = num + "";
        String str2 = String.valueOf(num);//valueOf 将其他数据类型的值转换为对应的包装类对象或字符串对象。
        System.out.println(str2);

输出结果：

//输出结果为10 其数据类型为String 而不是 int
10

2.String 转成 int

        String str = "111";
        int num = Integer.parseInt(str);//parseInt 将字符串解析为整数类型（int）
        System.out.println(num);

输出结果：

//输出结果为111 其数据类型为int 而不是 String
111

结语

感谢各位小伙伴的耐心观看，希望我的这些内容可以给你带来一点点帮助，不妨给我点个赞、收藏、评论或转发😀。
如有错误欢迎指正。

月光Knight
关注
  • 18
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 19
    评论
专栏目录
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

月光Knight

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值