抽象类（Abstract Class）

scala定义抽象类

1. 抽象类是不能被实例化的
2. 一个含有抽象方法的类必须定义成抽象类，也就是使用abstract关键字来定义类
3. 抽象类可以有抽象类型（type）
4. 抽象类可以包含抽象字段
5. ...............................

下面是一个简单的抽象类的定义

/**
 *
 * @param name
 * @param age
 */
abstract class Staff(name: String, age: Int) {

  /**
   * scala中的抽象字段
   */
  var _department: String

  def department: String = _department

  def department_=(newValue: String): Unit = _department = newValue

  /**
   * 定义参数为空，返回值为Unit的抽象方法
   */
  def doWork(): Unit

  /**
   * 抽象方法
   * @param value
   * @return
   */
  def echo(value: String): String

  def work() = {
    println("start work")
    this.doWork()
    println("work end")
  }
}

下面是对上面父类的继承和实现

/**
 * 只有子类的主构造器可以调用父类的主构造器
 * @param name
 * @param age
 * @param address
 */
class NormalStaff(name: String, age: Int, address: String) extends Staff(name: String, age: Int) {
  override var _department: String = _

  def this(name: String, age: Int) {
    this(name, age, "UNKNOW");
  }

  // 实现父类的抽象方法
  override def doWork(): Unit = {
    println("I‘m doing some job")
  }

  /**
   * 抽象方法
   * 必须使用override关键字
   * @param value
   * @return
   */
  override def echo(value: String): String = value

  override def toString = "NormalStaff [name=" + this.name + ",age=" + this.age +
    ",department=" + this._department + "]"
}

抽象类的抽象类型

class Food

abstract class Animal {
  type SuitableFood <: Food

  def eat(food: SuitableFood)
}

class Grass extends Food

class Cow extends Animal {
  type SuitableFood = Grass

  override def eat(food: Grass) {}
}

使用type关键字定义一个抽象类型，type SuitableFood，并指明他的上界是 Food。

abstract class Abstract {
  type T

  def transform(x: T): T

  val initial: T
  var current: T
}

class Concrete extends Abstract {
  override type T = String

  override def transform(x: T): T = x + x

  //在Java里这是final变量，所以必须要初始化赋值
  override val initial: T = "string"
  //在Java里这个private类型变量，在scala中可以yoga下划线赋值
  override var current: T = _
}

在这个例子中使用type关键字定义了抽象类型T，在实现类中要覆写并指明抽象类型的具体类型 override type T = String。。

抽象类的抽象字段

abstract class Abstract {
  type T

  def transform(x: T): T

  val initial: T
  var current: T
}

在这里用val和var定义的成员变量都没有初始化，经过scala的编译后的字节码，反编译后在java类里都是抽象方法

C:\WorkSpace5-gitosc\scala-sample\out\production\scala-sample\com\usoft3>javap -p Abstract.class
Compiled from "test.scala"
public abstract class com.usoft3.Abstract {
  public abstract java.lang.Object transform(java.lang.Object);
  public abstract java.lang.Object initial();
  public abstract java.lang.Object current();
  public abstract void current_$eq(java.lang.Object);
  public com.usoft3.Abstract();
}

=====================

val initial: T
var current: T

对应的java类的抽象方法就是，

public abstract java.lang.Object initial();
public abstract java.lang.Object current();

============================END============================