scala案例_Scala案例类和案例对象深入（第2部分）

scala案例

发表简短目录 (Post Brief TOC)

Introduction介绍
Scala’s Case Class Benefit-6Scala案例类权益6
Advantages of Scala’s Case ClassesScala案例类的优势
Case Class Parameters案例类别参数
Case Class Parameters with “var”带有“ var”的案例类参数
Limitation of Case Class Parameters案例类别参数的限制
Case Object Vs Object(Normal Object)案例对象与对象（普通对象）
Case Class/Object is Serializable案例类/对象可序列化
Case Classes may be abstract案例类可能是抽象的
Case Class/Object usage in Real-time Projects实时项目中案例类/对象的用法
Case Classes in Inheritance继承中的案例类

介绍 (Introduction)

I have already discussed about Scala Case Class and Case Object basics in my previous post. Before going through this post, please read my previous post at: “Scala Case Class and Case Object Basics”

在之前的文章中，我已经讨论过Scala Case Class和Case Object的基础知识。在阅读这篇文章之前，请阅读我以前的文章：“ Scala Case类和Case对象基础 ”

In this post, we are going to discuss some Advanced Concepts and Real-time Projects usage about Scala Case Class and Case Object. Please practice each example without fail to get some confidence on this concept.

在本文中，我们将讨论有关Scala Case类和Case对象的一些高级概念和实时项目用法。请练习每个示例，以使您对该概念有所信心。

Scala案例类权益6 (Scala’s Case Class Benefit-6)

As we discussed in my previous post at “Scala Case Class and Case Object Basics” in “Scala’s Case Class Benefit-2” section, Case Class parameters are by-default “val” that means they are constants.

正如我们在“ Scala的Case Class Benefit-2”部分中“ Scala案例类和案例对象基础知识 ”的上一篇文章中所讨论的那样，案例类参数默认为“ val”，这意味着它们是常量。

Because of this feature, by nature Scala’s Case Classes are Immutable. Once we create an instance of a Case Class, we cannot update it’s parameters.

由于此功能，Scala的案例类本质上是不可变的。一旦创建了案例类的实例，就无法更新其参数。

NOTE:- If we want to develop Immutable classes in Java, we need to follow some set of rules. However in Scala, it is easy to develop Immutable classes.

注意：-如果要使用Java开发不可变类，则需要遵循一些规则。但是在Scala中，开发不可变类很容易。

Scala案例类的优势 (Advantages of Scala’s Case Classes)

Scala’s Case Classes have the following advantages:

Scala的案例类具有以下优点：

By default, they are Immutable.默认情况下，它们是不可变的。
They avoid lot of boilerplate code.他们避免了很多样板代码。
They ease the development process and improve Productivity.它们简化了开发过程并提高了生产率。
They are very easy to use in Pattern Matching.它们在模式匹配中非常易于使用。

案例类别参数 (Case Class Parameters)

In Scala’s Older versions, We can create Case Classes without Parameters. However, it’s NOT possible in recent Scala Releases. If we try to create a Case Class without Parameters or Fields, we will get compile-time error as shown below:

在Scala的旧版本中，我们可以创建不带参数的案例类。但是，在最新的Scala版本中是不可能的。如果尝试创建没有参数或字段的Case类，则会出现编译时错误，如下所示：

This has been deprecated since Scala version 2.7.7. It is removed in 2.11.1.

从Scala 2.7.7版开始不推荐使用。在2.11.1中已将其删除。

