0
0

【Java】数据类型与变量

如果不是天能天生丽质

就要做到天生励志

1.常量

常量：程序运行期间，固定不变的量称为常量

常量按数据类型分类：

① 整型常量：程序中直接写的数字（没有小数点），就是整型常量。整型常量又可以分为： 二进制、八进制、十进制、十六进制 的整型常量。二进制的整型常量是由** 0** 和 1 构成，一般前面会加 0b 或者 0B ；八进制的整型常量是由 07 **的数字构成，一般前面会加 0；十进制一般由 **19** 的数字构成，**没有前缀；十六进制的整型常量是由09 AF构成，一般前面加上 0x 或 0X。

public class Test {
    public static void main(String[] args) {
        System.out.println("二进制："+0b11101);
        System.out.println("八进制："+011101);
        System.out.println("十进制："+11101);
        System.out.println("十六进制："+0x11101);
    }
}

上述代码通过十进制打印后的结果：

为什么都是11101最后打印出来的结果不一样咧？

答：因为进制不一样所以转换成十进制也就不一样

② 浮点数常量：程序中直接写的小数，就是浮点数常量。浮点型常量又可以分为 double 双精度浮点型 和 float 单精度浮点型。要是在小数后面加了** d 或 D 就表示双精度浮点型，要是在小数后面加了 f 或 F 就表示单精度浮点型，要是在程序中直接写的 小数 **没有加 后缀 默认是双精度浮点型。其中 单精度浮点型 还可以用指数形式来表示。

public class Test {
    public static void main(String[] args) {
        System.out.println(3.14);
        System.out.println(3.14d);
        System.out.println(3.14f);
        System.out.println(3e12);
    }
}

③ 字符常量：由 单引号 ' ' 括起来的单个字符，就是字符常量。转义字符也属于字符常量。

public class Test {
    public static void main(String[] args) {
        System.out.println('a');
        System.out.println('\n');
    }
}

④ 字符串常量：：由 " " 括起来的，就是字符串常量。" " 里面一个字符都没有的长度就是0，里面要是有一个空格那么长度就是 1。

public class Test {
    public static void main(String[] args) {
        System.out.println("abc");
    }
}

⑤ 布尔常量：****布尔常量是用来表示真假的，只有两个值一个是 true 表示真，还有一个是 false 表示假。

public class Test {
    public static void main(String[] args) {
        System.out.println(false);
        System.out.println(true);

        if(true) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }
}

⑥ 空常量： 空常量表示对象引用为空，只有一个值 null。

常量还可以从表现形式上进行分类：

① 字面值常量：就是看得这个常量就知道值

② 符号常量：就是用符号表示的常量，看得这个符号之后去找这个符号的值就能知道值了，通常要用 **final **来定义这样一个符号常量 

public class Test {
    public static void main(String[] args) {
        final int a = 10;
    }
}

2.数据类型

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

基本数据类型又可以分为：四类 八种

四类 八种：

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        short b = 10;
        int c = 10;
        long d = 10;
        double e = 10.0;
        float f = 10.0f;
        char g = 'g';
        boolean h = true;
    }
}

上面代码中数据类型不一样，它们所占空间大小也就不一样，取值范围也不一样

  • 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
  • 整形和浮点型都是带有符号的
  • 整型默认为int型，浮点型默认为double
  • 字符串属于引用类型
  • 字节是计算机中基本存储单元，1字节=8bit
  • 数据范围是空间大小 - 1 次方，因为第一位是符号位。不然整型的数据范围，整型占四个字节，则数据范围就是 2 的 -31 次方 ~ 2 的 31次方-1

为什么会有数据类型？

答：其实各种编程语言都有数据类型，不同编程语言的数据类型也是大同小异的，都是为了使用适合的空间。如果存储的数据只需要一个很小的数据空间，而选择了一个大的数据空间，就会造成空间的浪费。要是存储的数据需要一个很大的数据空间，而选择了一个小的数据空间，那就存储不下。

3.变量

3.1 认识变量

变量：在运行过程中，其值可以改变的量就是变量

定义变量的语法格式： 数据类型 变量名 = 初始值；

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

代码解析：定义了一个变量，类型是 int（整型），变量名是 a，初始值是 10 ，此时 变量 a 中存储的是 10 ，打印 a ，则打印的是 10。因为 a 是变量，所以给 a 赋值为 100， 此时变量 a 中存储的则是 100，打印 a，则打印的是 100。

3.2 变量的赋值

1.定义时赋初始值

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

