Scala的案例类和类之间有什么区别?


439

我在Google中进行搜索,找到了case class和之间的区别class。每个人都提到,当您要在类上进行模式匹配时,请使用用例类。否则,使用类,还提及一些额外的好处,例如equals和哈希码覆盖。但是,这些是为什么应该使用案例类而不是类的唯一原因吗?

我猜应该在Scala中使用此功能有一些非常重要的原因。有什么解释?是否有资源可以从中学习更多有关Scala案例类的信息?

Answers:


393

案例类可以被视为普通且不可变的数据保存对象,应仅取决于其构造函数参数

这个功能概念使我们能够

  • 使用紧凑的初始化语法(Node(1, Leaf(2), None))
  • 使用模式匹配分解它们
  • 隐式定义相等比较

与继承结合使用,case类用于模拟代数数据类型

如果对象在内部执行状态计算或表现出其他复杂的行为,则它应该是普通类。


11
@Teja:以某种方式。ADT是有点参数化的枚举,非常强大且类型安全。
达里奥

8
密封案例类用于模拟代数数据类型。否则,子类的数量不受限制。
Thomas Jung

6
@Thomas:正确地说,从密封的抽象类派生的案例类模仿封闭的代数数据类型,而ADT则是开放的
达里奥

2
@Dario ...,否则该类型是打开的,而不是ADT。:-)
Thomas Jung

1
@Thomas:是的,这只是一个存在的东西;)
Dario

165

从技术上讲,类和案例类之间没有区别-即使编译器在使用案例类时确实优化了某些内容。但是,使用case类来消除特定模式的样板,该特定模式正在实现代数数据类型

这种类型的一个非常简单的例子是树。例如,可以像这样实现一棵二叉树:

sealed abstract class Tree
case class Node(left: Tree, right: Tree) extends Tree
case class Leaf[A](value: A) extends Tree
case object EmptyLeaf extends Tree

这使我们能够执行以下操作:

// DSL-like assignment:
val treeA = Node(EmptyLeaf, Leaf(5))
val treeB = Node(Node(Leaf(2), Leaf(3)), Leaf(5))

// On Scala 2.8, modification through cloning:
val treeC = treeA.copy(left = treeB.left)

// Pretty printing:
println("Tree A: "+treeA)
println("Tree B: "+treeB)
println("Tree C: "+treeC)

// Comparison:
println("Tree A == Tree B: %s" format (treeA == treeB).toString)
println("Tree B == Tree C: %s" format (treeB == treeC).toString)

// Pattern matching:
treeA match {
  case Node(EmptyLeaf, right) => println("Can be reduced to "+right)
  case Node(left, EmptyLeaf) => println("Can be reduced to "+left)
  case _ => println(treeA+" cannot be reduced")
}

// Pattern matches can be safely done, because the compiler warns about
// non-exaustive matches:
def checkTree(t: Tree) = t match {
  case Node(EmptyLeaf, Node(left, right)) =>
  // case Node(EmptyLeaf, Leaf(el)) =>
  case Node(Node(left, right), EmptyLeaf) =>
  case Node(Leaf(el), EmptyLeaf) =>
  case Node(Node(l1, r1), Node(l2, r2)) =>
  case Node(Leaf(e1), Leaf(e2)) =>
  case Node(Node(left, right), Leaf(el)) =>
  case Node(Leaf(el), Node(left, right)) =>
  // case Node(EmptyLeaf, EmptyLeaf) =>
  case Leaf(el) =>
  case EmptyLeaf =>
}

请注意,树使用相同的语法构造和解构(通过模式匹配),这也正是它们的打印方式(减去空格)。

而且它们还可以与哈希映射或哈希集一起使用,因为它们具有有效,稳定的hashCode。


71
  • 案例类可以进行模式匹配
  • 案例类自动定义哈希码并等于
  • 案例类自动为构造函数参数定义getter方法。

(您已经提到了除最后一个以外的所有内容)。

这些是普通班级的唯一区别。


13
除非在构造函数参数中指定了“ var”,否则不会为案例类生成设置器,在这种情况下,您将获得与常规类相同的getter / setter生成。
米奇·布列文(Mitch Blevins)2010年

1
@米奇:是的,我很糟糕。立即修复。
sepp2k 2010年

您省略了2个差异,请参阅我的答案。
谢尔比·摩尔三世

@MitchBlevins,常规类并不总是具有 getter / setter生成器。
谢尔比·摩尔三世

Case类定义了unapply方法,这就是为什么可以对它们进行模式匹配的原因。
快乐的拷问者,2016年

