大数据开发语言Scala（三）——伴生类和伴生对象

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

总结：Scala中没有static关键字，所有的静态内容都写在object中。（main方法写在object中）

// scala默认构造函数
// 下面代码可以编译通过，但无法运行
class Oop1 {
  def showInfo()={
    println("this is oop1")
  }

  def main(args: Array[String]): Unit = {
    val oop = new Oop1
    oop.showInfo()
  }
}

一、 单例对象语法

1）基本语法

object Person{
    val country: String = "China"
}

2）说明

（1）单例对象采用object关键字声明

（2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。

（3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

3）执行顺序

class Oop1(name:String,age:Int) { // scala默认构造函数

  println("---oop1 class start---")
  var userName = name;
  var userAge = age;

  def showInfo()={
    println("this is oop1")
  }

  println("---oop1 class end---")
}

object Oop1Test {
  def main(args: Array[String]): Unit = {
    val oop = new Oop1("liwei",23)
    oop.showInfo()
  }
}

二、伴生类class与伴生对象object

伴生关系的条件：

1）class 和 object修饰的类 名字一致

2）在同一个文件中

类是对象的伴生类，对象是类的伴生对象。

可以访问彼此私有的内容，可以理解成一个整体，只是静态与非静态分离，使得程序运行起来更加高效。

// 互为伴生类、伴生对象
class Student{ }        // 类
object Student { }      // 对比java中的静态类，可以理解为对象

// 不是伴生关系
class Student{ }
object Stu { }

2）案例演示

（1）创建Student类

class Student{ 
  private var stuName:String = "zs"
  private var stuAge:Int = 18

  def showInfo ={
    println("show stu info method")
  }
}

object Student {
  var Name = "zss"
  var Age = 20
}

（2）创建测试类

object Test01 {
  def main(args: Array[String]): Unit = {
    // 创建类的实例对象
    val demo = new Student
    demo.name                // 私有属性，无法访问

    // 通过类名访问伴生对象中的属性。调用方法类似于Java中 静态方法的调用
    Student.Name
//     Student.Age     private定义的属性无法调用
  }
}

（3）object Student伴生类

class Student{ 
  private var name:String = "zs"
  private var age:Int = 18

  Student.Name    // 可以访问
  Student.Age     // object中的私有属性，在伴生类中可以访问
}

object Student {
  var Name = "zss"
  private var Age = 20

  def main(args: Array[String]): Unit = {
    val student = new Student    
// 外部类中无法访问，伴生对象中可以访问伴生类的privite私有属性
    student.name
    student.age
  }
}

三、构造函数

在Scala中构造函数有2种：

构造函数的功能：在创建类的对象的时候，进行初始化操作

// 1. 默认无参构造
class Student { 
  var stuName:String = ""
  var stuGrade:String = ""
  var stuAge:Int = 0

// 定义有参构造
  def this(name:String, grade:String, age:Int){
    this()
    this.stuName = name
    this.stuAge = age
    this.stuGrade = grade
  }

// 定义两个参数的构造方法
  def this(name:String,grade:String){
    // 方法一：调用无参构造，并赋值
    this()
    this.stuName = name
    this.stuGrade = grade

    // 方法二：直接调用有参构造方法
    this(name,grade,1)
    
  }
}

// 2. 默认有参构造
class Student(name:String, grade:String, age:Int){
  var stuName:String = ""
  var stuGrade:String = ""
  var stuAge:Int = 0

  def this(name:String,grade:String){
      this(name,grade,1)
  }
  def this(){
    this("","",0)
  }
}

1）主构造函数

只有一个

直接紧跟 在类class后面，如果没有属性的话，可以省略（）

2）附属构造函数

可以有很多

一个.scala文件中，一个类的名字和对象的名字一致，

互为伴生对象和伴生类

可以互相访问私有的属性和方法

//伴生类
class People(val name:String,val age:Int){

  var school:String = "huadian"
  val money:Double = 10000000.0

  //定义附属构造函数
  def this(name:String, age:Int, school:String){
    //第一行必须调用主构造函数
    this(name, age)
    this.school = school
    println(People.yaoshi)
  }
  def this(name:String, school:String){
    //第一行必须调用主构造函数
    this(name,18)
    this.school = school

  }
}

//伴生对象
object People{
  private  val yaoshi:String = "XXXX"
  def apply( name: String, age: Int): People = new People( name, age)
  def apply( name: String, age: Int,school:String): People = new People( name, age,school)
  def getMoney():Unit={
    println((new People("zs",11)).money)
  }
}

四、 apply方法

apply是一个特殊的方法，方法的调用可以省略方法名。

// 定义类
class Student (val name:String, val age:Int){
  def printInfo(){
    // 调用伴生对象的属性
    println(s"student:name=${name},age=${age},school=${Student.school}")
  }
}

// 伴生对象
object Student {
  val school = "bj"

  // 定义一个类的对象实例的创建方法
  def newStu(name: String, age: Int):Student = new Student(name,age)

  def apply(name: String, age:Int):Student = new Student(name,age)
}

// 测试类
object Test {
  def main(args: Array[String]):Unit = {
    // new对象
    val student = new Student("alice",18)
    student.printInfo()

    // 使用apply方法调用
    val demo2 = Student.apply("bob",21)
    demo2.showInfo

    // 简化apply关键字后的对象定义
    val demo3 = Student("candy",14)
    demo3.showInfo
  }
}