04 变量与数据类型

[📦 04 变量与数据类型](#📦 04 变量与数据类型)
- 一、什么是变量
- - [1.1 变量的概念](#1.1 变量的概念)
  - [1.2 变量的三要素](#1.2 变量的三要素)
- 二、变量的声明与初始化
- - [2.1 声明变量](#2.1 声明变量)
  - [2.2 初始化变量](#2.2 初始化变量)
  - [2.3 声明并初始化（推荐）](#2.3 声明并初始化（推荐）)
  - [2.4 同时声明多个同类型变量](#2.4 同时声明多个同类型变量)
  - [2.5 变量的使用](#2.5 变量的使用)
- 三、八大基本数据类型
- - [3.1 总览](#3.1 总览)
  - [3.2 整型详解](#3.2 整型详解)
  - [3.3 浮点型详解](#3.3 浮点型详解)
  - [3.4 字符型详解](#3.4 字符型详解)
  - [3.5 布尔型详解](#3.5 布尔型详解)
- 四、引用数据类型
- - [4.1 引用类型概述](#4.1 引用类型概述)
  - [4.2 String字符串](#4.2 String字符串)
  - [4.3 基本类型与包装类](#4.3 基本类型与包装类)
- 五、类型转换
- - [5.1 自动类型转换（隐式转换）](#5.1 自动类型转换（隐式转换）)
  - [5.2 强制类型转换（显式转换）](#5.2 强制类型转换（显式转换）)
  - [5.3 类型转换总结表](#5.3 类型转换总结表)
- 六、变量的作用域
- - [6.1 作用域的分类](#6.1 作用域的分类)
  - [6.2 作用域对比](#6.2 作用域对比)
  - [6.3 局部变量注意事项](#6.3 局部变量注意事项)
- 七、常量
- - [7.1 使用final关键字](#7.1 使用final关键字)
  - [7.2 常量命名规范](#7.2 常量命名规范)
- 八、命名规范
- - [8.1 标识符规则](#8.1 标识符规则)
  - [8.2 命名约定](#8.2 命名约定)
  - [8.3 好的命名习惯](#8.3 好的命名习惯)
- 九、常见面试题
- - [9.1 面试题汇总](#9.1 面试题汇总)
- 十、总结与预告
- - [✅ 本篇总结](#✅ 本篇总结)
  - [💬 互动问题](#💬 互动问题)
  - [📖 下篇预告](#📖 下篇预告)
  - [📚 参考资料](#📚 参考资料)

📦 04 变量与数据类型

更新日期 ：2026年5月

版权声明：本文为原创文章，转载请注明出处。© 2026 Java入门到精通系列

一、什么是变量

1.1 变量的概念

变量就是内存中的一块存储空间，用来存储数据。可以把它想象成一个带标签的盒子，标签是变量名，盒子里装的是数据。

复制代码

┌──────────────┐
│    变量       │
│  ┌────────┐  │
│  │ name   │  │  ← 变量名（标识符）
│  │"张三"  │  │  ← 变量值（数据）
│  └────────┘  │
│   String     │  ← 数据类型
└──────────────┘

1.2 变量的三要素

要素	说明	示例
数据类型	决定变量存储什么类型的数据	`int`, `String`, `double`
变量名	变量的标识符，用于引用变量	`age`, `studentName`
变量值	变量中存储的具体数据	`18`, `"张三"`, `3.14`

二、变量的声明与初始化

2.1 声明变量

java 复制代码

// 语法：数据类型 变量名;
int age;           // 声明一个整型变量
String name;       // 声明一个字符串变量
double score;      // 声明一个浮点型变量
boolean isPass;    // 声明一个布尔型变量

2.2 初始化变量

java 复制代码

// 语法：变量名 = 值;
age = 18;
name = "张三";
score = 95.5;
isPass = true;

2.3 声明并初始化（推荐）

java 复制代码

// 语法：数据类型 变量名 = 值;
int age = 18;
String name = "张三";
double score = 95.5;
boolean isPass = true;

2.4 同时声明多个同类型变量

java 复制代码

// 同时声明多个变量
int a = 1, b = 2, c = 3;

// 分开声明（推荐，更清晰）
int a = 1;
int b = 2;
int c = 3;

2.5 变量的使用

java 复制代码

public class VariableDemo {
    public static void main(String[] args) {
        // 声明并初始化
        String studentName = "李明";
        int age = 20;
        double score = 92.5;
        boolean isPass = true;

        // 使用变量
        System.out.println("学生姓名：" + studentName);
        System.out.println("年龄：" + age);
        System.out.println("成绩：" + score);
        System.out.println("是否通过：" + isPass);

        // 修改变量值
        age = 21;
        score = 95.0;
        System.out.println("修改后年龄：" + age);
        System.out.println("修改后成绩：" + score);
    }
}

输出：

复制代码

学生姓名：李明
年龄：20
成绩：92.5
是否通过：true
修改后年龄：21
修改后成绩：95.0

三、八大基本数据类型

Java有8种基本数据类型（Primitive Types），分为四大类：

3.1 总览

分类	类型	关键字	字节数	范围	默认值
整型	字节型	`byte`	1	-128 ~ 127	0
	短整型	`short`	2	-32768 ~ 32767	0
	整型	`int`	4	-2^31 ~ 2^31-1	0
	长整型	`long`	8	-2^63 ~ 2^63-1	0L
浮点型	单精度	`float`	4	±3.4E38	0.0f
	双精度	`double`	8	±1.7E308	0.0d
字符型	字符型	`char`	2	0 ~ 65535	'\u0000'
布尔型	布尔型	`boolean`	1*	true/false	false

3.2 整型详解

java 复制代码

public class IntegerTypes {
    public static void main(String[] args) {
        // byte：1字节，范围 -128 ~ 127
        byte byteMin = -128;
        byte byteMax = 127;
        System.out.println("byte范围：" + byteMin + " ~ " + byteMax);

        // short：2字节，范围 -32768 ~ 32767
        short shortMin = -32768;
        short shortMax = 32767;
        System.out.println("short范围：" + shortMin + " ~ " + shortMax);

        // int：4字节，最常用的整型
        int intMin = -2147483648;
        int intMax = 2147483647;
        System.out.println("int范围：" + intMin + " ~ " + intMax);

        // long：8字节，需要加 L 或 l 后缀
        long longValue = 1000000000000L;
        long longMax = 9223372036854775807L;
        System.out.println("long值：" + longValue);

        // 进制表示
        int binary = 0b1010;   // 二进制：10
        int octal = 012;       // 八进制：10
        int decimal = 10;      // 十进制：10
        int hex = 0xA;         // 十六进制：10
        System.out.println("二进制0b1010 = " + binary);
        System.out.println("八进制012 = " + octal);
        System.out.println("十进制10 = " + decimal);
        System.out.println("十六进制0xA = " + hex);

        // Java 7+：数字可以用下划线分隔，便于阅读
        int million = 1_000_000;
        long creditCard = 1234_5678_9012_3456L;
        System.out.println("百万：" + million);
        System.out.println("信用卡号：" + creditCard);
    }
}

3.3 浮点型详解

java 复制代码

public class FloatTypes {
    public static void main(String[] args) {
        // float：单精度，需要加 F 或 f 后缀
        float floatValue = 3.14f;
        float floatValue2 = 3.14F;
        System.out.println("float：" + floatValue);

        // double：双精度（默认类型）
        double doubleValue = 3.141592653589793;
        double doubleValue2 = 3.14d;  // d后缀可选
        System.out.println("double：" + doubleValue);

        // 科学计数法
        double scientific = 1.23E4;  // 1.23 × 10^4 = 12300
        System.out.println("科学计数法：" + scientific);

        // ⚠️ 浮点数精度问题
        System.out.println(0.1 + 0.2);        // 0.30000000000000004
        System.out.println(0.1 + 0.2 == 0.3); // false！

        // 需要精确计算时使用 BigDecimal
        // 后续章节会详细介绍
    }
}

3.4 字符型详解

java 复制代码

public class CharType {
    public static void main(String[] args) {
        // char：2字节，存储单个字符
        char letter = 'A';
        char chinese = '中';
        char digit = '9';
        char symbol = '#';

        System.out.println("字母：" + letter);
        System.out.println("中文：" + chinese);
        System.out.println("数字字符：" + digit);
        System.out.println("符号：" + symbol);

        // Unicode编码
        char unicode = '\u0041';  // 'A'的Unicode码
        System.out.println("Unicode \\u0041 = " + unicode);

        // 转义字符
        char newline = '\n';     // 换行
        char tab = '\t';         // 制表符
        char backslash = '\\';   // 反斜杠
        char singleQuote = '\''; // 单引号
        char doubleQuote = '\"'; // 双引号

        // char与int的转换
        char ch = 'A';
        int ascii = ch;          // 自动转换：65
        char ch2 = (char) 66;    // 强制转换：'B'
        System.out.println("'A'的ASCII码：" + ascii);
        System.out.println("66对应的字符：" + ch2);
    }
}

3.5 布尔型详解

java 复制代码

public class BooleanType {
    public static void main(String[] args) {
        // boolean：只有两个值 true 和 false
        boolean isStudent = true;
        boolean isWorking = false;

        System.out.println("是学生：" + isStudent);
        System.out.println("在工作：" + isWorking);

        // 比较运算的结果是boolean
        int age = 20;
        boolean isAdult = age >= 18;
        System.out.println("是否成年：" + isAdult);

        // ⚠️ 注意：Java中 boolean 不能用 0 和 1 代替
        // boolean flag = 1;    // ❌ 编译错误！
        // boolean flag = true; // ✅ 正确
    }
}

四、引用数据类型

4.1 引用类型概述

除了8种基本类型，其他都是引用类型（Reference Types）：

引用类型	示例	说明
类	`String`, `Integer`	最常用
数组	`int[]`, `String[]`	存储多个值
接口	`List`, `Map`	面向对象特性

4.2 String字符串

java 复制代码

public class StringType {
    public static void main(String[] args) {
        // String是最常用的引用类型
        String name = "张三";
        String greeting = "Hello, World!";
        String empty = "";          // 空字符串
        String nullStr = null;      // null表示不指向任何对象

        // 字符串拼接
        String fullName = "张" + "三";
        String info = "姓名：" + name + "，年龄：" + 20;

        // 字符串长度
        System.out.println("长度：" + greeting.length());

        // 字符串比较
        String s1 = "Hello";
        String s2 = "Hello";
        String s3 = new String("Hello");
        System.out.println(s1 == s2);       // true（常量池）
        System.out.println(s1 == s3);       // false（不同对象）
        System.out.println(s1.equals(s3));  // true（内容相同）
    }
}

4.3 基本类型与包装类

基本类型	包装类	说明
`byte`	`Byte`	自动装箱/拆箱
`short`	`Short`	自动装箱/拆箱
`int`	`Integer`	最常用
`long`	`Long`	自动装箱/拆箱
`float`	`Float`	自动装箱/拆箱
`double`	`Double`	自动装箱/拆箱
`char`	`Character`	自动装箱/拆箱
`boolean`	`Boolean`	自动装箱/拆箱

java 复制代码

public class WrapperClass {
    public static void main(String[] args) {
        // 自动装箱：基本类型 → 包装类
        Integer num = 100;      // 等价于 Integer.valueOf(100)

        // 自动拆箱：包装类 → 基本类型
        int value = num;        // 等价于 num.intValue()

        // 包装类的常用方法
        int parsed = Integer.parseInt("123");    // 字符串转int
        String str = Integer.toString(456);       // int转字符串
        String binary = Integer.toBinaryString(10); // 转二进制字符串

        System.out.println("解析结果：" + parsed);
        System.out.println("字符串：" + str);
        System.out.println("10的二进制：" + binary);
    }
}

五、类型转换

5.1 自动类型转换（隐式转换）

自动类型转换发生在小类型 → 大类型时，不需要显式声明。

复制代码

转换方向（小→大）：
byte → short → int → long → float → double
               char ↗

java 复制代码

public class AutoConversion {
    public static void main(String[] args) {
        // 自动类型转换：小 → 大
        byte b = 10;
        int i = b;          // byte → int（自动）
        long l = i;         // int → long（自动）
        float f = l;        // long → float（自动）
        double d = f;       // float → double（自动）
        System.out.println("byte → int: " + i);
        System.out.println("int → long: " + l);
        System.out.println("long → float: " + f);
        System.out.println("float → double: " + d);

        // char → int
        char ch = 'A';
        int ascii = ch;     // char → int（自动）
        System.out.println("char → int: " + ascii);  // 65

        // 混合运算时自动提升
        int intVal = 10;
        double doubleVal = 3.14;
        double result = intVal + doubleVal;  // int自动转为double
        System.out.println("混合运算：" + result);  // 13.14

        // ⚠️ byte/short/char运算时自动提升为int
        byte b1 = 10;
        byte b2 = 20;
        // byte b3 = b1 + b2;  // ❌ 编译错误！结果是int类型
        int b3 = b1 + b2;      // ✅ 正确
        byte b4 = (byte)(b1 + b2);  // ✅ 强制转换
    }
}

5.2 强制类型转换（显式转换）

强制类型转换发生在大类型 → 小类型时，可能丢失精度。

java 复制代码

public class ForceConversion {
    public static void main(String[] args) {
        // 强制类型转换：大 → 小（可能丢失精度）
        double d = 3.99;
        int i = (int) d;     // double → int（截断小数部分）
        System.out.println("3.99 → int: " + i);  // 3（不是四舍五入！）

        // int → byte（溢出问题）
        int big = 130;
        byte small = (byte) big;
        System.out.println("130 → byte: " + small);  // -126（溢出！）

        // long → int
        long l = 2147483648L;
        int n = (int) l;
        System.out.println("2147483648L → int: " + n);  // -2147483648（溢出！）

        // double → float
        double pi = 3.141592653589793;
        float f = (float) pi;
        System.out.println("double → float: " + f);  // 3.1415927（精度损失）
    }
}

5.3 类型转换总结表

转换方向	转换方式	示例	是否安全
小 → 大	自动（隐式）	`int i = 10; long l = i;`	✅ 安全
大 → 小	强制（显式）	`double d = 3.14; int i = (int)d;`	⚠️ 可能丢失精度
String → 基本	方法转换	`Integer.parseInt("123")`	⚠️ 可能抛异常
基本 → String	拼接/方法	`"" + 123` 或 `String.valueOf(123)`	✅ 安全

六、变量的作用域

6.1 作用域的分类

java 复制代码

public class ScopeDemo {
    // 1. 类变量（静态变量）：属于整个类
    static int classVar = 100;

    // 2. 实例变量：属于对象
    int instanceVar = 200;

    public void method() {
        // 3. 局部变量：属于方法内部
        int localVar = 300;
        System.out.println("局部变量：" + localVar);
        System.out.println("实例变量：" + instanceVar);
        System.out.println("类变量：" + classVar);

        // 代码块中的变量
        if (true) {
            int blockVar = 400;  // 仅在if块内有效
            System.out.println("块变量：" + blockVar);
        }
        // System.out.println(blockVar);  // ❌ 编译错误！blockVar已超出作用域
    }
}

6.2 作用域对比

变量类型	声明位置	生命周期	作用范围
局部变量	方法/代码块内	方法执行期间	声明处到方法/块结束
实例变量	类内，方法外	对象存在期间	整个类
类变量(static)	类内，加static	程序运行期间	整个类

6.3 局部变量注意事项

java 复制代码

public class LocalVariableDemo {
    public static void main(String[] args) {
        // 1. 局部变量必须初始化后才能使用
        int x;
        // System.out.println(x);  // ❌ 编译错误：变量x可能未初始化
        x = 10;
        System.out.println(x);     // ✅

        // 2. 局部变量不能使用访问修饰符
        // public int a = 1;  // ❌
        // private int b = 2; // ❌
        int c = 3;              // ✅

        // 3. 局部变量可以加 final
        final int MAX = 100;
        // MAX = 200;  // ❌ final变量不能修改

        // 4. 同一作用域内不能重复声明
        int num = 10;
        // int num = 20;  // ❌ 编译错误：变量num已定义
        num = 20;          // ✅ 修改值是可以的
    }
}

七、常量

7.1 使用final关键字

java 复制代码

public class ConstantDemo {
    // 常量：使用 final 关键字，值不可修改
    public static final double PI = 3.14159265358979;
    public static final String APP_NAME = "Java学习系统";
    public static final int MAX_SCORE = 100;
    public static final boolean DEBUG = false;

    public static void main(String[] args) {
        System.out.println("PI = " + PI);
        System.out.println("应用名：" + APP_NAME);

        // PI = 3.14;  // ❌ 编译错误！常量不可修改

        // 局部常量
        final int DAYS_IN_WEEK = 7;
        // DAYS_IN_WEEK = 8;  // ❌ 编译错误！
        System.out.println("一周天数：" + DAYS_IN_WEEK);
    }
}

7.2 常量命名规范

java 复制代码

// ✅ 正确命名：全大写，单词间用下划线
public static final int MAX_RETRY_COUNT = 3;
public static final String DEFAULT_ENCODING = "UTF-8";
public static final double TAX_RATE = 0.08;

// ❌ 错误命名
public static final int maxRetryCount = 3;   // 不应用小驼峰
public static final int MaxRetryCount = 3;   // 不应用大驼峰

八、命名规范

8.1 标识符规则

标识符是用来命名变量、方法、类等的名称。

规则	说明	示例
只能包含字母、数字、下划线、$	不能有空格和特殊字符	`myVar`, `$price`, `_count`
不能以数字开头	必须以字母或下划线或$开头	✅ `age1` ❌ `1age`
区分大小写	`name` 和 `Name` 是不同的	-
不能使用关键字	`int`, `class`, `public` 等不能做变量名	❌ `int int = 1;`
长度无限制	但建议简洁有意义	-

8.2 命名约定

元素	命名规范	示例
类名	大驼峰（PascalCase）	`StudentInfo`, `HelloWorld`
方法名	小驼峰（camelCase）	`getAge`, `calculateScore`
变量名	小驼峰（camelCase）	`studentName`, `maxAge`
常量	全大写下划线	`MAX_VALUE`, `PI`
包名	全小写	`com.example.demo`

8.3 好的命名习惯

java 复制代码

// ✅ 好的命名：有意义、易理解
int studentAge = 20;
String studentName = "张三";
double totalScore = 95.5;
boolean isPass = true;
int[] studentScores = {90, 85, 95};

// ❌ 不好的命名：无意义、难理解
int a = 20;
String s = "张三";
double d = 95.5;
boolean b = true;
int[] arr = {90, 85, 95};

九、常见面试题

9.1 面试题汇总

Q1：Java有哪些基本数据类型？

复制代码

答：Java有8种基本数据类型：
整型：byte(1), short(2), int(4), long(8)
浮点型：float(4), double(8)
字符型：char(2)
布尔型：boolean

Q2：float f = 3.14; 是否正确？

复制代码

答：不正确。3.14默认是double类型，赋值给float需要加强制转换或加f后缀：
float f = 3.14f;     // ✅ 正确
float f = (float)3.14; // ✅ 正确

Q3：char能否存储一个中文字符？

复制代码

答：可以。Java的char使用Unicode编码，占2字节，可以存储一个中文字符。
char ch = '中';  // ✅ 正确

Q4：以下代码的输出是什么？

java 复制代码

int a = 10;
int b = a++;
int c = ++a;
System.out.println(a + "," + b + "," + c);

复制代码

答：12,10,12
- a++：先赋值后自增，b=10, a=11
- ++a：先自增后赋值，a=12, c=12

Q5：基本类型和引用类型有什么区别？

特性	基本类型	引用类型
存储内容	实际值	对象的引用（地址）
存储位置	栈内存	堆内存（引用在栈上）
默认值	0/false等	null
比较方式	==比较值	==比较地址，equals比较内容

十、总结与预告

✅ 本篇总结

✅ 理解了变量的概念、声明和初始化
✅ 掌握了八大基本数据类型及使用场景
✅ 了解了引用数据类型（String、数组、包装类）
✅ 学会了自动类型转换和强制类型转换
✅ 理解了变量的作用域（局部变量、实例变量、类变量）
✅ 学会了使用final定义常量
✅ 掌握了Java的命名规范

💬 互动问题

int 和 Integer 有什么区别？
为什么 0.1 + 0.2 != 0.3？
String 是基本类型还是引用类型？

📖 下篇预告

第05篇：运算符与表达式，我们将学习：

算术运算符、赋值运算符
比较运算符、逻辑运算符
位运算符
三元运算符
运算符优先级

📚 参考资料

📝 系列目录 ：Java入门到精通系列 | 上一篇 ：03-第一个程序HelloWorld | 下一篇 ：05-运算符与表达式