Kotlin——02.类和对象

类的定义

Kotlin 类可以包含：构造函数，初始化代码块、函数、属性、内部类、对象声明。
Kotlin 中使用关键字 class 声明类，后面紧跟类名：

class Person{  // 类名为 Person
    // 大括号内是类体构成
}

可以在类中定义成员函数：

class Person {

    fun eat() { //成员函数
        println("吃饭")
    }
}

类的属性

类的属性可以用关键字 var 声明为可变的，否则使用只读关键字 val 声明为不可变。

class Person {
    var name:String = "张三"
    var age :Int = 25

    fun eat() {
        println("吃饭")
    }
}

构造函数

• 主构造函数
  Koltin 中的类可以有一个主构造器，以及一个或多个次构造器，主构造器是类头部的一部分，位于类名称之后:

fun main(args: Array<String>) {
    var techer = Teacher("张三")
    techer.eat()
}

class Teacher constructor(name:String) {
    var techname = name

    fun eat() {
        println(techname + "吃饭")
    }
}

如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略。

class Teacher (name:String) {
    ...
}

• 次构造函数

class Person {
    constructor(name:String) {
		...
    }
}

实例

fun main(args: Array<String>) {
    val runoob =  Person("张三", 25)
    runoob.printTest()

}
class Person  constructor(name: String) {  // 类名为 Runoob
    // 大括号内是类体构成
    init {
        println("初始化名字: ${name}")
    }
    // 次构造函数
    constructor (name: String, age: Int) : this(name) {
        println("年龄 $age")
    }
    fun printTest() {
        println("我是类的函数")
    }
}

输出：

初始化名字: 张三
年龄 25
我是类的函数

重写

在基类中，使用fun声明函数时，此函数默认为final修饰，不能被子类重写。如果允许子类重写该函数，那么就要手动添加 open 修饰它, 子类重写方法使用 override 关键词：

fun main(args: Array<String>) {

    var techer = Teacher()
    techer.eat()
}

open class Person  {
   open fun eat(){
       println("吃饭")
   }
}

class Teacher : Person(){
    override fun eat() {
        super.eat()
        println("吃面条")
    }
}

输出：

吃饭
吃面条

接口

fun main(args: Array<String>) {

    Bird().fly()
}

interface Fly{
    fun fly()
}

class Bird : Fly{
    override fun fly() {
        println("呼呼呼的飞")
    }
}

接口中的属性

接口中的属性只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性：

interface Fly{

    var color :String //颜色，属性，抽象的

    fun fly()
}

class Bird : Fly{
    override  var color : String = "黑色"
    
    override fun fly() {
        println("$color 呼呼呼的飞")
    }
}