我在谷歌中搜索了case类和class之间的区别。每个人都提到，当你想在类上做模式匹配时，用例类。否则使用类，并提到一些额外的好处，如等号和哈希代码重写。但是这些就是为什么应该使用case类而不是类的唯一原因吗?
我想在Scala中应该有一些非常重要的原因。有什么解释，或者有资源可以学习更多关于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类实例，相等性纯粹是根据对象字段的值定义的。
要最终理解什么是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实现。产品特点:
override def productPrefix(): String
def productArity(): Int
def productElement(x$1: Int): Object
override def productIterator(): Iterator
scala实现。通过==使case类实例具有相等可比性的Equals trait:
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: 不带new关键字的实例化方法:
case <synthetic> def apply(foo: String, bar: Int): Foo = new Foo(foo, bar);
在模式匹配中使用case类Foo的提取器方法unsupply:
case <synthetic> def unapply(x$0: Foo): Option
方法来保护对象作为单例对象不被反序列化，以免产生更多实例:
<synthetic> private def readResolve(): Object = Foo;
object 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类仅用于保存数据。
Case类对于以数据为中心的应用程序来说非常灵活，这意味着您可以在Case类中定义数据字段，并在伴生对象中定义业务逻辑。通过这种方式，您将数据与业务逻辑分离。
使用copy方法，您可以从源继承任何或所有必需的属性，并可以根据需要更改它们。
除了人们已经说过的，类和案例类之间还有一些更基本的区别
1.Case Class不需要显式的new，而Class需要用new调用
val classInst = new MyClass(...) // For classes
val classInst = MyClass(..) // For case class
2.默认情况下，构造函数的形参在类中是私有的，而在case类中是公共的
// 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类根据值进行比较
// 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
Scala中的case类构造也可以看作是删除一些样板文件的便利工具。
在构造一个case类时，Scala提供了以下内容。
它创建了一个类及其伴生对象 它的伴生对象实现了apply方法，您可以将其用作工厂方法。你不必使用new关键字，从而获得了语法上的优势。
因为类是不可变的，所以你得到了访问器，它只是类的变量(或属性)，而没有突变器(因此没有改变变量的能力)。构造函数参数作为公共只读字段自动提供给您。比Java bean构造好用得多。
默认情况下还可以获得hashCode、equals和toString方法，equals方法从结构上比较对象。生成一个复制方法来克隆一个对象(其中一些字段具有提供给该方法的新值)。
正如前面提到的，最大的优点是可以在case类上进行模式匹配。这是因为您获得了unapply方法，该方法允许您分解case类以提取其字段。
实际上，在创建case类(或者case对象，如果你的类不带参数)时，你从Scala得到的是一个作为工厂和提取器的单例对象。
推荐文章
- 对于没有null的语言的最佳解释
- Python:为什么functools。部分有必要吗?
- Scala 2.8 breakOut
- 如何克隆一个案例类实例，只改变一个字段在Scala?
- ':_* '(冒号下划线*)在Scala中有什么作用?
- 我如何用groupBy计算发生的事件?
- 定义一个函数时，“def”和“val”有什么区别
- 在Scala中获取列表中的项目?
- 在函数式编程中，什么是函子?
- case对象和对象的区别
- Scala中的Case对象与枚举
- 面向对象编程，函数式编程，过程式编程
- 任务不可序列化:java.io.NotSerializableException，当只对类而不是对象调用闭包外部的函数时
- 在Scala中将一个元素附加到列表的末尾
- 在Scala中按名称调用vs按值调用，需要澄清
