kotlin抽象类、密封类、接口

时间：2022-07-15 05:37:28

1.抽象类

（1）概念

​ 从多个具有相同特征的类中抽象出一个使用abstract修饰的类，以这个抽象类作为其子类模板，从而避免子类设计的随意性。抽象类的设计是一种模板模式的设计模式。

（2）特点

  • 抽象类、抽象属性、抽象方法都不需要open修饰符，open修饰符和abstract不能共存。

  • 抽象类不能实例化，但是可以有构造方法，构造方法是给子类用的。

  • 抽象类可以包含：属性（抽象属性或者非抽象属性）、方法（抽象方法或者非抽象方法）、构造器、初始化块、嵌套类（接口、枚举）5中成员。

  • 含有抽象成员（包括直接定义了一个抽象成员、或者继承了一个抽象父类但是没有完全实现父类包含的抽象成员、或者实现了一个接口但没有完全实现接口包含的抽象成员这三种情况）只能被定义为抽象类。

  • abstract不能修饰局部变量。

（3）抽象成员（抽象方法、抽象属性）

​ 抽象类里面使用abstract修饰的方法和属性。

  • 抽象方法不能有方法体。

  • 抽象属性不需要初始化。

（4）定义抽象类

下面是抽象类的定义方法

/**
 * 定义一个抽象类
 */
abstract class AbstractClass {
    //抽象属性，不能初始化
    abstract var abstractParam : String
    //抽象方法，不能有方法体
    abstract fun abstractFun()
    //普通属性，子类也可以重写，但是需要open修饰
    var commonParam : Int = 1
    //普通方法，子类也可以重写，但是需要open修饰
    fun commonFun() {
        //方法执行体
    }
    constructor() {
        //构造器，也可以在定义类时定义主构造器，抽象类的构造器是给子类用的，抽象类本身不能实例化
    }
}

下面是子类继承于抽象类的示例

fun main(args: Array<String>) {
    val fruit1 = Orange("橙子")
    val fruit2 = Apple()
    fruit1.eat()
    fruit2.eat()
}

/**
 * 水果抽象类
 */
abstract class Fruit {
    fun eat() {
        println("吃水果：$fruitName ，获取的水果重量${getFruitWeight()}")
    }
    abstract val fruitName : String
    abstract fun getFruitWeight() : Int
}

/**
 * 橘子子类
 */
class Orange(override val fruitName: String) : Fruit() {
    override fun getFruitWeight(): Int {
        return 10
    }
}

/**
 * 苹果子类
 */
class Apple : Fruit() {
    override fun getFruitWeight(): Int {
        return 20
    }

    override val fruitName: String
        get() = "苹果"

}

2.密封类（特殊的抽象类）

（1）概念

​ 密封类是一种特殊的抽象类，专门用来派生子类。使用sealed修饰符修饰。

（2）特点

​ 密封类的子类是固定的。

原因如下：

  • 密封类的子类必须与密封类在同一个文件。
  • 在其他文件中不能不能为密封类派生子类（但是密封类的子类可以被其他类继承）。

（3）定义密封类

/**
 * 密封类
 */
sealed class SealedClass {
    abstract fun sealedFun()
}

/**
 * 密封类子类1
 */
class SubClass1 : SealedClass() {
    override fun sealedFun() {
        
    }
}

/**
 * 密封类子类2（使用open修饰，可以在其他文件派生子类）
 */
open class SubClass2 : SealedClass() {
    override fun sealedFun() {
        
    }
}

3.接口

（1）概念

​ 接口定义了系统与外界交互的窗口或者说规范，规定了实现者必须向外界提供哪些服务（方法、属性）。

（2）特点

  • 修饰符：public|internal|private或者省略（省略即是public）；
  • 接口只能继承接口，不能继承类；
  • 接口中可以定义抽象/非抽象方法；
  • 接口中可以定义抽象属性/非抽象属性，但是接口中的费抽象属性是没有幕后字段（filed）的，因此需要为之提供get-set方法。
  • kotlin接口中的非抽象成员（方法、属性）可使用public|private两种访问权限修饰（java中自动为接口成员提供public修饰，如果指定访问权限也只能是public），抽象成员只能使用public修饰；
  • 接口不可以包含构造器和初始化块，但接口可包含：方法（抽象方法/非抽象方法）、属性（抽象属性/非抽象属性）、嵌套类（或嵌套接口、嵌套枚举）;
  • kotlin接口抽象成员的abstract关键字可以省略（抽象类的抽象成员不能省略）；
  • 接口不能实例化，但可以用来声明变量，通过该变量可以赋值给Any（向上转型，因为接口的子类对象一定是Any的子类）；
  • 接口的实现类实现该接口的抽象成员只能是public修饰。

（3）定义接口

fun main(args: Array<String>) {
    val person: Human = People("男", 5, 10)
    person.speak()
    (person as? Child)?.howOldAreYou()//向下转型为Child类型
    println("年级：${(person as? Student)?.grade}")//向下转型为Student类型
    val any : Any = person//person可以直接赋给Any
}

/**
 * 定义一个人类接口
 */
interface Human {
    //抽象属性，可省略abstract关键字，var type : String，只能使用public修饰
    abstract var type: String
    //非抽象属性，可以使用public|private访问权限符修饰
    val sex: String
        get() = type

    //非抽象方法，可以使用public|private访问权限符修饰
    fun speak() {
        if (canSpeak()) println("我是${sex}的") else println("不会说话")
    }

    //抽象方法，可省略abstract关键字，fun canSpeak() : Boolean
    abstract fun canSpeak(): Boolean
}

/**
 * 定义一个学生接口
 */
interface Student {
    val grade: Int
}

/**
 * 定义一个小孩抽象类
 */
abstract class Child {
    //抽象类的抽象属性，abstract不能省略
    abstract val age: Int
    //抽象类的非抽象方法（有方法体）
    fun howOldAreYou() {
        println("年龄：$age")
    }
}

/**
 * 定义Person类，继承于Child抽象类，实现了Student接口、Human接口，类后面的抽象类只能有一个，接口可以有多个，摆放顺序随意
 */
class People(override var type: String, override val grade: Int, override val age: Int) : Child(), Student, Human {
    override fun canSpeak(): Boolean {
        return true
    }
}
标签：

相关文章