scala Object

Object

在scala中被object关键字修饰的类有如下特征：
1、是单例的
2、不需要通过new来创建对象，直接通过类名创建
3、没有有参的主构造器，但是有主构造代码块（不包含在任何方法中的代码，就是object的主构造代码块）
4、通常用于封装一些常量、工具类、枚举和隐式转换函数
5、主构造代码块只会执行一次，因为是单例的

object ObjectDemo {
  println("ObjectDemo 的主构造代码块")
  def sayHello = println("hello world")

  println("ObjectDemo 的主构造代码块2")

}

object ObjectDemo2 {
  def main(args: Array[String]): Unit = {
    val obj1 = ObjectDemo
    val obj2 = ObjectDemo
    println(obj1.hashCode() == obj2.hashCode())

  }
}
运行结果:
ObjectDemo 的主构造代码块
ObjectDemo 的主构造代码块2
true

object.apply方法

package clazz

object ObjectDemo_02 {
  println("hello world")

  def apply() = {
    println("hello")
  }

  def apply(nums: Int*): Array[Int] = {
    val arr = new Array[Int](nums.length)
    for (i <- 0 to nums.length - 1) arr(i) = nums(i)
    arr
  }
}

object ObjectDemo_0201 {
  def main(args: Array[String]): Unit = {
    //创建了一个ObjectDemo_02对象
    val o = ObjectDemo_02
    println("----------------")
    //创建了一个ObjectDemo_02对象，并且调用了无参的apply方法
    val o1 = ObjectDemo_02()
    println("----------------")
    //创建了一个ObjectDemo_02对象，并且调用了有参的apply方法
    val o2 = ObjectDemo_02(1, 2, 2, 3) //ObjectDemo_02(1, 2, 2, 3) 等同于显示调用  ObjectDemo_02.apply(1,2,2,3)
    o2.foreach(println(_))
  }
}
运行结果：
hello world
----------------
hello
----------------
1
2
2
3

伴生类与伴生对象

 * 伴生类和伴生对象一定要在同一个类文件中，并且类名相同
 * 伴生类和伴生对象的特点是可以相互访问被private修饰的字段

//伴生类
class MyArray {
  private var name: String = "小明"
  println(MyArray.name)
}
//伴生对象
object MyArray {
  private var name: String = "小红"
  println(new MyArray().name)

  def apply(nums: Int*): Array[Int] = {
    val arr = new Array[Int](nums.length)
    for (i <- 0 to nums.length - 1) arr(i) = nums(i)
    arr
  }
}

object ObjectDemo_03 {
  def main(args: Array[String]): Unit = {
    //类比数组的创建方式
    var arr = Array(1, 2, 3) //通过伴生对象和有参的apply方法创建对象
    var arr2 = new Array[Int](5) //通过伴生类创建对象

    var arr3 = MyArray(1, 2, 3)
    println("------")
    var arr4 = new MyArray()
  }
}
运行结果：
小红
小明
------
小红

object继承App，App内部有个main方法，object不用main也可执行。

object ObjectDemo_04 extends App {
  println("hello")
}

object枚举

伴生对象继承Enumeration

object MyEnum extends Enumeration {
  //方式1
//  val RED, GREEN, YELLOW = Value
  //方式2
  val RED2 = Value(0, "red2")
  val GREEN2 = Value(1, "green2")
  val YELLOW2 = Value(2, "yellow2")
}

object ObjectDemo_05 {
  def main(args: Array[String]): Unit = {
//    println(MyEnum.GREEN)
    //通过枚举角标获取枚举值
    println(MyEnum(0))
    //通过枚举名称获取枚举值
    println(MyEnum.withName("green2"))
    println("----")
    //获取所有的枚举值
    val vs = MyEnum.values
    for (i <- vs) println(i)
  }
}

外部类与内部类
 * 每个外部类的实例所持有的内部类都是不同的类！！！

class Person {
  //内部类
  class Student

  def getStu: Student = {
    new Student
  }
  val lb = ListBuffer[Student]()
}


object ObjectDemo_06 {
  def main(args: Array[String]): Unit = {

    val p1 = new Person
    val stu1: p1.Student = p1.getStu //类型为:p1.Student
    p1.lb += stu1

    val p2 = new Person
    val stu2: p2.Student = p2.getStu //类型为:p2.Student
    p2.lb += stu2

  }
}

扩大内部类的作用域

package clazz

import scala.collection.mutable.ListBuffer

class Person {
  //内部类
  class Student

  def getStu: Student = {
    new Student
  }

  //通过外部类的类型投影，扩大内部类的影响范围
  //ListBuffer 容器可以放多个外部类的实例所持有的内部类对象了
    val lb = ListBuffer[Person#Student]()

}

object ObjectDemo_06 {
  def main(args: Array[String]): Unit = {

    //扩大内部类的影响范围----1、类型投影----2、内部类放在伴生对象中，实现单例
    val p3 = new Person
    val stu3: p3.Student = p3.getStu //类型为:p1.Student

    val p4 = new Person
    val stu4: p4.Student = p4.getStu //类型为:p2.Student
    
    p3.lb += stu3
    p3.lb += stu4
    println(p3.lb.size) //2

  }
}

case class

样例类：与普通类基本一致，只是可以不使用new来创建对象

case class Student(var name:String,var age:Int) {
  println(s"hello,I am $name, $age years old")
}

object ObjectDemo_07 {
  def main(args: Array[String]): Unit = {
    val s1 = Student("小明",12)
    val s2 = new Student("小王",10)
  }
}