30

没有人提到案例类也是它们的实例,Product因此继承了这些方法:

def productElement(n: Int): Any
def productArity: Int
def productIterator: Iterator[Any]

其中,productArity返回类参数的数量,productElement(i)返回第i 参数,并productIterator允许对其进行迭代。


2
但是,它们不是Product1,Product2等的实例。
Jean-Philippe Pellet

27

没有人提到案例类具有val构造函数参数,但这也是常规类的默认值(我认为这在Scala的设计中是不一致的)。达里奥(Dario)在他指出它们“ 不可变 ”的地方暗示了这一点。

请注意,您可以通过var为case类添加每个构造函数参数来覆盖默认值。但是,使案例类可变则导致其equalshashCode方法随时间变化。[1]

sepp2k已经提到案例类自动生成equalshashCode方法。

也没有人提到案例类自动创建一个object与该类同名的同伴,其中包含applyunapply方法。该apply方法可以构造实例而无需添加new。该unapply提取方法使图案匹配,其他人提及。

还编译器优化的速度match- case对case类模式匹配[2]。

[1] 案例类别很酷

[2] 案例分类和提取器,第15页


12

Scala中的case类构造也可以看作是删除某些样板的便利。

在构造案例类时,Scala为您提供了以下内容。

  • 它创建一个类及其伴随对象
  • 它的伴随对象实现了apply可以用作工厂方法的方法。您将获得不必使用new关键字的语法优势。

由于该类是不可变的,因此您将获得访问器,这些访问器仅是该类的变量(或属性),而没有变种器(因此无法更改变量)。构造函数参数可以作为公共只读字段自动提供给您。比Java bean构造好用得多。

  • 默认情况下,您还可以获取hashCodeequalstoString方法,并且该equals方法在结构上比较对象。copy生成一种能够克隆对象的方法(某些字段具有向该方法提供的新值)。

如前所述,最大的优势是您可以在案例类上进行模式匹配。这样做的原因是因为您获得了unapply使您可以解构case类以提取其字段的方法。


从本质上讲,在创建案例类(或案例对象,如果您的类不带参数)时从Scala获得的内容是单例对象,其目的是用作工厂提取器


为什么需要一个不可变对象的副本?
圣保罗Ebermann

@PaŭloEbermann因为此copy方法可以修改字段:val x = y.copy(foo="newValue")
Thilo

8

除了人们已经说过的以外,class和之间还有一些其他基本区别case class

1. Case Class不需要显式的new,而类需要用new

val classInst = new MyClass(...)  // For classes
val classInst = MyClass(..)       // For case class

2.默认构造函数的参数在中是私有的class,而在中是公共的case class

// For class
class MyClass(x:Int) { }
val classInst = new MyClass(10)

classInst.x   // FAILURE : can't access

// For caseClass
case class MyClass(x:Int) { }
val classInst = MyClass(10)

classInst.x   // SUCCESS

3. case class通过价值比较自己

// case Class
class MyClass(x:Int) { }

val classInst = new MyClass(10)
val classInst2 = new MyClass(10)

classInst == classInst2 // FALSE

// For Case Class
case class MyClass(x:Int) { }

val classInst = MyClass(10)
val classInst2 = MyClass(10)

classInst == classInst2 // TRUE

6

根据Scala的文档

案例类只是常规类,它们是:

  • 默认不可变
  • 通过模式匹配可分解
  • 通过结构平等而不是通过引用进行比较
  • 简洁地实例化并进行操作

案件的另一个特点关键字的是编译器会为我们自动生成几种方法,包括Java中熟悉的toString,equals和hashCode方法。


5

类:

scala> class Animal(name:String)
defined class Animal

scala> val an1 = new Animal("Padddington")
an1: Animal = Animal@748860cc

scala> an1.name
<console>:14: error: value name is not a member of Animal
       an1.name
           ^

但是,如果我们使用相同的代码但使用案例类:

scala> case class Animal(name:String)
defined class Animal

scala> val an2 = new Animal("Paddington")
an2: Animal = Animal(Paddington)

scala> an2.name
res12: String = Paddington


scala> an2 == Animal("fred")
res14: Boolean = false

scala> an2 == Animal("Paddington")
res15: Boolean = true

人类:

scala> case class Person(first:String,last:String,age:Int)
defined class Person

scala> val harry = new Person("Harry","Potter",30)
harry: Person = Person(Harry,Potter,30)

scala> harry
res16: Person = Person(Harry,Potter,30)
scala> harry.first = "Saily"
<console>:14: error: reassignment to val
       harry.first = "Saily"
                   ^
