示例

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayName;
        switch (day) {
            case 1:
                dayName = "Monday";
                break;
            case 2:
                dayName = "Tuesday";
                break;
            case 3:
                dayName = "Wednesday";
                break;
            case 4:
                dayName = "Thursday";
                break;
            case 5:
                dayName = "Friday";
                break;
            case 6:
                dayName = "Saturday";
                break;
            case 7:
                dayName = "Sunday";
                break;
            default:
                dayName = "Invalid day";
                break;
        }
        System.out.println("The day is: " + dayName); // 输出: The day is: Wednesday
    }
}

Part 2: this 关键字

this 是一个引用变量，它在方法或构造函数内部使用，指向当前对象的引用，你可以把它理解为“我”或“当前这个对象”。

主要用途

• 解决成员变量和局部变量同名冲突 当方法的参数名与类的成员变量名相同时，你可以使用 this 来明确地引用成员变量。

  public class Person {
      private String name;
      public Person(String name) {
          // 这里的 name 是参数，this.name 是类的成员变量
          this.name = name; // 将参数 name 的值赋给成员变量 name
      }
      public void printName() {
          System.out.println(this.name); // this.name 可以省略，但加上更清晰
      }
  }

• 调用当前类的其他构造函数 (构造器重载) this() 必须放在构造函数的第一行，用于调用同一个类中的其他构造函数。

  
  （图片来源网络，侵删）

  public class Student {
      private String name;
      private int age;
      // 构造函数1
      public Student(String name) {
          this(name, 18); // 调用构造函数2，并设置默认年龄为18
      }
      // 构造函数2
      public Student(String name, int age) {
          this.name = name; // 使用 this 区分成员变量和参数
          this.age = age;
      }
  }

• 将当前对象作为参数传递给其他方法 当你需要将当前对象传递给另一个方法时，可以使用 this。

  public class A {
      public void doSomething() {
          System.out.println("Doing something in class A");
      }
  }
  public class B {
      public void useA(A a) {
          a.doSomething();
      }
      public void doIt() {
          useA(this); // 将当前 B 对象作为参数传递给 useA 方法
      }
  }

• 返回当前对象 在方法链（Method Chaining）中，return this; 可以让多个方法调用可以在同一行上执行。

  public class Builder {
      private String name;
      private int age;
      public Builder setName(String name) {
          this.name = name;
          return this; // 返回当前 Builder 对象
      }
      public Builder setAge(int age) {
          this.age = age;
          return this; // 返回当前 Builder 对象
      }
      public void build() {
          System.out.println("Building object: " + name + ", " + age);
      }
  }
  // 使用方法链
  new Builder().setName("Alice").setAge(30).build();

Part 3: switch 和 this 的关系

现在我们来回答你的核心问题：switch 和 this 如何一起使用？

答案是：它们可以一起使用，但场景非常特定，并且通常不是最佳实践。

this 指向一个对象实例，而 switch 通常作用于一个值（如 int, String），将它们结合使用的前提是：你想根据当前对象的某个属性（状态）来决定执行不同的行为。

一个结合使用的例子

假设我们有一个 Shape 类，它根据一个内部的 type 属性来计算面积。

// 枚举类型，用于定义形状
enum ShapeType {
    CIRCLE, SQUARE, TRIANGLE
}
class Shape {
    private ShapeType type;
    private double dimension; // 可以是半径、边长等
    public Shape(ShapeType type, double dimension) {
        this.type = type;
        this.dimension = dimension;
    }
    // 计算面积的方法
    public double calculateArea() {
        switch (this.type) { // <-- 这里使用了 this.type
            case CIRCLE:
                return Math.PI * this.dimension * this.dimension;
            case SQUARE:
                return this.dimension * this.dimension;
            case TRIANGLE:
                // 假设 dimension 是底边，高是固定的
                return 0.5 * this.dimension * 10; 
            default:
                throw new IllegalArgumentException("Unknown shape type: " + this.type);
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Shape circle = new Shape(ShapeType.CIRCLE, 5.0);
        System.out.println("Circle Area: " + circle.calculateArea()); // 输出 Circle Area: 78.53981633974483
        Shape square = new Shape(ShapeType.SQUARE, 4.0);
        System.out.println("Square Area: " + square.calculateArea()); // 输出 Square Area: 16.0
    }
}

在这个例子中：

1. this 指的是 Shape 类的当前对象实例（circle 或 square）。
2. switch (this.type) 的意思是：“检查当前这个对象的 type 属性的值是什么”。
3. 根据 type 的值（CIRCLE, SQUARE, 等），switch 语句会选择对应的 case 来执行计算逻辑。

为什么这种使用方式需要谨慎？

虽然上述例子可以工作,但它通常被视为一种面向过程的编程风格，而不是纯粹的面向对象风格。

• 违反开闭原则：如果需要增加一种新的形状（RECTANGLE），你必须修改 Shape 类的 calculateArea() 方法，添加一个新的 case，这意味着一个已经存在的类需要被修改，这不符合“对扩展开放，对修改关闭”的设计原则。

• 更好的替代方案：多态 更符合 OOP 设计原则的做法是使用多态，通过继承和方法重写来实现。

  abstract class Shape {
      protected double dimension;
      public Shape(double dimension) {
          this.dimension = dimension;
      }
      // 抽象方法，强制子类必须实现
      public abstract double calculateArea();
  }
  class Circle extends Shape {
      public Circle(double radius) {
          super(radius);
      }
      @Override
      public double calculateArea() {
          // 不再需要 switch，逻辑就在这里
          return Math.PI * dimension * dimension;
      }
  }
  class Square extends Shape {
      public Square(double side) {
          super(side);
      }
      @Override
      public double calculateArea() {
          return dimension * dimension;
      }
  }

  多态的优势：

  • 扩展性强：要增加 Rectangle，只需创建一个新的 Rectangle 类，完全不需要修改 Shape, Circle, Square 等任何现有代码。
  • 代码更清晰：每个子类的逻辑都封装在自己的方法中，逻辑更内聚，更易于理解和维护。
  • 符合 OOP 思想：它利用了“对象”本身的特性来决定行为，而不是用外部的 switch 语句来判断。

switch(this) 是一个语法上完全合法的组合，它表示“根据当前对象的某个属性进行分支判断”，但在现代面向对象编程中，当这种判断涉及到对象的行为时，通常会用更优雅、更易扩展的多态机制来替代 switch 语句。