Java基础之数据类型与运算符_Java编程的基础核心知识

java编程的基石是数据类型和运算符，它们决定了变量的存储方式和操作行为。1. java数据类型分为基本数据类型和引用数据类型，前者包括byte、short、int、long（整型），float、double（浮点型），char（字符型），boolean（布尔型）；后者包括类、接口、数组等，存储的是对象的引用地址。2. 运算符包括算术、赋值、比较、逻辑、位、三元及自增/自减运算符，其中逻辑运算符具有短路特性，可提升性能并避免空指针异常。3. 基本数据类型的常见“坑”包括：浮点数精度问题（应使用bigdecimal处理精确计算），整数溢出（建议使用long或math.addexact检查），char类型的数值特性（可参与算术运算），以及包装类的缓存机制导致==比较失效（应使用equals比较值）。4. 运算符优先级和结合性影响表达式执行顺序，&&优先于||，赋值和三元运算符为右结合；为避免歧义，应使用括号明确逻辑。5. 实际编程中应选择合适的数据类型（如金额用bigdecimal），警惕隐式转换导致的数据丢失，合理利用短路和位运算但不牺牲可读性，优先使用括号提升代码清晰度，避免魔法数字而使用常量，通过单元测试验证复杂表达式的正确性。深入理解这些核心概念并养成良好习惯是编写健壮java代码的基础，必须在实践中持续总结和优化，才能真正掌握。

Java编程的基石，说白了，就是数据类型和运算符。它们就像是编程语言里的原子和分子，你写下的每一行代码，无论是简单的计算还是复杂的逻辑判断，都离不开它们。理解它们，不光是知道怎么用，更要明白它们背后的逻辑、潜在的“坑”，以及如何在实际项目中安全高效地运用。这是构建任何健壮Java应用的基础核心，真不是随便看看就能掌握的。

解决方案

在Java的世界里，数据类型定义了变量能存储什么种类的值，以及能对这些值进行什么操作。运算符则是对这些值进行计算、比较或逻辑判断的工具。

数据类型

立即学习“Java免费学习笔记（深入）”；

Java的数据类型主要分为两大类：基本数据类型（Primitive Types） 和 引用数据类型（Reference Types）。

1. 基本数据类型：

   • 整型:

     byte

     登录后复制
     (1字节),

     short

     登录后复制
     (2字节),

     int

     登录后复制
     (4字节),

     long

     登录后复制
     (8字节)。它们用来存储整数，区别在于能表示的范围大小。比如，

     int

     登录后复制
     是最常用的整型，但如果需要处理天文数字或者高精度ID，

     long

     登录后复制
     就成了不二之选。
   • 浮点型:

     float

     登录后复制
     (4字节),

     double

     登录后复制
     (8字节)。用于存储带小数点的数值。

     double

     登录后复制
     是默认和推荐的浮点类型，因为它精度更高。
   • 字符型:

     char

     登录后复制
     (2字节)。用来存储单个字符，比如'A', '1', '$'。它采用Unicode编码，所以可以表示世界上几乎所有的字符。
   • 布尔型:

     boolean

     登录后复制
     (JVM规范中没有明确定义大小，但通常认为是1位，实际存储时可能占用1字节)。只有两个值：

     true

     登录后复制
     和

     false

     登录后复制
     ，主要用于逻辑判断。

2. 引用数据类型：

   • 除了基本数据类型，其他所有类型都是引用数据类型，包括类（

     String

     登录后复制
     是

     java.lang.String

     登录后复制
     类的实例）、接口、数组等。它们存储的不是值本身，而是值的内存地址，也就是“引用”。这意味着当你操作一个引用类型变量时，你实际上是在操作它指向的那个对象。

运算符

运算符是执行特定操作的符号。Java提供了丰富的运算符：

1. 算术运算符:

   +

   登录后复制
   (加),

   -

   登录后复制
   (减),

   *

   登录后复制
   (乘),

   /

   登录后复制
   (除),

   %

   登录后复制
   (取模)。

   int a = 10;
   int b = 3;
   System.out.println(a / b); // 输出 3 (整数除法)
   System.out.println(a % b); // 输出 1 (取余)

   登录后复制
2. 赋值运算符:

   =

   登录后复制
   (赋值),

   +=

   登录后复制
   ,

   -=

   登录后复制
   ,

   *=

   登录后复制
   ,

   /=

   登录后复制
   ,

   %=

   登录后复制
   (复合赋值)。

   int x = 5;
   x += 3; // 等同于 x = x + 3; 现在 x 是 8

   登录后复制