scala>val saily =  harry.copy(first="Saily")
res17: Person = Person(Saily,Potter,30)

scala> harry.copy(age = harry.age+1)
res18: Person = Person(Harry,Potter,31)

模式匹配:

scala> harry match {
     | case Person("Harry",_,age) => println(age)
     | case _ => println("no match")
     | }
30

scala> res17 match {
     | case Person("Harry",_,age) => println(age)
     | case _ => println("no match")
     | }
no match

对象:单例:

scala> case class Person(first :String,last:String,age:Int)
defined class Person

scala> object Fred extends Person("Fred","Jones",22)
defined object Fred

5

对什么是案例类有最终的了解:

让我们假设以下案例类定义:

case class Foo(foo:String, bar: Int)

然后在终端中执行以下操作:

$ scalac -print src/main/scala/Foo.scala

Scala 2.12.8将输出:

...
case class Foo extends Object with Product with Serializable {

  <caseaccessor> <paramaccessor> private[this] val foo: String = _;

  <stable> <caseaccessor> <accessor> <paramaccessor> def foo(): String = Foo.this.foo;

  <caseaccessor> <paramaccessor> private[this] val bar: Int = _;

  <stable> <caseaccessor> <accessor> <paramaccessor> def bar(): Int = Foo.this.bar;

  <synthetic> def copy(foo: String, bar: Int): Foo = new Foo(foo, bar);

  <synthetic> def copy$default$1(): String = Foo.this.foo();

  <synthetic> def copy$default$2(): Int = Foo.this.bar();

  override <synthetic> def productPrefix(): String = "Foo";

  <synthetic> def productArity(): Int = 2;

  <synthetic> def productElement(x$1: Int): Object = {
    case <synthetic> val x1: Int = x$1;
        (x1: Int) match {
            case 0 => Foo.this.foo()
            case 1 => scala.Int.box(Foo.this.bar())
            case _ => throw new IndexOutOfBoundsException(scala.Int.box(x$1).toString())
        }
  };

  override <synthetic> def productIterator(): Iterator = scala.runtime.ScalaRunTime.typedProductIterator(Foo.this);

  <synthetic> def canEqual(x$1: Object): Boolean = x$1.$isInstanceOf[Foo]();

  override <synthetic> def hashCode(): Int = {
     <synthetic> var acc: Int = -889275714;
     acc = scala.runtime.Statics.mix(acc, scala.runtime.Statics.anyHash(Foo.this.foo()));
     acc = scala.runtime.Statics.mix(acc, Foo.this.bar());
     scala.runtime.Statics.finalizeHash(acc, 2)
  };

  override <synthetic> def toString(): String = scala.runtime.ScalaRunTime._toString(Foo.this);

  override <synthetic> def equals(x$1: Object): Boolean = Foo.this.eq(x$1).||({
      case <synthetic> val x1: Object = x$1;
        case5(){
          if (x1.$isInstanceOf[Foo]())
            matchEnd4(true)
          else
            case6()
        };
        case6(){
          matchEnd4(false)
        };
        matchEnd4(x: Boolean){
          x
        }
    }.&&({
      <synthetic> val Foo$1: Foo = x$1.$asInstanceOf[Foo]();
      Foo.this.foo().==(Foo$1.foo()).&&(Foo.this.bar().==(Foo$1.bar())).&&(Foo$1.canEqual(Foo.this))
  }));

  def <init>(foo: String, bar: Int): Foo = {
    Foo.this.foo = foo;
    Foo.this.bar = bar;
    Foo.super.<init>();
    Foo.super./*Product*/$init$();
    ()
  }
};

<synthetic> object Foo extends scala.runtime.AbstractFunction2 with Serializable {

  final override <synthetic> def toString(): String = "Foo";

  case <synthetic> def apply(foo: String, bar: Int): Foo = new Foo(foo, bar);

  case <synthetic> def unapply(x$0: Foo): Option =
     if (x$0.==(null))
        scala.None
     else
        new Some(new Tuple2(x$0.foo(), scala.Int.box(x$0.bar())));

  <synthetic> private def readResolve(): Object = Foo;

  case <synthetic> <bridge> <artifact> def apply(v1: Object, v2: Object): Object = Foo.this.apply(v1.$asInstanceOf[String](), scala.Int.unbox(v2));

  def <init>(): Foo.type = {
    Foo.super.<init>();
    ()
  }
}
...

如我们所见,Scala编译器生成一个常规类Foo和伴随对象Foo

让我们看一下已编译的类,并对所获得的内容进行评论:

  • 类的内部状态Foo,不可变:
