类和trait

修饰控制符

package base

object obj {
  def main(args: Array[String]): Unit = {

    // 调用无参构造方法
    val ps = new Person()
    println(ps.name)

    val person = new Person("小明")
    person.name = "小张"
    println(person.name)

    // 自定义private 字段set方法使用
    person.myAge = 1
    println(person.myAge)

    person.otherPerson(new Person("小李"))
  }
}


class Person {

  // 默认是public 会自动生成get和set方法
  var name: String = _

  // 不会自动生成get和set方法
  val info1: String = "info1"
  
  protected var info3: String = _
  protected[this] var info4: String = _
  // 在 base 包及包下面使用
  protected[base] var info5: String = _

  // 私有字段
  private var age: Int = _

  // age 的get方法,不能和字段名字相同
  def myAge: Int = age

  // age 的set方法,不能和字段名字相同,注意格式
  def myAge_=(newAge: Int) {
    age = newAge
  }

  private[this] val info2: String = "info2"

  // private[this] 和 private的区别
  def otherPerson(other: Person): Unit = {
    println(this.age == other.age)

    // 报错! 不能访问仅在实例内部使用的字段
    //    println(this.info2.equals(other.info2))
  }

  // 生成有参构造方法
  def this(name: String) {
    // 调用无参构造方法
    this()
    // 初始化变量
    this.name = name
  }

}

null
小张
1
false

抽象类

package base

object absC {
  def main(args: Array[String]): Unit = {
    val c1 = new C1()

    c1.absF1("abs1")
    c1.absF2("abs2")
    c1.fun1("fun1")
  }
}

// 抽象类
abstract class absClass1 {
  // 抽象方法
  def absF1(name: String)

  def absF2(name: String): String

  def fun1(name: String): Unit = {
    println(s"fun1 name = $name")
  }
}

// 继承抽象类
class C1 extends absClass1 {

  // 实现抽象方法
  override def absF1(name: String): Unit = {
    println("implement absF1")
  }

  override def absF2(name: String): String = {
    println(s"implement absF2")
    name
  }

  // 重写抽象类的方法
  override def fun1(name: String): Unit = {
    println(s"overwrite fun1 name = $name")
  }
}

implement absF1
implement absF2
overwrite fun1 name = fun1

枚举类

package base

object absC {
  def main(args: Array[String]): Unit = {
    // 获取枚举
    val red = Enum.RED
    println(red)
    
    val red1 = Enum.RED1
    println(red1)
  }
}

// 继承 Enumeration 特质
object Enum extends Enumeration{

  // 定义多个枚举,返回的是自身
  val RED, YELLOW, GREEN = Value
  val RED1 = Enum
}

RED
Enum

特质

• 像抽象类, 可以有抽象成员和非抽象成员
• 像java接口, 可以多重继承, 第一个继承使用extends之后的使用with隔开
• 当多个特质拥有相同名的方法时, 默认调用最右边的特质的方法
• 需要调用多个特质的相同方法, 使用super调用父类的方式来实现链式调用

package base

object TraitDM {
  def main(args: Array[String]): Unit = {

    val t = new CT
    t.Log("this is a log!")

  }
}

trait T {
  // 普通方法
  def Log(info: String): Unit = {

  }
}

// 继承 T
trait T1 extends T {
  override def Log(info: String): Unit = {
    println(s"T1 info = $info")
    // 调用 父特质的Log方法
    super.Log(info)
  }
}

trait T2 extends T {
  override def Log(info: String): Unit = {
    println(s"T2 info = $info")
    super.Log(info)
  }
}

class CT extends T1 with T2 {
  override def Log(info: String): Unit = {
    super.Log(info)
  }
}

T2 info = this is a log!
T1 info = this is a log!