scala> case class CreditCard
:1: error: case classes without a parameter list are not allowed;
use either case objects or case classes with an explicit `()' as a parameter list.
case class CreditCard

So Scala Version 2.11.1 on-wards, we cannot create Case Classes without parameters.

因此从Scala 2.11.1版开始，我们无法创建没有参数的案例类。

If we don’t have any parameters, then We can create Case Class using empty parenthesis as shown blow:

如果没有任何参数，则可以使用空括号创建Case类，如下所示：

scala> case class CreditCard()
defined class CreditCard

Or it’s always advisable to use Case Object in this case.

或者在这种情况下总是建议使用Case Object。

scala> case object CreditCard
defined object CreditCard

带有“ var”的案例类参数 (Case Class Parameters with “var”)

As we know, by default Case Class Parameters are val. Even though, it is not recommended to change this nature, but we can change Case Class Parameters from val to var as shown below:

众所周知，默认情况下，案例类参数为val。即使不建议更改此性质，但我们可以将Case类参数从val更改为var，如下所示：

scala> case class Book(var name:String)
defined class Bookscala> var book1 = Book("FP In Scala")
book1: Book = Book(FP In Scala)scala> book1.name
res0: String = FP In Scalascala> book1.name = "FP In Java"
book1.name: String = FP In Javascala> book1.name
res1: String = FP In Java

As we know, “var” means variables. We can change it’s values.

众所周知，“ var”表示变量。我们可以更改它的值。

By Default, Scala Compiler generates only getters for Case Class Parameters. However, if we use “var” to Case Class Parameters, Scala Compiler generates both setters and getters.

默认情况下，Scala编译器仅为案例类参数生成吸气剂。但是，如果我们对案例类参数使用“ var”，则Scala编译器会同时生成setter和getter。

案例类别参数的限制 (Limitation of Case Class Parameters)

Before Scala Version 2.11.1, Scala Case Classes support maximum of 22 parameters only. If we use more than 22, we will get compile-time error.

在Scala 2.11.1版之前，Scala案例类最多仅支持22个参数。如果我们使用22以上，则会出现编译时错误。

However, this limitation has been removed in Scala Version 2.11.1. Now, Scala Case Classes supports more than 22 Parameters.

但是，此限制已在Scala 2.11.1版中删除。现在，Scala案例类支持超过22个参数。

scala> case class Names(a1:String,a2:String,a3:String,a4:String,a5:String,a6:String,a7:String,a8:String,a9:String,a10:String,
a11:String,a12:String,a13:String,a14:String,a15:String,a16:String,a17:String,a18:String,a19:String,a20:String,
a21:String,a22:String,a23:String,a24:String,a25:String,a26:String,a27:String,a28:String,a29:String,a30:String)
defined class Names

That means we can use any number of Parameters in Case Classes.

这意味着我们可以在案例类中使用任意数量的参数。

案例对象与对象（普通对象） (Case Object Vs Object(Normal Object))

Normal object is created using “object” keyword. By default, it’s a singleton object.

使用“ object”关键字创建普通对象。默认情况下，它是一个单例对象。

object MyNormalObject

Case Object is created using “case object” keywords. By default, it’s also a singleton object

案例对象是使用“案例对象”关键字创建的。默认情况下，它也是一个单例对象

case object MyCaseObject

By Default, Case Object gets toString and hashCode methods. But normal object cannot.
By Default, Case Object is Serializable. But normal object is not.

默认情况下，Case Object获取toString和hashCode方法。但是普通物体不能。
默认情况下，Case对象是可序列化的。但是普通对象不是。

案例类/对象可序列化 (Case Class/Object is Serializable)

Yes, By Default, Case Object is Serializable. But normal object is not. We can prove this by using isInstanaceOf method as shown below:

是的，默认情况下，Case对象是可序列化的。但是普通对象不是。我们可以使用isInstanaceOf方法证明这一点，如下所示：

scala> object MyNormalObject
defined object MyNormalObjectscala> MyNormalObject.isInstanceOf[Serializable]
res0: Boolean = falsescala> case object MyCaseObject
defined object MyCaseObjectscala> MyCaseObject.isInstanceOf[Serializable]
res1: Boolean = true

We can prove it in another way. If we decompile the class file, we can observe the following code.

我们可以用另一种方式证明这一点。如果我们反编译类文件，则可以观察以下代码。

public class Person implements scala.Product.scala.Serializable {// Data and methods
}

案例类可能是抽象的 (Case Classes may be abstract)

Before Scala Version 2.7.0, we cannot create Case Classes as Abstract. However Scala Version 2.7.0 on-wards, Case Classes may be Abstract. We can create them as Abstract using “abstract” modifier as shown below:

在Scala 2.7.0之前的版本中，我们无法将Case类创建为Abstract。但是从Scala 2.7.0版开始，案例类可能是抽象的。我们可以使用“抽象”修饰符将它们创建为摘要，如下所示：

scala> abstract case class Card(id:Int)
defined class Card

We should use “abstract” modifier before “case” modifier only like “abstract case class”. If we use it in other way, we will get compile-time error as shown below:

我们只应像“抽象案例类”一样在“案例”修饰符之前使用“抽象”修饰符。如果以其他方式使用它，则会出现编译时错误，如下所示：

scala> case abstract class Card(id:Int)
:1: error: illegal start of definition
case abstract class Card(id:Int)
^

实时项目中案例类/对象的用法 (Case Class/Object usage in Real-time Projects)

If you are new to Scala Development, you should know this point to get Scala Jobs and easy to start Scala Development Projects.

如果您不熟悉Scala开发，则应该了解这一点，以获取Scala Jobs并轻松启动Scala Development Projects。

In Real-time Projects, we use Case Classes to define application MODEL objects (Here model means M in MVC. In other words, Model means POJO, Java Bean etc).

在实时项目中，我们使用案例类来定义应用程序的MODEL对象（此处的模型表示MVC中的M。换句话说，模型表示POJO，Java Bean等）。

继承中的案例类 (Case Classes in Inheritance)

In this section, We will discuss Case Classes in Inheritance scenarios one by one with some examples.

在本节中，我们将通过一些示例逐一讨论继承场景中的案例类。

Case Class can NOT extend another Case class.案例类不能扩展另一个案例类。
Before Scala Version 2.7.0, a Case Class cannot extend from other Case Class. However, They allowed to create a Case class by extending another case class in Scala Version 2.7.0 as shown below:

在Scala 2.7.0版之前，案例类不能从其他案例类扩展。但是，他们允许通过在Scala版本2.7.0中扩展另一个case类来创建Case类，如下所示：

case class Foo(x: Int)
case class Bar(override val x: Int, y: Int) extends Foo(x)

However, they have removed this feature in recent Scala Versions. So a Case Class cannot extend another Case class.

但是，他们已在最新的Scala版本中删除了此功能。因此，案例类不能扩展另一个案例类。

scala> case class Foo(x: Int)
defined class Fooscala> case class Bar(override val x: Int, y: Int) extends Foo(x)
:12: error: case class Bar has case ancestor Foo, but case-to-case inheritance is prohibited. To overcome this limitation, use extractors to pattern match on non-leaf nodes.case class Bar(override val x: Int, y: Int) extends Foo(x)

NOTE:- In Scala Language, case-to-case inheritance is prohibited.

注意：-在Scala语言中，禁止大小写继承。

Case Class can extend another Class or Abstract Class.案例类可以扩展另一个类或抽象类。

scala> abstract class Card(id:Int)
defined class Cardscala> case class DebitCard(id:Int,name:String,cvv:Int) extends Card(id)
defined class DebitCard

A Case Class or Case Object can extend a Trait.案例类或案例对象可以扩展特征。
```
scala> trait Event
defined trait Eventscala> case object SimpleEvent extends Event
defined object SimpleEventscala> case class ComplexEvent() extends Event
defined class ComplexEvent
```
I hope, this much information is enough to work on Scala-based projects. However, there are many more concepts to discuss about Case Classes. If anybody interested to know more, please drop me a comment below.

我希望，这些信息足以用于基于Scala的项目。但是，关于案例类还有更多的概念需要讨论。如果有人有兴趣了解更多信息，请在下面给我留言。

NOTE:- We will discuss about “How to use Case Class/Object in Pattern Matching” to understand the main benefit of Case Class/Object concept in my coming post “Scala Pattern Matching In-Depth (Coming soon).

注意：我们将在我即将发表的文章“ Scala模式匹配深度”（即将发布）中讨论“如何在模式匹配中使用案例类/对象”以了解案例类/对象概念的主要优点。

That’s it all about Scala Case Class and Case Object. We will discuss some more Scala concepts in my coming posts.

这就是有关Scala Case类和Case对象的全部内容。我们将在我的后续文章中讨论更多Scala概念。

Please drop me a comment if you like my post or have any typo errors/issues/suggestions.

如果您喜欢我的帖子或有任何错字/问题/建议，请给我评论。

翻译自: https://www.journaldev.com/12122/scala-caseclass-caseobject-part2

scala案例