5.5 三元运算符

三元运算符的概念

三元运算符（也称为条件运算符）是 Java 中唯一的三目运算符，它根据条件的真假来返回不同的值。三元运算符的语法简洁，可以替代简单的 if-else 语句。

三元运算符的语法

条件表达式 ? 表达式1 : 表达式2

• 条件表达式：一个返回布尔值的表达式
• 表达式1：当条件表达式为 true 时执行的表达式
• 表达式2：当条件表达式为 false 时执行的表达式

三元运算符的使用

基本用法

public class TernaryOperatorExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        
        // 比较两个数，返回较大的数
        int max = (a > b) ? a : b;
        System.out.println("Max: " + max); // 输出 10
        
        // 检查数字的奇偶性
        int number = 7;
        String result = (number % 2 == 0) ? "偶数" : "奇数";
        System.out.println(number + " 是 " + result); // 输出 7 是 奇数
        
        // 检查年龄是否成年
        int age = 18;
        String status = (age >= 18) ? "成年人" : "未成年人";
        System.out.println(age + " 岁是 " + status); // 输出 18 岁是 成年人
    }
}

嵌套使用

三元运算符可以嵌套使用，但嵌套层次不宜过深，否则会降低代码的可读性。

public class NestedTernaryExample {
    public static void main(String[] args) {
        int score = 85;
        
        // 嵌套三元运算符
        String grade = (score >= 90) ? "A" : 
                      (score >= 80) ? "B" : 
                      (score >= 70) ? "C" : 
                      (score >= 60) ? "D" : "F";
        
        System.out.println("Score: " + score + ", Grade: " + grade); // 输出 Score: 85, Grade: B
    }
}

与其他运算符结合使用

public class TernaryWithOtherOperatorsExample {
    public static void main(String[] args) {
        int x = 10;
        int y = 5;
        
        // 与算术运算符结合
        int result = (x > y) ? x + y : x - y;
        System.out.println("Result: " + result); // 输出 15
        
        // 与逻辑运算符结合
        boolean a = true;
        boolean b = false;
        String message = (a && b) ? "Both are true" : (a || b) ? "At least one is true" : "Both are false";
        System.out.println("Message: " + message); // 输出 At least one is true
    }
}

三元运算符的优先级

三元运算符的优先级低于算术运算符和关系运算符，但高于赋值运算符。

示例

public class TernaryPrecedenceExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        int c = 3;
        
        // 先计算关系表达式，再执行三元运算符
        int result1 = a > b ? a + c : b - c;
        System.out.println("Result 1: " + result1); // 输出 13
        
        // 使用括号改变优先级
        int result2 = (a > b ? a : b) + c;
        System.out.println("Result 2: " + result2); // 输出 13
    }
}

三元运算符的应用

1. 变量赋值

int age = 18;
String status = (age >= 18) ? "成年" : "未成年";

2. 方法返回值

public static String getGrade(int score) {
    return (score >= 90) ? "A" : (score >= 80) ? "B" : "C";
}

3. 简洁的条件判断

int x = 5;
int y = 10;
System.out.println((x > y) ? "x 大于 y" : "x 小于或等于 y");

示例：三元运算符的使用

public class TernaryApplication {
    public static void main(String[] args) {
        // 比较两个数
        int num1 = 25;
        int num2 = 30;
        int max = (num1 > num2) ? num1 : num2;
        int min = (num1 < num2) ? num1 : num2;
        System.out.println("Max: " + max); // 输出 30
        System.out.println("Min: " + min); // 输出 25
        
        // 检查字符串是否为空
        String name = "John";
        String message = (name != null && !name.isEmpty()) ? "Hello, " + name : "Hello, Guest";
        System.out.println(message); // 输出 Hello, John
        
        // 计算折扣
        double price = 100.0;
        int quantity = 5;
        double discount = (quantity >= 10) ? 0.2 : (quantity >= 5) ? 0.1 : 0;
        double total = price * quantity * (1 - discount);
        System.out.println("Total price: $" + total); // 输出 Total price: $450.0
        
        // 嵌套三元运算符
        int score = 75;
        String grade = (score >= 90) ? "优秀" : 
                      (score >= 80) ? "良好" : 
                      (score >= 60) ? "及格" : "不及格";
        System.out.println("Score: " + score + ", Grade: " + grade); // 输出 Score: 75, Grade: 及格
    }
}

三元运算符与 if-else 的比较

三元运算符的优点

• 代码简洁：使用三元运算符可以用一行代码替代多行 if-else 语句
• 表达式形式：三元运算符是一个表达式，可以作为其他表达式的一部分
• 可读性：对于简单的条件判断，三元运算符比 if-else 更易读

if-else 的优点

• 功能更强大：可以处理更复杂的逻辑
• 可读性：对于复杂的条件判断，if-else 比嵌套的三元运算符更易读
• 副作用：可以包含具有副作用的语句

常见问题

1. 嵌套层次过深

症状：代码可读性差，难以理解

解决方案：对于复杂的条件判断，使用 if-else 语句替代嵌套的三元运算符

2. 类型不匹配

症状：编译错误：error: incompatible types

解决方案：确保表达式1和表达式2的类型兼容

3. 副作用

症状：表达式中包含具有副作用的操作，导致意外行为

解决方案：避免在三元运算符中使用具有副作用的操作

总结

三元运算符是 Java 中一种简洁的条件表达式，它的语法是：

条件表达式 ? 表达式1 : 表达式2

三元运算符可以替代简单的 if-else 语句，使代码更加简洁。在使用三元运算符时，需要注意：

• 表达式1和表达式2的类型必须兼容
• 嵌套层次不宜过深，否则会降低代码的可读性
• 避免在表达式中使用具有副作用的操作

对于简单的条件判断，三元运算符是一个很好的选择；对于复杂的条件判断，建议使用 if-else 语句。