**2.先定义后赋值 **

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

** 注意：必须在使用前赋值，否则程序直接报错。建议使用第一种方法，如果不知道赋什么值可以先赋值为 0**

3.3 整型家族变量

1.字节型变量

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        System.out.println(a);
        System.out.println("最大值："+Byte.MIN_VALUE);
        System.out.println("最小值："+Byte.MAX_VALUE);
    }
}

  • byte 在任何系统下都占 1 个字节
  • byte 的表示范围为：-128 ~ 127
  • 使用时注意不要超过范围
  • byte 的包装类型为 Byte
  • 通过 Byte.MIN_VALUE 可以访问短整型的最小值，通过 Byte.MAX_VALUE 可以访问短整型的最大值

2.短整型变量

public class Test {
    public static void main(String[] args) {
        short a = 10;
        System.out.println(a);
        System.out.println("最小值："+Short.MIN_VALUE);
        System.out.println("最大值："+Short.MAX_VALUE);
    }
}

  • short在任何系统下都占2个字节
  • short的表示范围为：-32768 ~ 32767
  • 使用时注意不要超过范围
  • short的包装类型为Short
  • 通过 Short.MIN_VALUE 可以访问短整型的最小值，通过 Short.MAX_VALUE 可以访问短整型的最大值

3.整型变量

public class Test {
    public static void main(String[] args) {
        short a = 10;
        System.out.println(a);
        System.out.println("最大值："+Integer.MIN_VALUE);
        System.out.println("最小值："+Integer.MAX_VALUE);
    }
}

  • int 不论在何种系统下都是 4 个字节
  • int 的表示范围为：-2147483648 ~ 2147483647
  • 在给变量设置初始值时，值不能超过 int 的表示范围，否则会导致溢出
  • int 的包装类型为 Integer
  • 通过 Integer.MIN_VALUE 可以访问整型的最小值，通过 Integer.MAX_VALUE 可以访问整型的最大值

** 4.长整型变量**

public class Test {
    public static void main(String[] args) {
        long a = 10L;//一般在长整型变量初始值后面加上大写的 L ,方便与 ing 区分
        System.out.println(a);
        System.out.println("最小值："+Long.MIN_VALUE);
        System.out.println("最大值："+Long.MAX_VALUE);
    }
}

  • 长整型不论在那个系统下都占8个字节
  • 长整型的表示范围为：-9223372036854775808 ~ 9223372036854775807
  • 长整型变量的初始值后加L或者l，推荐加L
  • long的包装类型为Long
  • 通过 Long.MIN_VALUE 可以访问整型的最小值，通过 Long.MAX_VALUE 可以访问整型的最大值

**byte、short、int、long都可以定义整型变量，为什么要给出 4 种不同类型呢？ **

答：**因为存储空间大小的不同，所以为了更加合理化分配空间就把整型又细分成了4种不同的类型 **。就好比如碗的大小一样，为什么碗又分为大碗和小碗了，要是有一个小朋友来你家吃饭，我们会给他用小碗，因为如果用大碗，他根本吃不了那么多的饭，就会造成空间浪费。要是有一个大人来你家吃饭，我们会给他用大碗，因为如果用小碗，他根本吃不饱，就会造成空间不足。

3.4浮点型家族变量

**1.双精度浮点型 **

public class Test {
    public static void main(String[] args) {
        double a = 2.0;
        System.out.println(a);
        System.out.println("最小值："+Double.MIN_VALUE);
        System.out.println("最大值："+Double.MAX_VALUE);
    }
}

  • double在任何系统下都占8个字节
  • 浮点数与整数在内存中的存储方式不同，不能单纯使用 2的n次方 的形式来计算
  • double的包装类型为Double
  • double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

注：

整型 / 整型 ！= 小数：整型除以整型不可能得到一个小数

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a / b);
    }
}

如果想要结果得要小数则有两种方法：

①.在整型/整型之前，先乘以一个小数，这样就可以让一个整型提升为浮点型

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a * 1.0 / b );
    }
}

** ②.类型设置为浮点型：**

public class Test {
    public static void main(String[] args) {
        double a = 1.0;
        double b = 2.0;
        System.out.println(a / b );
    }
}

**2.单精度浮点型 **

public class Test {
    public static void main(String[] args) {
        float a = 1.0f;
        System.out.println(a);
        System.out.println("最小值："+Float.MIN_VALUE);
        System.out.println("最大值："+Float.MAX_VALUE);
    }
}

  • float 类型在 Java 中占四个字节
  • 同样遵守 IEEE 754 标准.
  • float的包装类型为Float。