3. 比较运算符:

   ==

   登录后复制
   (等于),

   !=

   登录后复制
   (不等于),

   >

   登录后复制
   (大于),

   <

   登录后复制
   (小于),

   >=

   登录后复制
   (大于等于),

   <=

   登录后复制
   (小于等于)。结果是

   boolean

   登录后复制
   类型。

   boolean isEqual = (5 == 5); // true

   登录后复制
4. 逻辑运算符:

   &&

   登录后复制
   (逻辑与),

   ||

   登录后复制
   (逻辑或),

   !

   登录后复制
   (逻辑非)。

   • &&

     登录后复制
     和

     ||

     登录后复制
     具有短路特性，这意味着如果第一个操作数已经能确定结果，第二个操作数就不会被评估。

     boolean result = (true && false); // false
     boolean anotherResult = (true || false); // true

     登录后复制
5. 位运算符:

   &

   登录后复制
   (按位与),

   |

   登录后复制
   (按位或),

   ^

   登录后复制
   (按位异或),

   ~

   登录后复制
   (按位非),

   <<

   登录后复制
   (左移),

   >>

   登录后复制
   (右移),

   >>>

   登录后复制
   (无符号右移)。这些操作直接作用于二进制位，通常用于底层数据处理或特定优化。
6. 三元运算符:

   ? :

   登录后复制
   。一个简洁的条件表达式。

   String status = (score >= 60) ? "及格" : "不及格";

   登录后复制
7. 自增/自减运算符:

   ++

   登录后复制
   (自增),

   --

   登录后复制
   (自减)。
   • 前缀形式 (

     ++i

     登录后复制
     ,

     --i

     登录后复制
     )：先改变值，再使用值。
   • 后缀形式 (

     i++

     登录后复制
     ,

     i--

     登录后复制
     )：先使用值，再改变值。

     int i = 5;
     int j = i++; // j是5, i变成6
     int k = ++i; // k是7, i变成7

     登录后复制

Java中基本数据类型到底有哪些坑？

说起Java的基本数据类型，很多人觉得“不就那几个吗，有什么难的？”。但实际上，它们隐藏着不少让人头疼的“坑”，尤其是在不经意间，就可能导致程序行为异常。

一个经典的“坑”就是浮点数精度问题。你可能会想，

0.1 + 0.2

0.3

System.out.println(0.1 + 0.2);

你会发现输出是

0.30000000000000004

1/3

BigDecimal

float

double

另一个常见的问题是整数溢出。

int

Integer.MAX_VALUE

int maxInt = Integer.MAX_VALUE;
int result = maxInt + 1; // 结果会变成 -2147483648
System.out.println(result);

这在处理计数器、ID生成或者大数据量循环时，如果没考虑到，就可能导致逻辑错误。解决方案很简单，如果知道数值可能超出

int

long

Math.addExact()

还有就是

char

char

char c = 'A';
System.out.println(c + 1); // 输出 66 (因为'A'的ASCII码是65)

这在某些特定场景下很方便，比如大小写转换，但也容易让人混淆它的“字符”本质和“数值”特性。

最后，不得不提基本数据类型和它们的包装类（Wrapper Classes）。Java为了实现泛型、集合等功能，为每个基本数据类型提供了对应的包装类（如

int

Integer

double

double

Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true

Integer c = 200;
Integer d = 200;
System.out.println(c == d); // false

这是因为

Integer

-128

127

Integer

==

equals()

==

NullPointerException

Integer

null

运算符优先级和结合性，你真的理解透了吗？

说实话，运算符优先级和结合性，这玩意儿看着简单，但真正写代码时，尤其是在表达式比较复杂的时候，很多人都会犯迷糊。我见过不少因为这个导致bug的代码，排查起来还挺费劲的。

优先级决定了哪个运算符先执行。比如，我们都知道乘除优先于加减。

a + b * c

b * c

a + b

(a + b) * c

举个例子：

boolean x = true, y = false, z = true;
if (x && y || z) {
    System.out.println("条件成立");
} else {
    System.out.println("条件不成立");
}

你觉得会输出什么？如果你不清楚

&&

||

(x && y)

z

(x && y) || z

x && y

false

false || z

false || true

true

结合性则是在优先级相同的情况下，决定了运算符的执行顺序。大多数运算符都是左结合的，比如加减乘除，

a - b - c

(a - b) - c

=

? :

int a = b = 5; // 等同于 b = 5; a = b; (右结合)

