Scala基础（二）

叁歲伎倆 2024-03-24 09:25 71阅读 0赞

### 单例对象（object） ###

Scala的类中无法定义静态成员，即无static关键字。如何像Java一样表达类的静态成员变量、成员方法与静态代码块？

Scala解决方案：单例对象

*  使用“object”关键字声明，可包含变量、方法与代码定义
 *  单例对象中的成员变量、成员方法通过单例对象名直接调用
 *  单例对象第一次被访问时初始化，并执行全部代码块
 *  单例对象不能new，且无构造参数
 *  程序入口main()方法必须定义在单例对象中
 *  单例对象与同名类定义在同一文件中时形成绑定关系

//定义一个单例对象
    object Student{
        def s(name:String,age:Int):Unit = print(name+","+age)
    }

### 伴生 ###

伴生即单例对象与同名类定义在同一文件中时形成绑定关系

*  前提:同一个文件的class和object 名字相同,伴生类和伴生对象在同一个文件中，名字相同
 *  同名类称为单例对象的伴生类（class）
 *  单例对象称为同名类伴生对象（object）![1178ea2ca7194c7b8dbe6576c1e86606.png][]

伴生类与伴生对象可相互访问各自私有成员  
伴生对象可为伴生类增加静态成员

伴生类中可以在域中直接使用：类名.方法 的方式调用伴生对象中的方法  
在main方法中：  
1.使用伴生类直接建立一个实例，属性和方法只能是class域中的  
2.使用伴生对象提供的实例，属性和方法只能是object域中的  
3.伴生对象中定义apply方法可以不使用new新建实例

// 互为伴生类、伴生对象
    class Oop1{ }        // 类
    object Oop1{ }      // 对比java中的静态类，可以理解为对象
     
    // 不是伴生关系
    class Oop1{ }
    object Oop{ }

### 创建语法 ###

伴生对象中的属性可以直接使用类名进行调用；伴生类中的属性，需要先实例化对象，才能够进行调用。

*没有class，只有object则是单例模式类。*

scala中伴生类&伴生对象的语法如下：

class Test{
      val a:Int = 10;
      var b:Int = 2;
    }
    
    object Test{
      val object_v1:String = "变量1";
        
      def main(args: Array[String]): Unit = {
        // 注：只有伴生对象中可以定义主函数，类似于static修饰
        println("伴生对象变量:" + Test.object_v1);
        println("伴生类变量:" + (new Test()).a);
      }
    }

### apply() ###

apply()是一个语法糖，直接调用类(对象)名称时候，默认执行的是该类(对象)的apply()方法。

目的是为了适应函数式编程的编码规范，可以在伴生对象的apply()中new一个对象，使用案例如下：

object Test{
        def apply():Test= new Test();
        def main(args: Array[String]): Unit = {
            // 变量复制，直接可以实例化对象，不需要再new了
            val ad1 = Test();
        }
    }

### 案例 ###

//伴生类和伴生对象在同一个文件中，名字相同，class类称为object的伴生类，object称为class的伴生对象
    
    //定义伴生类
    class Person(uname:String, uage:Int) {   //Scala主构造函数，主构造函数定义在类的头部
      println("class 进入到Person的class类中")
      var name:String = uname
      var age:Int = uage
      private var address:String = "亚洲"
      
      def this(){  //从构造方法 
        this("xxx",0)
        println("class this() 从构造方法")
      }
      def this(age:Int){
        this("XXX",age)
      }
      def this(name:String){
        this(name,0)
      }
      println("class 变量定义完成，准备定义方法")
      
      //定义伴生类中的方法
      def printMsg(): Unit ={
        println(Person.name+" "+Person.age+" "+address)
        Person.showMsg()
      }
      println("class类一次游，准备离开Person类")
    }
    
    
    //定义伴生对象
    object Person{  //伴生对象  相当于java中的Static
      println("object 进入到Person伴生对象中。。。")
      private val name:String = "中国"
      private val age:Int = 71
      
      //定义apply方法
      def apply(uname: String, uage: Int): Person = new Person(uname, uage)
      def apply(uname: String): Person = new Person(uname)
      def apply(uage: Int): Person = new Person(uage)
      def apply(): Person = new Person()
    
      println("object 变量定义完成，准备定义方法")
      def showMsg():Unit={
        println(Person.name+" "+Person.age)
      }
      
      //定义方法，获得class中的属性
      def showBSClass(p:Person): Unit ={
        println(p.address)
      }
      
      //main方法
      def main(args: Array[String]): Unit = {
        println("object main 进入到main方法中")
        
        //使用object的apply方法新建对象,只能使用class中的属性和方法
        val po1 = Person("zs",21)  //相当于：val person = Person.apply("aa",12)
        val po2 = Person()
        val po3 = Person("kb09")
        val po4 = Person(12)
    
        Person.showBSClass(po1)
    
    	//使用从构造方法
        var p1:Person = new Person()
        var p2:Person = new Person(21)
        var p3:Person = new Person("zhangsan")
     
     	//使用class新建对象,只能使用class中的属性和方法
     	var personNew:Person = new Person("zs",21)
     	//使用object提供的对象,只能使用object中的属性和方法
        var personObj = Person
        personObj.showMsg()
        personNew.printMsg()
      }
      println("object 伴生对象一次游结束")
    }

[1178ea2ca7194c7b8dbe6576c1e86606.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/7d55ff79a7344421afb825c77650ec37.png