val foo: String
val bar: Int
  • 吸气剂:
def foo(): String
def bar(): Int
  • 复制方法:
def copy(foo: String, bar: Int): Foo
def copy$default$1(): String
def copy$default$2(): Int
  • 实现scala.Product特征:
override def productPrefix(): String
def productArity(): Int
def productElement(x$1: Int): Object
override def productIterator(): Iterator
  • 通过以下方式实现scala.Equals使案例类实例具有可比性,从而实现特征==
def canEqual(x$1: Object): Boolean
override def equals(x$1: Object): Boolean
  • java.lang.Object.hashCode服从equals-hashcode契约的重写:
override <synthetic> def hashCode(): Int
  • 覆盖java.lang.Object.toString
override def toString(): String
  • 通过new关键字实例化的构造函数:
def <init>(foo: String, bar: Int): Foo 

对象Foo:- apply没有new关键字的实例化方法:

case <synthetic> def apply(foo: String, bar: Int): Foo = new Foo(foo, bar);
  • unupply在模式匹配中使用案例类Foo的提取器方法:
case <synthetic> def unapply(x$0: Foo): Option
  • 保护对象作为单例免受反序列化的方法,以免产生更多实例:
<synthetic> private def readResolve(): Object = Foo;
  • Foo对象扩展scala.runtime.AbstractFunction2了这种技巧:
scala> case class Foo(foo:String, bar: Int)
defined class Foo

scala> Foo.tupled
res1: ((String, Int)) => Foo = scala.Function2$$Lambda$224/1935637221@9ab310b

tupled from object返回一个函数,通过应用2个元素的元组来创建新的Foo。

因此,案例类只是语法糖。


4

与类不同,案例类仅用于保存数据。

案例类对于以数据为中心的应用程序非常灵活,这意味着您可以在案例类中定义数据字段,并在伴随对象中定义业务逻辑。这样,您就可以将数据与业务逻辑分离。

使用copy方法,您可以从源继承任何或所有必需的属性,并可以根据需要更改它们。


3

没有人提到案例类伴侣对象具有tupled防御性,其类型如下:

case class Person(name: String, age: Int)
//Person.tupled is def tupled: ((String, Int)) => Person

我可以找到的唯一用例是,当您需要从元组构造案例类时,例如:

val bobAsTuple = ("bob", 14)
val bob = (Person.apply _).tupled(bobAsTuple) //bob: Person = Person(bob,14)

您可以通过直接创建对象而无需元组的情况下执行相同的操作,但是如果您将数据集表示为Arity为20(元组包含20个元素的元组)的元组列表,则选择元组是您的选择。


3

一个案例类是可与使用一类match/case的语句。

def isIdentityFun(term: Term): Boolean = term match {
  case Fun(x, Var(y)) if x == y => true
  case _ => false
}

你看 case其后是Fun类的实例,其第二个参数是Var。这是一种非常不错且功能强大的语法,但是不能与任何类的实例一起使用,因此对case类有一些限制。如果遵守这些限制,则可以自动定义哈希码和等于。

含糊不清的短语“通过模式匹配的递归分解机制”的含义仅是“与...一起使用case”。(实际上,将后面的实例与后面的实例进行match比较(匹配)case,Scala必须分解它们两者,并且必须递归分解它们的组成。)

什么案例类有用?在维基百科的文章关于代数数据类型给出了两个很好的典型例子,列表和树木。任何现代功能语言都必须支持代数数据类型(包括知道如何比较它们)。

什么情况下类不是有用?有些对象具有状态,类似的代码connection.setConnectTimeout(connectTimeout)不适用于案例类。

现在您可以阅读Scala之行:案例课程


2

我认为总体而言,所有答案都给出了有关类和案例类的语义解释。这可能非常相关,但是scala中的每个新手都应该知道创建案例类时会发生什么。我已经写了这个答案,简而言之解释了案例类。

每个程序员都应该知道,如果他们使用任何预先构建的功能,那么他们所编写的代码就会相对较少,这可以通过赋予编写最优化的代码的能力来使它们成为可能,但是这些功能承担着巨大的责任。因此,请谨慎使用预建函数。

由于另外20种方法,有些开发人员避免编写案例类,您可以通过反汇编类文件来查看。

如果要检查case类中的所有方法,参考此链接


1
  • 案例类使用apply和unapply方法定义一个compagnon对象
  • 案例类扩展了Serializable
  • 案例类定义等于hashCode和copy方法
  • 构造函数的所有属性均为val(语法糖)

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.