Kotlin中类、构造器、对象

绝地灬酷狼 2022-03-17 05:19 299阅读 0赞

**1.Kotlin中类的定义**

类的构成:

*  类的构成由`构造函数和初始化代码块、属性（字段）、函数（方法）、内部类（嵌套类）、对象声明`五部分组成

//Kotlin中也是使用class关键字创建类的
    class Empty

**2.创建类的对象**

fun main(args: Array<String>) {
        val empty=Empty()  //Kotlin中创建对象无new关键字
    }

**3.创建类的构造器**

Kotlin当没有创建构造器时，与Java类似的是，与Java类似的就是当没有显示提供主函数时，Kotlin会为其生成一个无参构造。

/**
     * 构造器 constructor Kotlin中有一个主构造函数和多个二级构造函数
     * 主构造函数是类头的一部分，跟在类名后面
     * 在Java中，构造方法必须和类名相同，而在Kotlin中，是通过constructor关键字来标明的
     */
    class Student constructor(name: String, age: Int) {
        private val username: String
        private var age: Int
    
        //在Kotlin中使用init初始化代码块，它的作用是为了主构造函数服务的，由于主构造函数是放在类首部的，是不能包含任何初始化执行语句的，这是语法规定的，那么这个时候就有了init的用武之地，
        // 我们可以把初始化执行语句放置在此处，为属性进行赋值
        init {
            this.username = name
            this.age = age
        }
    }
    
    //写法二 : 可将constructor关键字去掉
    class Student2(username: String, age: Int) {
        private val username: String
        private val age: Int
    
        init {
            this.username = username
            this.age = age
        }
    }
    
    //写法三 初始化语句不是必须放在init代码块中的，也可以定义属性的时候初始化
    class Student3(username: String, age: Int) {
        private val username: String = username
        private var age: Int = age
    }
    //写法四，直接在构造器中定义类的属性
    class Student4(private val username: String,private val age: Int){}
    
    //次构造函数,与主构造函数的区别就是，次构造函数定义在类中，可以有多个，但是主构造函数只会有一个
    class Users{
        private val username:String
        private val age:Int
    
        constructor(username: String,age: Int){
            this.username=username
            this.age=age
        }
    }

**4.创建抽象类**

用来创建基类，封装常用的方法，以及处理一些共有的逻辑，而这个所谓的基类一般都是抽象类。

Kotlin中抽象类的定义

抽象类，可以理解为类定义了一个模板。所有的子类都是根据这个模板是填充自己的代码。

关键字：abstract

抽象可以分为:抽象类、抽象函数、抽象属性。而一个抽象类和普通类的区别在于抽象类除了可以有其自己的属性、构造函数、方法等组成部分，还包含了抽象函数以及抽象属性。

![20190222182338634.png][]

抽象类的定义及具体的实现类

class TestAbstractA :Lanauge(){
        override var name: String="Kotlin"
        override fun init() {
    //        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
            println("我是${name}")
        }
    }
    
    class TestAbstractB :Lanauge(){
        override var name: String
        get() = "Java"
        set(value) {}
        override fun init() {
           // TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
            println("我是${name}")
        }
    }
    
    fun main(args: Array<String>) {
        val ta=TestAbstractA()
        val tb=TestAbstractB()
        println(ta.name)
        println(tb.name)
                ta.init()
        tb.init()
    }

**抽象类的特点：**

*  抽象类本身具有普通类特性，以及组成部分。不过值得注意的是，**抽象类不能直接被实例化**
 *  其抽象了类的子类必须全部重写带`abstract`修饰的属性和方法。
 *  抽象成员只有定义，没有实现。都有`abstract`修饰符修饰。
 *  抽象类是为其子类定义了一个模板。不同是类实现不同的功能

**\*\*\*抽象类还可以继承自一个继承类**

//使用open，这个类声明有open属性，可以被其他类继承
    open class Base {
        open fun init() {}
    }
    
    //抽象类还可以继承自一个继承类
    abstract class Lanauge2 : Base() {
        override fun init() {
            super.init()
        }
        abstract class Name() {} //抽象类的嵌套
    }

**5.嵌套类**

/**
     * 嵌套类
     */
    class Other {
        val numOuther = 1
    
        class Nested{
            fun init(){
                println("执行了init方法")
            }
        }
    }
    
    //嵌套类的使用
    
     Other.Nested().init()  //调用格式为：外部类.嵌套类().嵌套类 方法/属性

**6.嵌套内部类**

//嵌套内部类
    class Othert{
        val mumOther=1
    
        inner class InnerClass{
            val name="InnerClass"
            fun init(){
                println("我是内部类")
            }
        }
    }
    
    在主函数中调用
     Othert().InnerClass().init() // 调用格式为：外部类().内部类().内部类方法/属性

**7.匿名内部类的定义**

fun main(args: Array<String>) {
     //测试内部类
        val inner=Inner()
        inner.setOnClickListener(object : OnClickListener{
            override fun onItemClick(str: String) {
                println(str)
            }
        })
        inner.testListener()
    }
    class Inner{
        //lateini(延迟加载) 只能修饰, 非kotlin基本类型
        //因为Kotlin会使用null来对每一个用lateinit修饰的属性做初始化，而基础类型是没有null类型，所以无法使用lateinit。
        lateinit private var listener:OnClickListener
        fun setOnClickListener(listener: OnClickListener){
            this.listener=listener
        }
    
        fun testListener(){
            listener.onItemClick("我是匿名内部类的测试方法")
        }
    }
    
    interface OnClickListener{
        fun onItemClick(str:String)
    }

**8.定义局部类**

class Local{    // 外部类
        val numOther = 1
    
        fun partMethod(){
            var name : String = "partMethod"
    
            class Part{
                var numPart : Int = 2
    
                fun test(){
                    name = "test"
                    numPart = 5
                    println("我是局部类中的方法")
                }
            }
    
            val part = Part()
            println("name = $name \t numPart = " + part.numPart + "\t numOther = numOther")
            part.test()
            println("name = $name \t numPart = " + part.numPart + "\t numOther = numOther")
        }
    }
    
    fun main(args: Array<String>) {
        // 测试局部类
        Local().partMethod()
    }

[20190222182338634.png]: /images/20220317/8511a6268c58435580147b563e6d1c0b.png