scala Object

我会带着你远行 2022-05-19 01:45 134阅读 0赞

**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)
      }
    }