Scala之case class

痛定思痛。 2022-04-24 21:52 118阅读 0赞

我们在模式匹配中可以见到case

a match {
        case b => ...
        case _ => ...
    }

我们在类定义时，有时也会见到case关键字

case class Person (age: Int, name: String)

那么，在类上加上case关键字意味着什么呢?

#### 伴生对象 ####

编译Person.scala会产生两个class, Person.class和Person$class. 编译器给scala自动添加了一个伴生对象object Person

#### apply()方法和unapply()方法 ####

伴生对象Person里面实现了apply()方法如下，

public Person apply(int age, String name){
        return new Person(age, name);
    }

所以我们创建一个实例的时候不需要使用关键字new,可以直接通过Person(age,name)来得到一个实例对象  
  
伴生对象Person里面还实现了unapply()方法,将对象转为可选元组集合Option\[Tuple\]

public scala.Option<scala.Tuple2<Object, Object>> unapply(Person person) {
            if (person == null) {
                return scala.None$.MODULE$;
            }
            return new scala.Some(new scala.Tuple2$mcll$sp(person.age, person.name))

我们来看看代码

object CaseClassDriver {
      def main(args: Array[String]): Unit = {
        val p = Person(13,"李程")
        println(p.toString)
    
        val p$ = Person.unapply(p)
        println(p$.toString)
      }
    }
    
    /**
      * case class 编译后会生成两个class文件Person.class和Person$.class
      * Person$.class是伴生对象，实现了apply方法和unapply方法
      * apply方法返回一个实例对象
      * unapply方法将对象转为元组
      */
    case class Person(age: Int, name: String)

#### Case Class默认是Immutable ####

case类的字段会被编译器默认加上val关键字。  
所以Person.class中的age和name都被定义成了final, 且伴生对象Person$.class的定义也是

public final class Person$ {
        ...
    }

#### toString()、hashCode()和equals()方法 ####

Scala编译器负责（根据字段）给Case类重写toString()、hashCode()和equals()方法。

#### copy()方法，快速复制自己，并可以做少量变化 ####

package base.day05.caseobject
    
    /**
      * @description CaseObjDriver
      * @author ZerlindaLi create at 2019/4/29 20:32
      * @version 1.0.0
      */
    object CaseClassDriver {
      def main(args: Array[String]): Unit = {
        val p = Person(13,"李程")
        val p2 = p.copy()
        val p22 = Person(13,"李程")
        val p3 = p.copy(age=14)
        println(p.toString + p2.toString + p3.toString)
        println(p.hashCode)
        println("p.equals(p)："+p.equals(p))
        println("p.equals(p22)："+p.equals(p22))
        println("p.equals(p2)："+p.equals(p2))
        println("p2.equals(p3)："+p2.equals(p3))
        val p$ = Person.unapply(p)
        println(p$.toString)
      }
    }
    
    /**
      * case class 编译后会生成两个class文件Person.class和Person$.class 默认为Immutable
      * Person$.class是伴生对象，实现了apply方法和unapply方法
      * apply方法返回一个实例对象
      * unapply方法将对象转为元组
      * 重写了toString,equals,hashCode方法
      */
    case class Person(age: Int, name: String)

运行结果为

Person(13,李程)Person(13,李程)Person(14,李程)
    -89502882
    p.equals(p)：true
    p.equals(p22)：true
    p.equals(p2)：true
    p2.equals(p3)：false
    Some((13,李程))

## 实现Product和Serializable接口 ##

Case类还实现了scala.Product和scala.Serializable接口（Product和Serializable实际上都是Traits）。

// Product
        // def productArity: Int
        // def productElement(n: Int): Any
        // def productIterator: Iterator[Any]
        // def productPrefix = ""
        
        public int productArity() {
            return 2;
        }
        public Object productElement(int n) {
            switch (n) {
                case 0: return age();
                case 1: return name();
                default: throw new IndexOutOfBoundsException();
            }
        }
        public scala.collection.Iterator productIterator() {
            return scala.runtime.ScalaRunTime$.MODULE$.typedProductIterator(this);
        }
        public String productPrefix() {
            return "Person";
        }