再看三元运算符：

硅基智能

基于Web3.0的元宇宙，去中心化的互联网，高质量、沉浸式元宇宙直播平台，用数字化重新定义直播

62

查看详情

int result = (condition1 ? value1 : (condition2 ? value2 : value3)); // 右结合

如果不是右结合，那

condition1 ? value1 : condition2 ? value2 : value3

(condition1 ? value1 : condition2) ? value2 : value3

我个人的经验是，与其死记硬背完整的优先级表，不如在任何可能引起歧义的地方，都果断地加上括号

()

另一个和逻辑运算符相关的特性是短路求值（Short-Circuit Evaluation）。

&&

||

• 对于

  A && B

  登录后复制
  ：如果

  A

  登录后复制
  为

  false

  登录后复制
  ，那么

  B

  登录后复制
  不会被执行，因为整个表达式的结果已经确定为

  false

  登录后复制
  。
• 对于

  A || B

  登录后复制
  ：如果

  A

  登录后复制
  为

  true

  登录后复制
  ，那么

  B

  登录后复制
  不会被执行，因为整个表达式的结果已经确定为

  true

  登录后复制
  。

这个特性在编写条件判断时非常有用，尤其是在需要防止

NullPointerException

if (obj != null && obj.getProperty() > 10) {
    // 只有当 obj 不为 null 时，才会调用 obj.getProperty()
}

如果这里用

&

&&

obj

null

obj.getProperty()

NullPointerException

如何在实际编程中高效且安全地运用数据类型与运算符？

在实际开发中，高效和安全地运用数据类型与运算符，绝不仅仅是语法层面的问题，更多的是一种编程习惯和思维模式。

1. 选择最合适的数据类型，而不是“差不多就行”

这听起来像废话，但真的很多人会忽视。比如，一个表示年龄的变量，你用

int

long

true

false

boolean

int

0

false

1

true

更重要的是，对于数值类型，要预估其可能的最大值和最小值。如果你的计数器可能达到几十亿，那就老老实实地用

long

double

BigDecimal

double

BigDecimal

2. 警惕隐式类型转换，必要时进行显式转换

Java在某些情况下会进行自动的类型提升（比如

int

long

int

long

long bigNum = 1234567890123L;
int smallNum = (int) bigNum; // 可能会丢失精度或溢出
System.out.println(smallNum); // 输出 -2133400193

在进行强制类型转换前，最好先检查数值是否在目标类型的范围内，或者确保你知道转换可能带来的后果。例如，使用

if

Math.toIntExact()

3. 利用运算符的特性，但不要过度“炫技”

短路逻辑

&&

||

NullPointerException

// 检查权限，假设权限用位表示
int userPermissions = 7; // 0111
int requiredPermission = 4; // 0100 (读写执行中的执行权限)

if ((userPermissions & requiredPermission) == requiredPermission) {
    System.out.println("用户有执行权限");
}

但请注意，除非你确实需要那一点点性能提升，并且团队成员都能理解位运算，否则不要为了用而用。可读性往往比微小的性能提升更重要。过度使用复杂的运算符组合，反而会让代码变得难以理解和维护。

4. 优先级不明时，毫不犹豫地使用括号

我前面强调过，这是最简单也最有效的实践。它不仅消除了歧义，也让你的代码意图一目了然。哪怕你对优先级了如指掌，为复杂的表达式加上括号，也是一种良好的编程习惯。这是一种防御性编程，避免了潜在的错误。

5. 避免“魔法数字”，使用常量

在代码中直接使用裸露的数字（“魔法数字”）是一个坏习惯。比如

if (status == 1)

1

public static final int STATUS_ACTIVE = 1;
// ...
if (status == STATUS_ACTIVE) {
    // ...
}

这不仅让代码自解释，如果将来

STATUS_ACTIVE

6. 编写单元测试来验证复杂表达式

对于涉及多种数据类型转换、复杂运算符组合的逻辑，编写单元测试是确保其正确性的最佳方式。这能帮你捕获那些因为优先级、结合性或者数据溢出导致的隐蔽错误。

总的来说，数据类型和运算符是Java编程的基石，它们的运用无处不在。深入理解它们的原理、特性以及潜在的陷阱，并养成良好的编程习惯，是写出高质量、高效率、高健壮性Java代码的关键。这没有捷径，只有在实践中不断思考和总结。

以上就是Java基础之数据类型与运算符_Java编程的基础核心知识的详细内容，更多请关注php中文网其它相关文章！