kotlin-2-class related basic knowledge

Kotlin classes can contain: constructors and initialization blocks, functions, properties, inner classes, object declarations.

1, class basic information

Like java, kotlin can use the class keyword to identify, but not only the class, but also the object keyword.

The class marked with class is a public final type, which cannot be inherited by default. If it needs to be inherited, you need to use the open keyword.

The class marked with object is a static class by default, and the methods in it look ordinary, but they are all static static methods by default.

fun main(args: Array<String>) {
    var test = TTson()
    test.printt()
    StaticTT.printHello()
}

class TTson : TestTT() {//继承TestTT

}

open class TestTT {  //使用open表示可继承
    fun printt() {
        print("hello TestTT")
    }
}

object StaticTT {
    fun printHello() {      //自带静态方法加持
        print("Hello Static TT")
    }
}

2, construction method

1,白银操作
class TestTT {
    var name: String? = null

    constructor() {//使用constructor()函数来表示当前为构造方法

    }

    constructor(name: String) {//另一个构造方法 中规中矩 和java基本一毛一样
        this.name = name
    }
}

2,黄金操作
class TestTT constructor(name: String) { //构造方法移到上面去了 主构造方法
    var name: String? = null

    init {
        this.name = name                //再调用init代码块,如果有多个代码块,按顺序执行
    }
}

3,钻石操作
class TestTT (name: String) {
    var name: String? = null

    init {
        this.name = name
    }
}

4,荣耀操作
class TestTT (var name: String) {//直接在主构造方法中定义变量

    fun printName(){
        print(name)
    }
}

5,王者操作 如果是纯bean类,可以使用class data来定义
data class TestTT(var name: String)

3, init code block

class TestTT constructor(var name: String, var addr: String) {  //主构造方法
    var age: Int = 0

    init {
        println("this is init $name")
    }

    constructor(age: Int, name: String) : this(name, "默认") {//所以这里通过this执行了类定义的构造方法
        this.age = age
        println("this is constructor")
    }

    fun printName() {
        println("$name   $age   $addr")
    }

}

调用
TestTT("monkeyking", "江西").printName()
TestTT(18, "monkey").printName()

输出日志:
this is init monkeyking//执行init代码块 name已被赋值,说明主构造方法先执行
monkeyking   0   江西

this is init monkey//执行init前已经对name进行定义初始化
this is constructor//最后才执行次构造方法
monkey   18   默认

总结:
1,先执行主构造方法
2,再执行init代码块
3,再执行次构造方法

4, nested class

嵌套类 2个类相互独立,嵌套的类定义在一个类内部

fun main(args: Array<String>) {
    var nest = Out.Nest() 外部类.嵌套类
    nest.printNest()
}

class Out {
    class Nest {
        fun printNest() {
            println("this is Nest")
        }
    }
}

5, inner class

内部类 先有外部类再有内部类,内部类可以持有外部类的引用
fun main(args: Array<String>) {
    var nest = Out().Inner()//先实例Out再实例Inner
    nest.printNest()
}

class Out {
    var name = "OUT"

    inner class Inner {
        var name = "INNER"
        fun printNest() {
            println("this is Nest,this is $name")
            println("now I call Out's name " + [email protected])//通过this@Out获得外部类的引用
        }
    }
}

6, class modifiers

类的修饰符包括 classModifier 和 accessModifier

classModifier: 类属性修饰符，标示类本身特性。
abstract    // 抽象类  
final       // 类不可继承，默认属性
enum        // 枚举类
open        // 类可继承，类默认是final的
annotation  // 注解类

accessModifier: 访问权限修饰符
private    // 仅在同一个文件中可见
protected  // 同一个文件中或子类可见
public     // 所有调用的地方都可见
internal   // 同一个模块中可见

7, inheritance and interface

继承同接口同java的语法是一样的,无非是语句不一样
java的继承 class Son extends Parent{}
kotlin的继承 class Son : Parent(){}

java的接口实现 class AA implements BB{  重写方法 }
kotlin的接口实现 class AA : BB { 实现方法 }

8, companion class

fun main(args: Array<String>) {
    TestTT.name = "atongmu"
    TestTT.sayHello()
}

class TestTT {

    companion object {      //伴生类 里面的属性和方法都是static 静态的,最多可以有一个
        var name: String? = null

        fun sayHello() {                //静态方法
            println("hello, $name")
        }
    }
}

9, data class data class

fun main(args: Array<String>) {

    var test = TestTT("sunguanyong", 18)
    println(test.toString())
}

class TestTT(var name: String, var age: Int)

输出:com.example.app.TestTT@355da254          //普通类的toString()  

fun main(args: Array<String>) {

    var test = TestTT("sunguanyong", 18)
    println(test.toString())
}

data class TestTT(var name: String, var age: Int)

输出:TestTT(name=sunguanyong, age=18)         //数据类的toString()已经被重写了

10. Expand attributes and methods

fun main(args: Array<String>) {

    var test = TestTT("sunguanyong", 18)
    test.print()
    println(test.addr)
}

fun Any.sayHello() {//给Any类拓展了一个方法
    println("hello")
}

fun TestTT.print() {
    println("hello,我是拓展函数")
}

val TestTT.addr: String
    get() = "hello,我是拓展属性"

class TestTT(var name: String, var age: Int)