Kotlin编程之伴生对象，抽象类，密封类

淩亂°似流年 2022-06-15 10:36 282阅读 0赞

**Kotlin编程相关知识点介绍**：

*  [Kotlin编程之使用Intellij IED和了解源文件（.kt）][Kotlin_Intellij IED_.kt]
 *  [Kotlin编程之类的介绍和使用][Kotlin]
 *  [Kotlin编程之类的属性][Kotlin 1]
 *  [Kotlin编程之方法][Kotlin 2]
 *  [Kotlin编程之父类和继承父类][Kotlin 3]
 *  [ Kotlin编程之接口和实现接口][Kotlin 4]

--------------------

本篇概括：

*  伴生对象
 *  抽象类
 *  密封类

## **伴生对象** ##

--------------------

package com.xingen.kotlin.day2017531
    
    fun main(args: Array<String>) {
        Test.instance.test()
        Test.test1()
    }
    class Test { 
         fun test() {
             println("伴生对象的静态调用对象，通过对象再调用方法")
        }
        companion object Factory{  // 伴生对象
            var instance =Test()
            fun  test1(){
                println("伴生对象的静态调用方法")
            }
        }
    }

输出结果：

伴生对象的静态调用对象，通过对象再调用方法
    伴生对象的静态调用方法

**可知**：

*  伴生对象可以实现静态调用，通过`类名.属性名`或者`类名.方法名`进行调用。

## **抽象类** ##

--------------------

package com.xingen.kotlin.day2017531
    
    fun main(args: Array<String>) {
        Test.instance.test()
         Test.instance.test1()
    }
    
    /** * 定义一个抽象类 * * 1. 抽象类中有抽象方法，方法的实现。 * 2. 抽象类和抽象方法是默认open关键字修饰的 */
    abstract  class TestAbstract{
        var v="抽象类中属性"
        abstract fun  test()
        fun test1(){
                  println("抽象类中方法的实现")
        }
    }
    class  Test :TestAbstract(){
        override fun test() {
           println("一个抽象类的子类中使用 $v")
        }
        companion object  Factory{
       //伴生对象
            var instance :TestAbstract=Test()
        }
    }

输出结果：

一个抽象类的子类中使用 抽象类中属性
    抽象类中方法的实现

**可知**：

*  抽象类和抽象方法是默认open关键字修饰的
 *  抽象类有抽象方法和方法的实现，可以有成员属性

## **密封类** ##

--------------------

通常与When语句一起使用,确保声明到所有的情形，不需要使用else语句。

在一个源文件（.kt）,编写以下代码：

package com.xingen.kotlin
    
    /** * Created by ${新根} on 2017/5/24 0024. * 博客：http://blog.csdn.net/hexingen */
    
    fun main(str: Array<String>) {
        test( BaseClass.Test1() )
        test( BaseClass.Test2() )
        test( BaseClass.Test3 )
    }
    
    /** * 使用when表达式 */
    
    fun test(instance: BaseClass)=when(instance){
        is BaseClass.Test1-> instance.test()
        is BaseClass.Test2-> instance.test()
        is BaseClass.Test3->instance.test()
    }
    /** * * sealed修饰符修饰密封类。 * * 密封类内部含有多个子类。 */
    sealed class BaseClass {
    
        class Test1 : BaseClass() {
            override fun test() {
                println("Test1实例")
            }
    
        }
        class Test2 : BaseClass() {
            override fun test() {
                println("Test2实例")
            }
        }
        object Test3 : BaseClass() {
            override fun test() {
                println("Test3实例")
            }
        }
        open fun test() {
            println("BaseClass实例")
        }
    }

输出如下：

Test1实例
    Test2实例
    Test3实例

[Kotlin_Intellij IED_.kt]: http://blog.csdn.net/hexingen/article/details/72820445
[Kotlin]: http://blog.csdn.net/hexingen/article/details/72820822
[Kotlin 1]: http://blog.csdn.net/hexingen/article/details/72820984
[Kotlin 2]: http://blog.csdn.net/hexingen/article/details/72821113
[Kotlin 3]: http://blog.csdn.net/hexingen/article/details/72822247
[Kotlin 4]: http://blog.csdn.net/hexingen/article/details/72822291