Abstract vals && Abstract vars

Abstract vals && Abstract vars

在scala中抽象类和特质都可以定义抽象的成员变量。

Abstract vals && Abstract vars

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 = _
}

object Main9 {
  def main(args: Array[String]): Unit = {
    val c = new Concrete
    println(c.initial) //string
    println(c.current) //null
  }
}

如上的示例，定义两个抽象的成员变量，

val initial: T
var current: T

同时实现类实现抽象类的时候必须要赋值重写。在Java里看起来很怪，那么在Java里是如何实现的呢，通过javap反编译看一下

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();
}

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

其实在scala中定义的抽象字段在反编译后的java类中，其实就是抽象方法，

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

那么也就不难理解了。

Initializing abstract vals

如下定义的抽象类中含有两个抽象变量

abstract class Abstract {
  val numerArg: Int
  val denomArg: Int
}

javap 反编译Abstract抽象类

C:\WorkSpace5-gitosc\scala-sample\out\production\scala-sample\com\usoft4>javap -p Abstract.class
Compiled from "test.scala"
public abstract class com.usoft4.Abstract {
  public abstract int numerArg();
  public abstract int denomArg();
  public com.usoft4.Abstract();
}

scala中实现抽象类的方式最简单的如下，同时也必须重写抽象变量

new Abstract {
  override val denomArg: Int = 1
  override val numerArg: Int = 2
}

我们打印一下这个实现类的className

println(new Abstract {
  override val denomArg: Int = 1
  override val numerArg: Int = 2
}.getClass.getName)

com.usoft4.Main9$$anon$1，javap反编译

C:\WorkSpace5-gitosc\scala-sample\out\production\scala-sample\com\usoft4>javap -p Main9$$anon$1.class
Compiled from "test.scala"
public final class com.usoft4.Main9$$anon$1 extends com.usoft4.Abstract {
  private final int denomArg;
  private final int numerArg;
  public int denomArg();
  public int numerArg();
  public com.usoft4.Main9$$anon$1();
}

反编译的Abstract抽象类中是没有定义的成员变量的，只是在抽象类的实现类中出现了父类的成员变量。

这其实就是Java中的匿名类的概念。

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