Scala(五)-②-面相对象高级-静态属性和方法、特质(上)

① 伴生对象和伴生类

①-① Why

• Scala语言是完全面相对象的,并不支持静态这个概念,也就没有静态成员(静态成员变量和静态成员方法).

• 但是java又支持静态这个概念,有些需求需要用到静态.所以Scala就使用伴生对象这个技术来模拟静态,使得我们能够实现和静态一样的效果.

①-② How

语法和规则

• 伴生对象必须和伴生类同名.

class Person {  // 半生类Person}object Person {  // 伴生对象Person.写在里面的成员可以模拟Java的static效果.}

• 可以在伴生对象实现apply方法.之后直接用类名(apply形参列表)就能够触发apply方法.所以一般创建对象.

object 类名 {    def apply(形参列表) : 类名 = new 类名(形参列表)
}

Demo

伴生对象模拟静态方法

package com.sweetcs.bigdata.scala.day05.chapter08._01_accompobject/**
  * @author sweetcs
  */object ChildGameDemo {  def main(args: Array[String]): Unit = {    val child0 = new Child("lisi")    val child1 = new Child("zhangsan")    val child2 = new Child("wangwu")    Child.count(child0) // 使用类能够直接调用伴生对象中的成员
    Child.count(child1)    Child.count(child2)    Child.showNumberOfChild()

  }
}class Child(inName :String) {  var name :String = inName

}object Child {  var numberOfChild : Int = 0

  def count(child: Child): Unit = {
    numberOfChild += 1
  }  def showNumberOfChild(): Unit = {
    println(s"numberOfChild = $numberOfChild")
  }
}

伴生对象里apply

object ApplyDemo {  def main(args: Array[String]): Unit = {    val pig1 = Pig()    val pig2 = Pig("pei qi")

    println(pig1.name)
    println(pig2.name)

  }
}class Pig(inName :String) {  var name :String = inName  def this() {    this("")
  }

}object Pig {  def apply(inName: String): Pig = new Pig(inName)  def apply(): Pig = new Pig()

  
}

①-③ What

伴生对象是怎么实现让对应的伴生类能通过类直接调用 伴生对象里面的成员?

如下分析,先看源代码和对应的反编译的代码

源代码

/**
  * @author sweetcs
  */object AccompObjectDemo {  def main(args: Array[String]): Unit = {      PersonOfAccompanyClass.name = "test"
      PersonOfAccompanyClass.show()
  }
}// 半生类class PersonOfAccompanyClass {

}// 半生对象object PersonOfAccompanyClass {  var name :String = ""
  def show(): Unit = {
    println(s"name = ${name}")
  }
}

反编译的AccompObjectDemo代码

public final class AccompObjectDemo${  public static final  MODULE$;  
  static
  {    new ();
  }  
  public void main(String[] args)
  {
    PersonOfAccompanyClass..MODULE$.name_$eq("test");
    PersonOfAccompanyClass..MODULE$.show();
  }  
  private AccompObjectDemo$()
  {
    MODULE$ = this;
  }
}

public final class PersonOfAccompanyClass${  public static final  MODULE$;  private String name;  
  public String name()
  {    return this.name;
  }  
  public void name_$eq(String x$1)
  {    this.name = x$1;
  }  
  public void show()
  {
    Predef..MODULE$.println(new StringContext(Predef..MODULE$.wrapRefArray((Object[])new String[] { "name = ", "" })).s(Predef..MODULE$.genericWrapArray(new Object[] { name() })));
  }  
  private PersonOfAccompanyClass$()
  {
    MODULE$ = this;this.name = "";
  }  
  static
  {    new ();
  }
}

从上面代码可以看出,底层是通过以下两句实现了我们写的代码.而这里的MODULE$是核心所在,它是一个静态实例,类型就是PersonOfAccompanyClass$类型.所以底层其实是创建了一个对应的类名$的类,并将伴生对象中的成员分按访问控制权限放入, 并且仅有一个类名$的类型的实例(因为MODULE$是静态的).

    PersonOfAccompanyClass$.MODULE$.name_$eq("test");    PersonOfAccompanyClass$.MODULE$.show();

①-④ Details

• 伴生对象必须和伴生类同名.如果只有伴生对象,其会自动生成一个对应的空的半生类,如果只有伴生类其不会自动生成伴生对象.

• 如果半生对象中定义一个apply(apply形参列表),则可以不用new就创建对象,直接通过类名(apply形参列表)即可以触发对应的apply方法返回对象.

② 特质

学习特质之前我们先来看下Java中的接口.

Java中的接口特点

• 在Java中, 一个类可以实现多个接口。

• 在Java中，接口之间支持多继承

• 接口中属性都是常量

• 接口中的方法都是抽象的

Java中的接口有以下缺点

• 如果B实现了Ia接口,并且C继承自B,则C中会多出哪个被实现的方法,但是很多时候我们并不想要.而Scala可以通过mixin动态混入技术实现该功能

• 无法在接口中实现方法.(在Java8之前), Scala的trait可以实现该功能.

②-① Why

• trait拥有接口和抽象类的特点.学习trait,是因为trait拥有java中接口的特点和抽象类的特点,其可以很方便的解决以上接口存在的问题.所以我们可以用trait来替代接口.

• trait可以动态扩展类的功能而不通过继承.trait可以让一个类(包含抽象类),能够不通过继承trait就可以动态的扩展trait里的非抽象方案,增强这个类的功能.

②-② How

规则和语法

• 如果使用传统方法(extends),则子类依旧会继承父类实现的接口方法

• 如果使用mixin(动态混入),则子类不会继承父类实现的接口方法

获取数据库连接(trait的接口特点)-传统方法

object TraitDemo02 {  def main(args: Array[String]): Unit = {    val mySQLDriver = new MySQLDriver
    mySQLDriver.getConnection()    val oracleDriver = new OracleDriver
    oracleDriver.getConnection()

  }
}trait DBDriver{  def getConnection()
}class A {}class B extends A {}class MySQLDriver extends A with DBDriver {  override def getConnection(): Unit = {
      println("连接MySQL成功")
  }
}class D {}class OracleDriver extends D with DBDriver {  override def getConnection(): Unit = {
    println("连接Oracle成功")
  }
}class F extends D {}

动态混入(mixin)

/**
  * @author sweetcs
  */object TraitDemo04Mixin {  def main(args: Array[String]): Unit = {    val oracle = new OracleWithMixin with DBDriver02
    oracle.insert()
  }
}class OracleWithMixin {

}trait DBDriver02 {  def insert(): Unit = {
    println("正在插入数据到数据库中")
  }
}

作者：sixleaves
链接：https://www.jianshu.com/p/7b4b4ebc68ca