kotlin之类与继承

落日映苍穹つ 2023-01-08 05:26 176阅读 0赞

# 类与继承 #

## 类 ##

使用class关键字来定义一个类：

class Invoice {  /*...*/ }

一个类由类名、类的头部（参数类型、主要构造方法）和类的内容，并用花括号括起来。其中头部和内容是可以省略的，如果一个类没有内容，花括号都可以省略，类似下面这样：

class Empty

## 构造方法 ##

一个类可以有一个主要构造方法和一个或者多个次要构造方法，主要构造方法是类的头部的一部分，主要构造方法紧跟在类名的后面：

class Person constructor(firstName: String) {  /*...*/ }

如果主要构造方法没有被任何注解或可见性修饰符修饰，**constructor**关键字都可以省略。

class Person(firstName: String) {  /*...*/ }

主要构造方法不能包含任何代码，初始化的代码可以初始化块中执行，初始化块可以使用init关键字声明，初始化块的执行顺序会按照代码出现中的顺序执行，可以出现多次：

//sampleStart
    class InitOrderDemo(name: String) { 
        val firstProperty = "First property: $name".also(::println)
    
        init { 
            println("First initializer block that prints ${ name}")
        }
    
        val secondProperty = "Second property: ${ name.length}".also(::println)
    
        init { 
            println("Second initializer block that prints ${ name.length}")
        }
    }
    //sampleEnd
    
    fun main() { 
        InitOrderDemo("hello")
    }

主要构造方法的参数可以用在初始化块，也可以使用在属性的初始化时。

class Customer(name: String) { 
        val customerKey = name.toUpperCase()
    }

实际上，可以直接将主构造方法中的参数直接声明为属性，语法如下：

class Person(val firstName: String, val lastName: String, var age: Int) {  /*...*/ }

如果主要构造方法需要被任何注解或可见性修饰符修饰时，**constructor**关键字不可以省略。

class Customer public @Inject constructor(name: String) {  /*...*/ }

#### Secondary constructors ####

class Person { 
        var children: MutableList<Person> = mutableListOf()
        constructor(parent: Person) { 
            parent.children.add(this)
        }
    }

如有类有一个**primary constructor**，那么**secondary constructor**中需要调用**primary constructor**，可以显示的调用**primary constructor**，也可以通过其他的**secondary constructor**间接的调用。

class Person(val name: String) { 
        var children: MutableList<Person> = mutableListOf()
        constructor(name: String, parent: Person) : this(name) { 
            parent.children.add(this)
        }
    }

注意初始化块是**primary constructor**的一部分，那么初始化块代码的执行会在**secondary constructor**之前执行，即使没有**primary constructor**，初始化代码块也会执行。

//sampleStart
    class Constructors { 
        init { 
            println("Init block")
        }
    
        constructor(i: Int) { 
            println("Constructor")
        }
    }
    //sampleEnd
    
    fun main() { 
        Constructors(1)
    }

如果一个非抽象的类没有声明任何构造方法，kotlin会自动生成一个无参的public修饰的**primary constructor**，如果希望一个不是public的，可以使用private修饰或者不带

class DontCreateMe private constructor () {  /*...*/ }

如果**primary constructor**中所有的参数都有默认值，那么kotlin会为此类自动生成一个无参的构造方法：

class Customer(var name: String = "") { 
    }

反编译字节码，能看到kotlin自动生成的无参构造方法：

$ javap  com.morris.kotlin.clazz.Customer
    Compiled from "Customer.kt"
    public final class com.morris.kotlin.clazz.Customer { 
      public final java.lang.String getName();
      public final void setName(java.lang.String);
      public com.morris.kotlin.clazz.Customer(java.lang.String);
      public com.morris.kotlin.clazz.Customer(java.lang.String, int, kotlin.jvm.internal.DefaultConstructorMarker);
      public com.morris.kotlin.clazz.Customer();
    }

## 继承 ##

kotlin中所有的类都有一个共同的父类`Any`，类似java中的`Object`。

class Example // Implicitly inherits from Any

`Any`类中有三个方法：`equals()`, `hashCode()` and `toString()`，因此所有的kotlin类都有这些方法。

在kotlin中，所有的类默认都是final，也就说不能被继承。如果想要类能被继承，需要使用`open`关键字声明。

open class Base(p: Int)
    
    class Derived(p: Int) : Base(p)

如果子类有**primary constructor**，那么必须在**primary constructor**声明时初始化父类。

如果子类没有**primary constructor**，那么可以在每个**secondary constructor**中使用super关键字调用父类的构造方法。  
必须在**primary constructor**声明时初始化父类。

class MyView : View { 
        constructor(ctx: Context) : super(ctx)
    
        constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
    }