3.5字符型变量

public class Test {
    public static void main(String[] args) {
        char a = 'a';
        char b = '哈';
        System.out.println(a);
        System.out.println(b);
    }
}
  • Java 中使用 Unicode 表示字符，因此 一个字符占用两个字节, 表示的字符种类更多, 包括中文
  • char的包装类型为Character

3.6 布尔型变量

public class Test {
    public static void main(String[] args) {
        boolean a = true;
        if (a) {
            System.out.println("真");
        } else {
            System.out.println("假");
        }
    }
}
  • Java中的布尔类型只有两个取值一个是** true 表示真**，还有一个是 false 表示假。（注：C语言0表示假，非零表示真，大家不要弄混了哦）
  • Java 的** boolean** 类型和** int **不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
  • Java虚拟机规范中，并没有明确规定 **boolean 占几个字节，也没有专门用来处理 boolean 的字节码指令，在 Oracle 公司的虚拟机实现中，boolean **占 1 个字节
  • boolean 的包装类型为 **Boolean **

4.类型转换

4.1 认识类型转换

类型转换：顾名思义就是将一个类型转换为另一个类型。

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验

将把一个双精度类型的值赋给一个整型时程序将会直接报错。

将把一个双精度类型的值转换为整型，然后赋给一个整型时程序将通过。

这就是类型转换的功能，将把一个值赋值给一个不同的类型变量时，就需要类型转换。

类型转换可以分为：**隐式类型转换 **和 强制类型转换。

4.2 隐式类型转换

**隐式类型转换又称为自动类型转换：数据范围小的转为数据范围大的时候，代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。 **

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        b = a;//自动类型转换
        System.out.println(b);
    }
}

当数据范围大的转为数据范围小的时候，编译器则不会自动处理，则会直接报错

当数据范围大的转为数据范围小的时候，我们则需要用到强制类型转换

4.3 强制类型转换

** 强制类型转换：当数据范围大的转为数据范围小的时候，编译器则不会自动处理，此时我们则需要自己去转换，由用户自己转换的就叫做强制类型转换。**

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        a = (int) b;//强制类型转换
        System.out.println(a);
    }
}
  • 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
  • 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
  • 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查（比如：将一个小数赋给一个整型变量）
  • 强制类型转换不一定能成功，不相干的类型不能互相转换（比如：将布尔类型强制转换为整型）

4.4 类型提升

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

** ① 数据类型小的 与 数据类型大的进行运算**

当一个 整型 和 长整型 进行运算时，整型会被提升为长整型然后进行运算。

上述代码中 a + b ---》int + long ---》long + long 赋值给 int 时会丢失数据，编译时会报错。

** 上述代码 a + b ---》int + long ---》long + long 赋值给 long，则编译成功。**

② 低于4个字节的数据类型进行的运算

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

上述代码中 a + b ---》short + short ---》int + int 赋值给** short 时会丢失数据，编译时会报错**

上述代码 a + b ---》short + short ---》int + int 赋值给 int，则编译成功。

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

5.字符串类型

5.1认识字符串

**字符串属于引用类型 **

public class Test {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "def";
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str1 + str2);
    }
}

  • C语言中没有字符串类型，如果想在C语言中存储字符串只能运用数组。
  • 在Java中使用 String 类定义字符串类型。
  • Java 中两个字符串相加就表示把两个字符串拼接起来

5.2 int 转换为 String

方法一：整型变量 + 双引号

public class Test {
    public static void main(String[] args) {
        int a = 1;
        String str = a + "";
        System.out.println(str);
    }
}

** 方法二：用 String 包装类**

public class Test {
    public static void main(String[] args) {
        int a = 1;
        String str = String.valueOf(a);
        System.out.println(str);
    }
}

5.3 String 转换为 int

直接用 Integer 包装类

public class Test {
    public static void main(String[] args) {
        String str = "100";
        int a = Integer.parseInt(str);
        System.out.println(a);
    }
}
标签： java jvm servlet
本文转载自: https://blog.csdn.net/m0_66488562/article/details/126520427
版权归原作者 拼命阿紫 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Java】数据类型与变量”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

机器人技术在安全领域的重要作用

安全学习记录——网络篇（一）

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

单元测试数据库回滚问题

这才是单元测试，之前我们都错了

【C语言基础】：字符函数和字符串函数

ChatGPT-Next-Web SSRF漏洞+XSS漏洞复现(CVE-2023-49785)

文章导航