scala的继承体系

Field继承与覆写

//Scala语言是完全面向对象(万物皆对象)的语言
//类的“伴生对象”：一个类的所有静态内容都可以放置在它的伴生对象中声明和调用

1. Scala中伴生对象采用object关键字声明，伴生对象中声明的全是 "静态"内容（模拟产生），可以通过伴生对象名(类名)直接调用访问。
2. 伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
3. 从编译class看，伴生对象实现静态特性是依赖于public static final MODULE$实现的。

class A { //伴生类
  val age: Int = 10
}

class B extends A {
  override val age: Int = 20
}

object A { //伴生对象
  def main(args: Array[String]): Unit = {
    val obj1: A = new B
    val obj2: B = new B
    println(obj1.age) //20
    println(obj2.age) //20
  }
}

抽象类的继承

abstract class Tree {
  var name: String //抽象的字段
  var age: Int //抽象的字段
  var color: String = "red"

  def cry(): Long //抽象方法, 没有方法体
  def smile //抽象方法, 没有方法体
}

class Pine extends Tree {
  override var name: String = _
  override var age: Int = _

  override def cry(): Long = ???

  override def smile: Unit = ???
}

构造器的继承

class Report100(var u: String, val v: String, w: String) {
  //  private String u;
  //  private final String v;
  /**
   * 当主构造器参数没有var或val限定时，
   * 若class内部使用到该属性，则该属性会编译为private final String v;
   * 若class内部没有用到该属性，则该属性不会编译为成员变量
   * private final String w;
   */
  def myPrint(): Unit = {
    println(s"myPrint=> u=${u}---v=${v}---w=${w}")
  }

  println(s"u=${u}---v=${v}---w=${w}")
}

class Report101[T] {
  var t: T = _

  def this(p_t: T) {
    this
    this.t = p_t
    println("Report101->def this(p_t: T)")
  }

  def printOrder(t: T): Unit = {
    println(t)
  }
}

class Report102[S, T] extends Report101[T] {
  var s: S = _

  def this(p_s: S, p_t: T) {
    this
    s = p_s
    //    t = p_t
    println("Report102->def this(p_s: S, p_t: T)")
  }

  override def printOrder(t: T): Unit = {
    println(t)
  }
}


//只有主构造器可以调用父类的构造器。
//辅助构造器不能直接调用父类的构造器。
class Report103[S, T](p_s: S, p_t: T, var p_u: String) extends Report101[T](p_t) {
  var s: S = _

  def this(p_s: S, p_t: T) {
    this(p_s, p_t, "你好")
    s = p_s
    //    t = p_t
    println("Report102->def this(p_s: S, p_t: T)")
  }

  override def printOrder(t: T): Unit = {
    println(t)
  }
}

object Report101 {
  def main(args: Array[String]): Unit = {
    var r100 = new Report100("var_p", "val_p", "default_p") //u=var_p---v=val_p---w=default_p
    r100.myPrint(); //myPrint=> u=var_p---v=val_p---w=default_p
    println("====================================")
    var r1 = new Report102[String, String]("p_s", "p_t");
    //Report102->def this(p_s: S, p_t: T)
    r1.printOrder("99999999999999"); //99999999999999
    println("====================================")
    var r2 = new Report102[String, Double]();
    r2.printOrder(9999999.88); //9999999.88
    println("====================================")
    var r3 = new Report103[String, String]("p_s", "p_t", "你好世界");
    //Report101->def this(p_t: T)
    r3.printOrder("88888.88") //88888.88
    println("====================================")
    var r4 = new Report103[String, String]("p_s", "p_t");
    //Report101->def this(p_t: T)
    //Report102->def this(p_s: S, p_t: T)
    println(s"r4.t=${r4.t}   r4.s=${r4.s}   r4.p_u=${r4.p_u}") //r4.t=p_t   r4.s=p_s   r4.p_u=你好
    println("====================================")

  }
}

特质(trait)

//一个类具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素，所以在使用时，也采用了extends关键字，如果有多个特质或存在父类，那么需要采用with关键字连接。
//没有父类
//class 类名 extends 特质1 with 特质2 with 特质3 ..
//有父类
//class 类名 extends 父类 with 特质1 with 特质2 with 特质3


trait MyTrait1 {
  //声明方法，抽象的.
  def getDatabaseConnect(url: String, user: String, pwd: String): Unit
}

trait MyTrait2 {
  //声明方法，抽象的.
  def getRedisConnect(url: String, user: String, pwd: String): Unit
}

trait MyTrait3 {
}

class C extends A with MyTrait1 {
  override def getDatabaseConnect(url: String, user: String, pwd: String): Unit = {
    println("获取一个mysql数据库连接成功……^_^")
  }
}


class D extends MyTrait1 with MyTrait2 with MyTrait3 {
  override def getDatabaseConnect(url: String, user: String, pwd: String): Unit = ???

  override def getRedisConnect(url: String, user: String, pwd: String): Unit = ???
}

这篇好文章是转载于：学新通技术网