Kotlin(二)：类和接口

类

kotlin类包含：构造函数和初始化代码块、函数、属性、内部类、对象声明

类属性

setter and getter

setter 和getter 和java完全不一样
kotlin的声明方法

var <propertyName>[: <PropertyType>] [= <property_initializer>]
    [<getter>]
    [<setter>]

实例

class Person {

    var lastName: String = "zhang"
        get() = field.toUpperCase()   // 将变量赋值后转换为大写
        set

    var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

    var heiht: Float = 145.4f
        private set
        
// 测试
fun main(args: Array<String>) {
    var person: Person = Person()

    person.lastName = "wang"

    println("lastName:${person.lastName}")

    person.no = 9
    println("no:${person.no}")

    person.no = 20
    println("no:${person.no}")

}
}

Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器

通俗来说，field相当于this.属性名

构造函数

主构造器

主构造器是在类名旁边进行声明的，使用关键字constructor(可省略) 带上传入的的参数。

class Person constructor(firstName: String) {
    init {
        println("FirstName is $firstName")
    }
}

在主构造器中不能写任何代码，因此类的初始化只能交由init{} 代码块中执行，在init{}可以调用主构造器传入的参数。

实例
创建一个类，并通过构造函数传入值

class Demo (name:String){
   var name:String = name
}

// 在main函数中   输出结果为 xxxx
  var demo : Demo = Demo("xxxx")
    print(demo.name)
    

次构造器

次构造函数必须要加前缀

// 第一种方式
class Demo{
    
    constructor(age:Int,name:String){

    }

}

// 第二种方式
class Demo (name:String){

    constructor(age:Int,name:String) : this(name){

    }

}

如果类有主构造函数，每个次构造函数都要，或直接或间接通过另一个次构造函数代理主构造函数。在同一个类中代理另一个构造函数使用this关键字
换言之，如果类有主构造器，那么如果要声明次构造器则必须调用主构造器

私有构造器

class DontCreateMe private constructor () {
}

静态方法

在实现私有构造器后，就无法通过常规方法创建对象，因此可以通过静态方法获取一个实例。
在kotlin中如何实现静态方法

// 方法一
companion object {
     fun test(){
        、、、
      }
}
// 方法二
companion object StaticParams {
     fun test(){
        、、、
      }
}

companion object {}中可以包含静态常量，或者静态方法，单例等等。

在声明属性的时候就需要对setter和setter进行声明（也可以无视，不声明）

继承

Kotlin中所有类都继承Any类，它是所有类的超类

如果一个类要被继承，可以使用open关键字进行修饰

kotlin继承一个类的方式和C#类似 使用 ‘：’ 冒号

open class Base(p: Int)           // 定义基类
class Derived(p: Int) : Base(p)

重写

使用fun声明函数时，默认会使用final修饰，因此无法被重写，如果需要被重写基类的函数需要使用open修饰，而子类的函数需要使用override关键字

/**用户基类**/
open class Person{
    open fun study(){       // 允许子类重写
        println("我毕业了")
    }
}

/**子类继承 Person 类**/
class Student : Person() {

    override fun study(){    // 重写方法
        println("我在读大学")
    }
}

嵌套类和内部类

嵌套类和内部类都是一个类写在另一个类里，但是它们是有区别的

// 嵌套类
class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun foo() = 2
    }
}

// 内部类
class Demo {
    var name = "Chenchangsheng"
    var age = 99
    inner class DemoInner{
        // 可以访问外部类的的属性
        var innerName=name;
        fun getOutterDemo(){
            // 通过标签分别获取外部类和内部类的对象
            var outer = this@Demo
            var inner = this@DemoInner
        }
    }
}

可以发现 内部类必须使用。inner 关键字定义 并且 与嵌套类不同的是，内部类持有外部类的引用，可以访问外部类的属性和方法

接口

kotlin 接口与java8类似，使用interface关键字定义接口，允许方法有默认实现(java8之后支持接口方法有默认实现，声明方法的时候 使用static或default关键字定义)

实现接口

open class A{
}
interface B{
}
// 继承类 
class C:A(){
}

// 实现接口
class D:B{
}

注意在继承类的时候会比实现接口对一对括号