Scala基础（二）

单例对象（object）

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

Scala解决方案：单例对象

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

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

伴生

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

• 前提:同一个文件的class和object 名字相同,伴生类和伴生对象在同一个文件中，名字相同
• 同名类称为单例对象的伴生类（class）
• 单例对象称为同名类伴生对象（object） 

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

伴生类中可以在域中直接使用：类名.方法 的方式调用伴生对象中的方法
在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 伴生对象一次游结束")
}