Scala Abstract Class(抽象类)

抽象类(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============================

时间: 2024-10-15 03:47:48

Scala Abstract Class(抽象类)的相关文章

scala入门-06抽象类(abstract)的使用

在scala下的org.scala.clazz下创建AbstractScala.scala 创建抽象类 使用abstract关键字 ITCoder类继承Person类并重写speak方法,重写超类的抽象方法时,不需要使用override关键字. 但你使用override关键字 也可以 App内部帮我们实现了main方法并管理工程师写的代码 抽象类中未被初始化的变量的使用 你可以定义一个抽象类,抽象类可以定义一些方法,但是不需要实现它们.相反,继承抽象类的子类需要实现这些方法.抽象类是不能被实例化

[Scala基础系列 08]Scala继承、抽象类、接口trait以及AOP实现

1.继承 和java一样,scala采用extends关键字继承基类.代码实例如下: /** * Created by molyeo on 2015/8/11. */ class Person(val name: String, var age: Int) { println("The primary constructor of Person") val school = "BJU" def sleep = "8 hours" override

SCALA中的抽象类代码样例

package com.hengheng.scala class AbstractClass { } abstract class People { def speak val name : String var age : Int } class Worker extends People { def speak { println("Hello, Worker!!!") } val name = "Rocky" var age = 27 } object Abs

scala -abstract 类

定义一个抽象类 abstract class Animal {   def walk(speed:Int)   def breathe() = {     println("animal breathes")   } } 在具体Dog中 我们必须实现Animal实现的抽象方法 class Dog extends Animal {   override def walk (speed :Int) = {     println("dog walks, speed is &quo

abstract class抽象类和interface接口区别

含有 abstract 修饰符 class 即为抽象类,抽象类不能创建实际对象,含有抽象方法的抽象类必须定义为 abstract class. 接口可以说成是一种特殊的抽象类,接口中的所有方法都必须是抽象的,接口中的方法定义默认为 public abstract 类型,接口中的成员产量类型默认为 public static final. 两者的区别: a. 抽象类可以有构造方法,接口中不能有构造方法. b. 抽象类中可以有普通成员变量,接口中没有普通成员变量. c. 抽象类中可以包含非抽象普通方

c# interface(接口)和abstract(抽象类)区别

抽象类依然是一个类,不能被实例化,可以包含字段.成员变量.抽象方法.或者不抽象方法. 类继承抽象类,只重写抽象方法即可,其他是可以得到继承的. 接口是规则,里面只包含:方法.属性.索引.事件.类继承接口,类必须实现所有接口定义.

Java中的抽象类abstract

abstract定义抽象类 abstract定义抽象方法,只需要声明,不需要实现 包含抽象方法的类是抽象类 抽象类中可以包含抽象方法,也可以包含普通方法 抽象类不能直接创建,可以定义父类引用变量指向子类的对象 子类继承抽象类,必须实现父类中的抽象方法 抽象类的应用场景: 1.父类只知道子类应该包含的方法,但是不知道子类如何去实现这些方法,约束子类必须有哪些方法,但是并不关心它如何实现. 2.从多个具有相同特征的类中抽象出一个抽象类,以抽象类作为子类的模板,避免子类设计的随意性 package c

接口 interface ,抽象类 abstract

接口是类的模板,类是对象的模板. 使用关键字interface 定义了一个接口Person,接口中有两个方法: 使用关键字implements实现了接口,实现类Man里需要实现接口中的所有方法,否则会报错. L类中的factory方法是调用接口的一个例子,其中传入的参数$user 使用了 Person 接口进行了类型限制,说明传入的参数必须是实现了Person接口的类(比如说Man类). 接口可以被多次实现,比如把代码中的Man类复制粘贴改成Woman类,就是另外一次实现接口了. 接口也是可以被

Java中抽象类和接口的区别(abstract class VS interface)

前言:本文解决的问题 什么是抽象类 抽象类的应用场景 接口可以有方法实现吗 接口和抽象类的区别 1 什么是抽象类 在声明时含有关键字abstract就是抽象类,抽象类它可以看作具体类的一个模板,继承它的子类可以从抽象类中共享一些方法(可能是不完整的)和属性. A class which is declared with the abstract keyword is known as an abstract class in Java. It can have abstract and non-