scala的case类和class有什么区别?

我在谷歌中搜索，以找到case class和class之间的差异。每个人都提到，当你想在类上做模式匹配时，用例类。否则使用类，并提到一些额外的好处，如等号和哈希代码重写。但是这些就是为什么应该使用case类而不是类的唯一原因吗?

我想在Scala中应该有一些非常重要的原因。有什么解释，或者有资源可以学习更多关于Scala案例类的知识吗?

143763 次浏览
小开
最佳答案

Case类可以被视为普通的和不可变的数据保存对象应该完全依赖于它们的构造函数参数。

这个函数概念允许我们

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

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

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

小开
  • Case类可以进行模式匹配
  • Case类自动定义hashcode和equals
  • Case类自动为构造函数参数定义getter方法。

(除了最后一个，你已经提到了所有的)。

这些是与常规课程的唯一区别。

小开

从技术上讲，类和case类之间没有区别——即使编译器在使用case类时确实优化了一些东西。然而，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。

小开

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

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

其中productArity返回类参数的个数，productElement(i)返回我th参数，而productIterator允许遍历它们。

小开

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

注意，你可以通过在每个构造函数参数前加上var来覆盖默认值。然而，使case类可变会导致它们的equals和hashCode方法是时变的。[1]

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

同样没有人提到case类会自动创建一个与类同名的伴生object，它包含apply和unapply方法。apply方法允许在不使用new前置的情况下构造实例。unapply提取器方法启用了其他人提到的模式匹配。

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

& # 91; 1] 案例类很酷

& # 91; 2) 案例类和提取器，第15页。

小开

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

在构造一个case类时，Scala提供了以下内容。

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

因为类是不可变的，所以你得到了访问器，它只是类的变量(或属性)，而没有突变器(因此没有改变变量的能力)。构造函数参数作为公共只读字段自动提供给您。比Java bean构造好用得多。

  • 默认情况下，你还可以获得hashCode、equals和toString方法，而equals方法会从结构上比较对象。生成copy方法是为了能够克隆一个对象(其中一些字段为该方法提供了新值)。

正如前面提到的，最大的优点是可以在case类上进行模式匹配。这样做的原因是因为你得到了unapply方法，它可以让你解构一个case类来提取它的字段。

本质上，在创建case类(或者case对象，如果你的类不带参数)时，你从Scala得到的是一个单例对象，它的用途是工厂和器。

小开

类:

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

Person类:

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
小开

没有人提到case类伴生对象有tupled定义，它的类型是:

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

我能找到的唯一用例是当你需要从tuple构造case类时，例如:

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

你可以不使用tuple直接创建object来实现同样的功能，但是如果你的数据集表示为包含20个元素的tuple列表(tuple有20个元素)，则可能使用tuple是你的选择。

小开

根据Scala的文档:

Case类只是常规类，它们是:

  • 默认是不可变的
  • 可通过模式匹配分解
  • 用结构相等代替参照进行比较
  • 简单的实例化和操作

情况下关键字的另一个特性是编译器自动为我们生成几个方法，包括Java中熟悉的toString、equals和hashCode方法。

小开

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

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一起工作”。(实际上，match后面的实例会与case后面的实例进行比较(匹配)，Scala必须将它们两个都分解，并且必须递归地分解它们的组成部分。)

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

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

现在你可以读Scala之旅:Case类了

小开
  • Case类用apply和unapply方法定义一个compagnon对象
  • Case类扩展了Serializable
  • Case类定义了equals hashCode和copy方法
  • 构造函数的所有属性都是val(语法糖)
小开

与类不同，case类仅用于保存数据。

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

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

小开

除了人们已经说过的，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比较自己的值

// For 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
小开
我认为总的来说，所有的答案都给出了一个关于类和case类的语义解释。 这可能非常相关，但是scala的每个新手都应该知道创建case类时会发生什么。我已经写了这答案，它简单地解释了case类。< / p >

每个程序员都应该知道，如果他们使用任何预先构建的函数，那么他们编写的代码相对较少，这使他们能够编写最优化的代码，但能力伴随着巨大的责任。因此，使用预构建函数时要非常小心。

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

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

小开

要最终理解什么是case类:

让我们假设下面的case类定义:

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
  • getter方法:
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 trait:
override def productPrefix(): String
def productArity(): Int
def productElement(x$1: Int): Object
override def productIterator(): Iterator
  • 通过==实现scala.Equals trait，使case类实例具有相等的可比性:
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
< p >对象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。

所以case类只是语法糖。

小开

下面列出了case classes的一些关键特性

  1. Case类是不可变的。
  2. 你可以实例化没有new关键字的case类。
  3. 案例类可以根据值进行比较

scala fiddle的示例代码，摘自scala文档。

< a href = " https://scalafiddle。io/sf/34XEQyE/0" rel="nofollow noreferrer">https://scalafiddle.io/sf/34XEQyE/0

小开

在前面的回答中没有提到的一个重要问题是身份。常规类的对象具有同一性，因此即使两个对象的所有字段值相同，它们仍然是不同的对象。然而，对于case类实例，相等性纯粹是根据对象字段的值定义的。


提交答案