apply方法

伴生类和伴生对象的概念，companion class和companion object
伴生对象里面，可以定义一个apply方法
直接调用类(参数)，方式，就相当于在调用apply方法
此时在apply方法中，通常来说（也不一定），会创建一个伴生类的对象，返回回去
这种方式，有一个好处，创建对象呢，非常的方便
不要每次都是new 类(参数)，类(参数)

提取器

unapply方法

和apply方法，顾名思义，那就是反过来
apply方法，可以理解为，接收一堆参数，然后返回一个对象
unapply方法，可以理解为，接收一个字符串，解析成一个对象的各个字段
提取器就是一个包含了unapply方法的对象，跟apply方法正好相反
apply方法，是接收一堆参数，然后构造出来一个对象
unapply方法，是接收一个字符串，然后解析出对象的属性值

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

object Person {

  def apply(name: String, age: Int) = new Person(name, age)
  
  def unapply(str: String) = {
    val splitIndex = str.indexOf(" ")
    if (splitIndex == -1) None
    else Some((str.substring(0, splitIndex), str.substring(splitIndex + 1)))
  }

  /**
    *  输出：name is leo and age is 25
    * @param args
    */
  def main(args: Array[String]): Unit = {
    val Person(name, age) = "leo 25"
    println(s"name is ${name} and age is ${age}")
  }

}

样例类的提取器

scala中的样例类，说白了，也很简单
类似于java中的javabean，java中的JavaBean，是什么东东？

包含了一堆属性，field; 每个field都有一对getter和setter方法

public class Person {
    
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
}

scala中的样例类，默认就是提供apply方法和unapply方法的

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

val p = Person("leo", 25)

p match {
    case Person(name, age) => println(name + ": " + age)
}

只有一个参数的提取器

如果接收一个字符串，作为参数，然后从字符串里面解析出来多个字段值，然后将多个字段值封装在一个tuple中作为Some类型的对象，返回

现在我们来想一下，如果你的类只有一个字段
字符串里面只有一个字段，解析出来的一个字段，是没有办法放在tuple中的，因为scala中的tuple，规定了，必须要两个以及两个以上的值

这个时候，在提取器，unapply方法中，只能将一个字段值，封装在Some对象中，直接返回

class Person(val name: String)

object Person {
  def unapply(input: String): Option[String] = Some(input)
}

val Person(name) = "leo"