Kotlin类和继承

1.类，构造函数，二级构造函数，创建类的实例
2.类成员
3.继承,复写方法,复写属性,复写规则
4.抽象类
5.密封类

类

在 Kotlin 中类用 class 时

class MainAct{
}

构造函数

在 Kotlin 中类可以有一个主构造函数以及多个二级构造函数。主构造函数是类头的一部分：跟在类名后面

class MainAct constructor(str:String){
}
//如果主构造函数没有注解或可见性说明，则 constructor 关键字是可以省略：
class MainAct(str:String){
}
//主构造函数不能包含任意代码。初始化代码可以放在以 init 做前缀的初始化块内
class MainAct(str:String){
  init{
    //todo
  }
}

二级构造函数

1.类也可以有二级构造函数，需要加前缀 constructor
2.如果类有主构造函数，每个二级构造函数都要，或直接或间接通过另一个二级构造函数代理主构造函数。在同一个类中代理另一个构造函数使用 this 关键字

class MainAct (){
  constructor (str:String){
  }
}
class MainAct (name:String){
   constructor(str: String,name:String) : this(str) {
        println("$str-$name")
    }
}
class MainAct private(){
}

创建类的实例

注意 Kotlin 没有 new 关键字。

 LoginAct("1","2")

类成员

类可以包含：

构造函数和初始化代码块 constructor and init
函数 fun
属性 val
内部类
对象声明

继承

Kotlin 中所有的类都有共同的父类 Any ，它是一个没有父类声明的类的默认父类
Any 不是 java.lang.Object；事实上它除了 equals(),hashCode()以及toString()外没有任何成员了。

open class Base {
    init {
        println("Base")
    }
}

class BaseAct : Base() {
    init {
        println("BaseAct")
    }
}

open注解与java中的final相反:它允许别的类继承这个类。默认情形下，kotlin 中所有的类都是 final

复写方法

我们在 kotlin 中坚持做明确的事。不像 java ，kotlin 需要把可以复写的成员都明确注解出来，并且重写它们

open class Base {
    open fun read() {}
    fun run() {}
}
class BaseMain : Base() {
    override fun read() {
    }
}

复写属性

复写属性与复写方法类似，在一个父类上声明的属性在子类上被重新声明，必须添加override，并且它们必须具有兼容的类型。每个被声明的属性都可以被一个带有初始化器的属性或带有getter方法的属性覆盖

open class Base {
    open val x = 1

    open fun read() {}
    fun run() {}
}

class BaseMain : Base() {

    override val x: Int get() = 2

    override fun read() {
    }
}

抽象类

一个类或一些成员可能被声明成 abstract 。一个抽象方法在它的类中没有实现方法。记住我们不用给一个抽象类或函数添加 open 注解，它默认是带着的。

我们可以用一个抽象成员去复写一个带 open 注解的非抽象方法

open class Base {
    open fun read() {}
}

abstract class BaseMain : Base() {
    abstract override fun read()
}

class BaseTitleMain : BaseMain(){
    override fun read() {
    }
}

密封类

密封类用于代表严格的类结构，值只能是有限集合中的某种类型，不可以是任何其它类型。这就相当于一个枚举类的扩展：枚举值集合的类型是严格限制的，但每个枚举常量只有一个实例，而密封类的子类可以有包含不同状态的多个实例。

声明密封类需要在 class 前加一个 sealed 修饰符。密封类可以有子类但必须全部嵌套在密封类声明内部

密封类通常与when语句一起使用，因为每个子类及其类型都作为个案

sealed class Shape {
    class Circle(var radius: Float):Shape()
    class Square(var length: Int): Shape()
    class Rectangle(var length: Int, var breadth: Int): Shape()
}
fun shapeType(shape:Shape) {
    when (shape){
        is Shape.Circle -> {
            println(shape.radius)
        }
        is Shape.Rectangle -> {
            println(shape.length)
        }
    }
}