美文网首页
Android学习Kotlin之五、对象-接口-抽象类

Android学习Kotlin之五、对象-接口-抽象类

作者: 艾曼大山 | 来源:发表于2022-01-06 09:05 被阅读0次

    对象-接口-抽象

    Kotlin

    其它Kotlin文章
    Android学习Kotlin之一、常量-条件-函数-高阶函数
    Android学习Kotlin之二、Null安全 -字符串操作- 类型转换
    Android学习Kotlin之三、标准库函数-集合List-Set-Map
    Android学习Kotlin之四、定义类-初始化-继承
    Android学习Kotlin之五、对象-接口-抽象类
    Android学习Kotlin之六、泛型-扩展函数

    本编文章会讲到的知识点

    • 对象
      • 对象声明
      • 对象表达式
      • 伴生对象
    • 类的使用
      • 嵌套类
      • 数据类
      • copy
      • 解构声明
      • 使用数据类的条件
      • 枚举类
    • 接口
    • 抽象类

    对象

    使用object关键字,你可以定义一个只能产生一个实例的类-单例

    使用object关键字有三种方式:

    • 对象声明
    • 对象表达式
    • 半生对象
    对象声明

    通过object定义类,相当于java中的单例模式,有利于组织代码、管理状态

    object Tools{
        init {
            println("init初始化")//因为是单例模式,多次调用只会执行一次
        }
        fun getDate():String{
            return  return SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(Date())
        }
    }
        println(Tools.getDate())//和java中调用static方法一样
        println(Tools.getDate())//再次调用 不会执行init初始化代码块
    
    对象声明
    对象表达式

    有时候你不一定非要定义一个新的命名类不可,也许你需要某个现有类的一种变体实例,但只需用- -次就行了,事实上,对于这种用完就丢的类实例,连命名都可以省了。这个对象表达式是XX的子类,这个匿名类依然遵循object关键字的-一个规则,即一旦实例化,该匿名类只能有唯- - -个实例存在。

    /**
     * 对象表达式 定义一个可继承的类
     */
    open class Stu {
        open fun getName() = "神雕侠侣"
    }
    
        /**
         * 通过对象表达式生成一个类
         */
        val s = object : Stu() {
            override fun getName() = "杨过和小龙女"
            fun getAge():Int{
                return 18
            }
        }
        //和使用对象声明一样使用s类直接调用其函数
        println("我的名字:${s.getName()}")//我的名字:杨过和小龙女
        println("我的年龄:${s.getAge()}")//我的年龄:18
    
    
    伴生对象

    如果你想将某个对象的初始化和一一个类实例捆绑在一起,可以考虑使用伴生对象,使用companion修饰符, 你可以在一个类定义里声明一个伴生对象,一个类里只能有一个伴生对象;无论初始化多少次类,伴生对象只会初次的时候执行一次。

    class Associated{
    
        //无论初始化多少次类,伴生对象只会初次的时候执行一次。
        companion object{
           init {
               println("我是伴生对象初始化了")
           }
        }
    
        // 类的init代码块,每初始化一次类时都会执行
        init {
            println("我是Associated对象初始化了")
        }
    
    }
    
        // 伴生对象
        Associated()// 初始化第一次
        println("--------------------------")
        Associated()// 初始化第二次
    
    伴生对象

    类的使用

    嵌套类

    如果一个类只对另一个类有用,那么将其嵌入到该类中并使这两个类保持在一起是合乎逻辑的,可以使用嵌套类。

    class Nesting{
        class InerNesting{
            fun getName(name:String){
                println("我是嵌套类 ${name}")
            }
        }
        fun getName(name:String){
            InerNesting().getName(name)
        }
    }
    // 使用
    Nesting().getName("外部类调")
    Nesting.InerNesting().getName("内部类调")
    
    嵌套类
    数据类

    是专门设计用来存储数据的类,数据类提供了toString的个性化实现,==符号默认情况下,比较对象就是比较它们的引用值,数据类提供了equals和hashCode的个性化实现

    data class classStudent(var name:String,var age:Int)
    // data类 默认toString方法
    println(classStudent("小明",19))//classStudent(name=小明, age=19)
    println(classStudent("小明",19)===classStudent("小明",19))
    
    数据类
    copy

    除了重写Any类的部分函数,提供更好用的默认实现外,数据类还提供了一个函数,它可以用来方便地复制一个对象。假设你想创建一个Student实例,除了name属性,它拥有和另一个现有Student实例完全一样的属性值,如果Student是个数据类,那么复制现有Student实例就很简单了,只要调用copy函数,给想修改的属性传入值参就可以了。

    /**
     * copy类
     */
    data class classCopy(var name:String,var age:Int){
        constructor(name:String):this(name,18){
        }
    }
    
        // copy类 使用
        val copy1 = classCopy("小明")
        val copy2 = copy1.copy("baby")
        println(copy1)
        println(copy2)
    
    copy
    解构声明

    解构声明的后台实现就是声明component1、component2等若干个组件函数,让每个函数负责管理你想返回的一个属性数据,如果你定义一个数据类,它会自动为所有定义在主构造函数的属性添加对应的组件函数。

    /**
     * 解构声明
     */
    data class decosClass(var name:String,var age:Int){
    }
    
        // 解构声明
        var (n,a) =classCopy("小明",18)
        println("name:${n} age:${a}")
    
    解构声明
    使用数据类的条件

    正是因为上述这些特性,你才倾向于用数据类来表示存储数据的简单对象,对于那些经常需要比较、复制或打印自身内容的类,数据类尤其适合它们。然而,一个类要成为数据类,也要符合一定条件。总结下来,主要有三个方面:

    • 数据类必须有至少带一个参数的主构造函数
    • 数据类主构造函数的参数必须是val或var
    • 数据类不能使用abstract、open、sealed和inner修饰符
    枚举类

    枚举类,用来定义常量集合的一种特殊类。

    enum class MyEnum{
        NORTH,
        SOUTH,
        WEST
    }
        //枚举类
        val type = MyEnum.NORTH
        when(type){
            MyEnum.NORTH->  println(666)
            MyEnum.SOUTH->  println(888)
            MyEnum.WEST -> println(999)
        }
    
    枚举类
    接口

    Kotlin规定所有的接口属性和函数实现都要使用override关键字,接口中定义的函数并不需要open关键字修饰,他们默认就是open的。

    //定义接口
    interface OnItemClick{
        val name:String
        fun itemClick(index:Int)
    }
    
    //实现接口
    class MAdapter(override val name: String) : OnItemClick{
        override fun itemClick(index: Int) {
            TODO("Not yet implemented")
        }
    }
    
    抽象类

    要定义一个抽象类,你需要在定义之前加上abstract关键字,除了具体的函数实现,抽象类也可以包含抽象函数只有定义,没有函数实现。

    //定义抽象类
    abstract class BaseClass{
        open fun initView(){}
        abstract fun initData()
    }
    
    //继承抽象类
    class MyClass : BaseClass() {
        
        //重新initView函数
       override fun initView(){
        }
        
        //继承initData函数
        override fun initData() {
            TODO("Not yet implemented")
        }
    
    }
    

    相关文章

      网友评论

          本文标题:Android学习Kotlin之五、对象-接口-抽象类

          本文链接:https://www.haomeiwen.com/subject/afglultx.html