关于函数式编程：Scala的案例类和类之间有什么区别？

What is the difference between Scala's case class and class?

我在谷歌上搜索了case class和class的区别。每个人都提到当你想在类上进行模式匹配时，用例类。否则，请使用类，并提到一些额外的好处，如equals和hash代码重写。但是，这是为什么人们应该使用case类而不是class的唯一原因吗？

我想在scala中应该有一些非常重要的原因。什么是解释，或者是否有资源可以从中了解有关scala case类的更多信息？

case类可以看作是纯的和不可变的数据，它保存的对象应该完全依赖于它们的构造函数参数。

这个功能概念允许我们

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

结合继承，case类被用来模拟代数数据类型。

如果一个对象在内部执行有状态计算，或者表现出其他类型的复杂行为，那么它应该是一个普通类。

相关讨论

从技术上讲，类和case类没有区别——即使编译器在使用case类时确实优化了一些东西。然而，一个case类被用来去掉特定模式的boiler plate，该模式实现代数数据类型。

这种类型的一个非常简单的例子是树。例如，二进制树可以这样实现：

1
2
3
4

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

这使我们能够做到以下几点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// 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 =>
}

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

它们也可以与散列图或散列集一起使用，因为它们有一个有效、稳定的散列码。

案例类可以进行模式匹配
case类自动定义hashcode和equals
case类自动为构造函数参数定义getter方法。

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

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

相关讨论

没有人提到case类也是Product的实例，因此继承了这些方法：

1
2
3

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

当productArity返回类参数个数时，productElement(i)返回ith参数，productIterator允许遍历这些参数。

相关讨论

没有人提到case类有val构造函数参数，但这也是常规类的默认值(我认为这在scala的设计中是不一致的)。达里奥在他提到的地方暗示了这些"不变的"。

注意，您可以通过在case类的每个构造函数参数前面加上var来重写缺省值。但是，使case类可变会导致它们的equals和hashCode方法是时间变量。

SEPP2K已经提到case类自动生成equals和hashCode方法。

也没有人提到case类自动创建一个与该类同名的伴生object，该类包含apply和unapply方法。apply方法可以在不预先使用new的情况下构造实例。unapply提取器方法可以实现其他方法提到的模式匹配。

此外，编译器还优化了与case类&91；2]匹配的match到case模式的速度。

[；1]案例类很酷

[；2]案例类和提取器，第15页。

scala中的case类构造也可以看作是删除一些样板文件的便利。

当构造一个case类时，scala给出了以下内容。

它创建一个类以及它的伴生对象
它的伴生对象实现了可以用作工厂方法的apply方法。你不必使用这个新的关键词就可以获得句法上的优势。

因为类是不可变的，所以您可以得到访问器，它只是类的变量(或属性)，但没有变元(因此无法更改变量)。构造函数参数自动作为公共只读字段提供给您。比JavaBean构建要好得多。

您还可以得到默认的hashCode、equals和toString方法，并且equals方法在结构上比较对象。生成一个copy方法，以便能够克隆一个对象(有些字段为该方法提供了新的值)。

正如前面提到的，最大的优点是您可以在case类上进行模式匹配。这是因为您得到了unapply方法，该方法允许您解构一个case类来提取其字段。

实际上，在创建case类(或者如果类不带参数，则为case对象)时，您从scala获得的是一个单例对象，它用作工厂和提取器。

相关讨论

除了人们已经说过的，class和case class之间还有一些更基本的区别。

1.case class不需要显式new，类需要用new调用。

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

2.默认情况下，构造函数参数在class中是私有的，在case class中是公共的。

1
2
3
4
5
6
7
8
9
10
11

// 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.按价值比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 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

根据scala的文件：

Case classes are just regular classes that are:

Immutable by default

Decomposable through pattern matching

Compared by structural equality instead of by reference

Succinct to instantiate and operate on

case关键字的另一个特点是编译器自动为我们生成几种方法，包括在Java中熟悉的ToStand、Heales和Hash码方法。

班级：

1
2
3
4
5
6
7
8
9
10

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
^

但是，如果我们使用相同的代码但使用用例类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

人员类别：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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)

图案匹配：

1
2
3
4
5
6
7
8
9
10
11

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

对象：单件：

1
2
3
4
5

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

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

与类不同，case类只是用来保存数据。

case类对于以数据为中心的应用程序是灵活的，这意味着您可以在case类中定义数据字段，并在伴生对象中定义业务逻辑。通过这种方式，您将数据与业务逻辑分离。

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

case类是可以与match/case语句一起使用的类。

1
2
3
4

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

您可以看到case后面跟着一个类fun实例，它的第二个参数是var。这是一个非常好和强大的语法，但它不能与任何类的实例一起使用，因此对case类有一些限制。如果遵守这些限制，就可以自动定义hashcode和equals。

模糊的短语"通过模式匹配的递归分解机制"意味着"它与case一起工作"。(事实上，跟在EDOCX1后面的实例(11)与跟在EDOCX1后面的实例(9)进行比较，scala必须同时分解这两个实例，并且必须递归地分解它们的构成。)

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

什么case类不有用？有些对象有状态，像connection.setConnectTimeout(connectTimeout)这样的代码不适用于case类。

现在您可以阅读scala的教程：案例类

没有人提到案例类伴侣对象具有tupled防御，其类型为：

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

我能找到的唯一用例是当您需要从元组构造case类时，例如：

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

通过直接创建对象，可以在不使用元组的情况下执行相同的操作，但如果数据集表示为arity 20的元组列表(20个元素的元组)，则可能使用元组是您的选择。

我认为所有的答案都给出了关于类和案例类的语义解释。这可能非常相关，但是scala中的每个新手都应该知道当您创建一个case类时会发生什么。我写了这个答案，简单地解释了案例课。

每个程序员都应该知道，如果他们使用任何预构建的函数，那么他们编写的代码相对较少，这是通过赋予他们编写最优化代码的能力来实现的，但是能力是有很大责任的。因此，使用预先构建的函数时要非常小心。

一些开发人员避免编写case类，因为有额外的20个方法，您可以通过分解类文件看到这些方法。

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

case类使用apply和unapply方法定义compagnon对象
case类扩展了可序列化
case类定义等于hashcode和copy方法
构造器的所有属性都是val(语法糖)