Scala中Shape子类自定义相等性实现及Trait与抽象类选择疑问

嘿，重新捡起来编程遇到这类细节问题太正常了，我来帮你逐个拆解清楚：

首先得纠正你之前的一个小踩坑：你写的def equals(r: Shape)是重载而非覆盖了Object的equals方法。Scala里==运算符调用的是def equals(obj: Any): Boolean，所以你的自定义逻辑根本没被触发，这就是为啥没达到预期的核心原因。

要实现Rectangle(2,2) == Square(2)的效果，你需要：

• 正确覆盖equals（参数必须是Any），同时重写hashCode（这俩必须严格一致，不然Set、Map这类集合会出乱子）；
• 处理跨类型的匹配逻辑，区分不同Shape子类的相等规则。

这里分两种情况给你示例代码：

如果你用Scala 3（支持重写case类的equals） #

trait Shape {
  def a: Double
  def b: Double
  def area: Double = a * b
  def sides: Int = 4
  def perimeter: Double = 2 * (a + b)

  override def equals(obj: Any): Boolean = obj match {
    case s: Shape =>
      (this, s) match {
        // Square和边长相等的Rectangle视为相等
        case (Square(sa), Rectangle(ra, rb)) => sa == ra && ra == rb
        case (Rectangle(ra, rb), Square(sa)) => ra == sa && ra == rb
        // 同类型按结构比较
        case (r1: Rectangle, r2: Rectangle) => r1.a == r2.a && r1.b == r2.b
        case (s1: Square, s2: Square) => s1.a == s2.a
        case _ => false
      }
    case _ => false
  }

  override def hashCode(): Int = {
    // 保证相等的对象hashCode一致：正方形（含Square和a=b的Rectangle）用a的hash，否则用(a,b)的hash
    if (a == b) a.hashCode() else (a, b).hashCode()
  }
}

case class Rectangle(a: Double, b: Double) extends Shape
case class Square(a: Double) extends Shape {
  override def b: Double = a // Square的b和a始终相等
}

测试一下：

println(Rectangle(2.0, 2.0) == Square(2.0)) // 输出true
println(Square(2.0) == Rectangle(2.0, 3.0)) // 输出false

如果你用Scala 2（case类的equals是final的，不能重写） #

这种情况可以把Rectangle和Square改成普通类：

trait Shape {
  def a: Double
  def b: Double
  def area: Double = a * b
  def sides: Int = 4
  def perimeter: Double = 2 * (a + b)

  override def equals(obj: Any): Boolean = obj match {
    case s: Shape =>
      (this, s) match {
        case (s1: Square, r1: Rectangle) => s1.a == r1.a && r1.a == r1.b
        case (r1: Rectangle, s1: Square) => r1.a == s1.a && r1.a == r1.b
        case (r1: Rectangle, r2: Rectangle) => r1.a == r2.a && r1.b == r2.b
        case (s1: Square, s2: Square) => s1.a == s2.a
        case _ => false
      }
    case _ => false
  }

  override def hashCode(): Int = {
    if (a == b) a.hashCode() else (a, b).hashCode()
  }
}

class Rectangle(val a: Double, val b: Double) extends Shape
class Square(val a: Double) extends Shape {
  override def b: Double = a
}

你提到这个逻辑满足相等性的三大性质（自反、对称、传递），这一点没问题，但从OOP设计和代码可维护性角度，确实有几个需要谨慎的点：

• 违反类型语义直觉：通常来说，不同类型的对象不会被视为相等。比如Square(2)和Rectangle(2,2)在类型系统里是两个不同的类，其他开发者看到它们相等，很可能会困惑，甚至误以为是bug。
• 潜在的LSP风险：如果后续有人写代码依赖Rectangle的b可以不等于a（比如一个拉伸矩形的方法），但因为Square和Rectangle(2,2)相等，可能会误把Square传入这类方法，导致不符合预期的行为。
• 维护成本飙升：如果后续扩展Shape添加新的子类（比如菱形、平行四边形），你需要不断更新equals和hashCode的逻辑，确保所有“等价”形状的判断一致，很容易遗漏或出错。

这要看你的具体需求，但针对当前场景，用trait更合适，理由如下：

• 灵活性更高：Scala是单继承，类只能继承一个抽象类，但可以混入多个trait。如果后续要加Circle、Triangle等形状，用trait可以让它们都轻松继承Shape的行为。
• 更贴合接口定位：Shape本质是定义形状的通用行为（计算面积、周长、相等性），trait天生就是用来定义这类行为契约的，而且支持默认实现（你已经用到了area、perimeter的默认逻辑）。
• 无状态需求匹配：你的Shape没有需要维护的状态，只有抽象方法和默认实现，trait完全能满足，不需要抽象类的构造参数等特性。

当然，如果需要和Java深度互操作，或者Shape后续需要添加带参数的构造逻辑，那抽象类会更合适，但当前场景下trait是最优解。

内容的提问来源于stack exchange，提问作者oerpli