### 重写方法 ###

与类的继承类似，方法想要被重写，需要使用open关键字来修饰：

open class Shape { 
        open fun draw() {  /*...*/ }
        fun fill() {  /*...*/ }
    }
    
    class Circle() : Shape() { 
        override fun draw() {  /*...*/ }
    }

父类需要使用open关键字来标识方法可以被继承，子类需要使用override关键字来标识重写了父类的方法。

子类使用override重写的方法还是open的，也可以被他的子类重写，如果不想被重写，可以使用final关键字修饰：

open class Rectangle() : Shape() { 
        final override fun draw() {  /*...*/ }
    }

### 重写属性 ###

重写属性与重写方法类似：

open class Shape { 
        open val vertexCount: Int = 0
    }
    
    class Rectangle : Shape() { 
        override val vertexCount = 4
    }

`var`类型的属性可以重写`val`类型的属性，`val`类型的属性不能重写`var`类型的属性。`var`属性代表着有getter和setter方法，`val`属性代表着只有getter方法，var变成val，意味着减少了setter方法，这是不允许的，会导致多态失效。

也可以在子类的primary constructor中重写父类的属性：

interface Shape { 
        val vertexCount: Int
    }
    
    class Rectangle(override val vertexCount: Int = 4) : Shape // Always has 4 vertices
    
    class Polygon : Shape { 
        override var vertexCount: Int = 0  // Can be set to any number later
    }

### 派生类的初始化顺序 ###

与java一样，子类初始化之前需要先初始化父类。

package com.morris.kotlin.clazz
    
    open class Base(name: String) { 
    
        init {  println("Initializing Base") }
    
        open val size: Int =
            name.length.also {  println("Initializing size in Base: $it") }
    }
    
    class Derived(name: String, lastName: String
    ) : Base(name.capitalize().also {  println("Argument for Base: $it") }) { 
    
        init {  println("Initializing Derived") }
    
        override val size: Int =
            (super.size + lastName.length).also {  println("Initializing size in Derived: $it") }
    }
    
    fun main() { 
        Derived("hello", "world")
    }

运行结果如下：

Argument for Base: Hello
    Initializing Base
    Initializing size in Base: 5
    Initializing Derived
    Initializing size in Derived: 10

### 调用父类的实现 ###

可以在子类中使用super关键字调用父类的方法或者属性：

open class Rectangle { 
        open fun draw() {  println("Drawing a rectangle") }
        val borderColor: String get() = "black"
    }
    
    class FilledRectangle : Rectangle() { 
        override fun draw() { 
            super.draw()
            println("Filling the rectangle")
        }
    
        val fillColor: String get() = super.borderColor
    }

子类的内部类中调用外部类的父类的方法或属性：

open class Rectangle { 
        open fun draw() {  println("Drawing a rectangle") }
        val borderColor: String get() = "black"
    }
    
    //sampleStart
    class FilledRectangle: Rectangle() { 
        override fun draw() { 
        	val filler = Filler()
            filler.drawAndFill()
        }
    
        inner class Filler { 
            fun fill() {  println("Filling") }
            fun drawAndFill() { 
                super@FilledRectangle.draw() // Calls Rectangle's implementation of draw()
                fill()
                println("Drawn a filled rectangle with color ${ super@FilledRectangle.borderColor}") // Uses Rectangle's implementation of borderColor's get()
            }
        }
    }
    //sampleEnd
    
    fun main() { 
        val fr = FilledRectangle()
            fr.draw()
    }

### 重写规则 ###

如果父类或者父接口中同一个方法的实现有多个，那么子类需要自己必须重写此方法。

open class Rectangle { 
        open fun draw() {  /* ... */ }
    }
    
    interface Polygon { 
        fun draw() {  /* ... */ } // interface members are 'open' by default
    }
    
    class Square() : Rectangle(), Polygon { 
        // The compiler requires draw() to be overridden:
        override fun draw() { 
            super<Rectangle>.draw() // call to Rectangle.draw()
            super<Polygon>.draw() // call to Polygon.draw()
        }
    }

## 抽象类 ##

与java中的抽象类差不多，抽象方法没有方法实现，只有方法声明，抽象类和抽象方法是open的，无需手动指定。

open class Polygon { 
        open fun draw() { }
    }
    
    abstract class Rectangle : Polygon() { 
        abstract override fun draw()
    }

## 伴生对象 ##

伴生对象类似与java中的静态方法：

class Companion { 
    
        companion object { 
            var name = "hello"
    
            fun method() { 
                println("method")
            }
        }
    
    }
    
    fun main() { 
        println(Companion.name)
    
        Companion.method()
    }

伴生对象可以指定名字，也可以不指定，默认名为Companion。