疯狂Kotlin讲义学习笔记08章：面向对象（下）嵌套类、内部类、局部嵌套类，匿名内部类，对象表达式，对象声明，伴生对象，枚举类，类委托，属性委托，延迟属性，属性监听，map存储属性，委托工厂

最新推荐文章于 2024-04-21 14:18:22 发布
最新推荐文章于 2024-04-21 14:18:22 发布
阅读量237 收藏
点赞数
分类专栏： Kotlin学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43745804/article/details/108656259
版权
20、嵌套类和内部类概述

类定义在一个类的内部叫做嵌套类
内部类分静态内部类（static修饰）和非静态内部类（无static修饰）
嵌套类（相当于静态内部类）：放在一个类的内部，用static修饰
内部类（非静态内部类）：使用inner修饰，相当于java中的无static修饰非静态内部类

只需要把一个类放在另一个类的类内部嵌套定义即可，甚至可以在方法中定义嵌套类

21、内部类
//通过主构造器为外部类定义属性
class Cow(var weight:Double=0.0){
    //定义一个内部类（用inner修饰，相当于java的非静态内部类）
    //通过主构造器为内部定义属性
    private inner class Cowleg(var length:Double=0.0,var cololr:String=""){
        //内部类的方法
        fun info(){
            println("当前牛腿颜色是：${cololr},高：${length}")
            //直接访问外部类的private修饰的foo()方法
            foo()
        }
    }

    fun test(){
        val c1=Cowleg(1.12,"黑白相间")
        c1.info()
    }

    private fun foo() {
        println("Cow的foo方法")
    }
}

fun main(args:Array<String>){
    val cow=Cow(378.9)
    cow.test()
}

打印：
当前牛腿颜色是：黑白相间,高：1.12
Cow的foo方法

如果外部类属性、内部类属性与内部类中方法的局部变量同名，则可通过使用this、带标签的this@（访问外部类属性）来进行限定区分

关于this，kotlin的处理规则如下

  • 在类的方法或属性中，this代表该方法或属性的对象
  • 在类的构造器中，this代表该构造器即将返回的队形
  • 在扩展行数或带接收者的函数字面值中，this表示（.）左边的接收者
  • 如果this没有限定符，那么优先代表包含该this的最内层的接收者，并且会自动向外搜索，如果要让this明确引用特定的接收者，则可使用标签限定符
class DiscernVariable{//隐式标签@DiscernVariable
    private val prop="外部类的属性"
    inner class InClass{//隐式标签@InClass
        private val prop="内部类的属性"
        fun info(){
            val prop="局部变量"
            //通过外部类类名.this.varname来访问外部类属性
            println("外部类的属性值：${this@DiscernVariable.prop}")
            //通过this.varname来访问内部类属性
            println("内部类的属性值：${this.prop}")
            //直接访问局部变量
            println("局部变量的值${prop}")

        }
    }
    fun test(){
        val ic=InClass()
        ic.info()
    }

}
fun main(args:Array<String>){
    DiscernVariable().test()
}

打印：
外部类的属性值：外部类的属性
内部类的属性值：内部类的属性
局部变量的值局部变量

====================

内部类成员不能够外部类直接使用，如果需要访问外部类成员，则必须显式创建内部类对象来调用访问其成员

class Outer{
    private val outProp=9
    inner class Inner{
        val inprop=5
        fun accessOuterProp(){
            //内部类可以直接访问外部类的private属性
            println("外部类的outProp值：${outProp}")
        }
    }
    fun accessInnerProp(){
        //如果需要访问内部类的属性，必须显式地创建内部类的对象
        println("内部类的inProp值：${Inner().inprop}")
    }
}

fun main(args:Array<String>){
    val out=Outer()
    out.accessInnerProp()
}

打印
内部类的inProp值：5

22、嵌套类

由于kotlin取消static修饰符，所以kotlin类的成员除嵌套类之外，全部都是非静态成员，因此嵌套类不可访问外部类的其他任何成员（只能访问其他嵌套类）

class NestedClassTest{
    var prop=5
    fun test(){
        println("外部类的test()方法")
    }
    //没有inner修饰符，是嵌套类（相当于java的静态内部类）
    class  NestedClass {
        fun accessOuterMember(){
            //访问另一个嵌套类是允许的
            val a = A()
            //下面两行会出错
            //println(prop)不可以访问，外部类的成员
            //test()
        }
    }

    class A{}
}

fun main(args:Array<String>){
    val out=Outer()
    out.accessInnerProp()
}

嵌套类唯一可以访问的是外部类的其他嵌套类
嵌套类相当于外部类的静态成员，因此外部类的所有方法，属性，初始化快都可以使用嵌套类来定义变量，创建对象等

外部类依然不能直接访问嵌套类的成员，但可以使用嵌套类的对象作为调用者来访问嵌套类的成员

class NestedClassTest{

    class  NestedClass {
        var prop=9
    }
        fun accessNetedProp(){
            println(NestedClass().prop)
        }
   
}
23、在外部类以外使用内部类

外部类在内部使用嵌套类或者内部类是与平常使用普通类没有太大的区别，一样可以直接通过嵌套类或内部类的类名来定义变量，调用嵌套类或者内部类的构造器来创建实例

嵌套类智能访问外部的其他嵌套类，不能访问外部的其他任何成员。如果希望在外部意外的地方使用内部类或嵌套类，一定要注意访问权限的限制。

在外部类以外的地方定义内部类变量的语法格式

var |val varname：OuterClass.InnerClass

从语法格式上看，在外部类意外的地方使用内部类时，内部类完整的类名应该是OuterClass.InnerClass，如果外部类还有包名，应当加上包名前缀

由于内部类的对象必须寄生在外部类的对象中，因此在创建内部类对象之前，必须先创建器外部类对象。在外部类意外的地方创建内部类实例的语法格式如下

OuterInstance.InnerConstructor（）

从以上语法格式可以看出，在外部类以外的地方创建内部类实例时必须使用外部类实例来调用内部类的构造器

class Outer{
    //定义一个内部类，不使用访问控制符，默认是public
    inner class In(msg:String){
        init {
            println(msg)
        }
    }
}

fun main(args:Array<String>){
    var oi:Outer.In=Outer().In("测试信息")
    //以上代码等效于
    //使用OuterClass.InnerClass形式定义内部类变量
    //var oi:Outer.In
    //创建外部类实例
    //val ot=Outer()
    //通过外部类实例来调用内部类的构造器创建内部实例
    //oi=ot.In("测试信息")

}

测试信息

24、在外部类以外使用嵌套类
由于内部类是外部类本身的成员，因此创建嵌套内部类对象无需创建外部类对象

在外部类以外的地方创建嵌套类实例的语法格式如下

OuterClass.NestedConstructor()

案例

class NestedOut{
    //定义一个嵌套类，不适用访问控制符，默认是public
    open class Nested{
        init {
            println("嵌套类的构造器")
        }
    }
}


fun main(args:Array<String>){
   
    val nested:NestedOut.Nested=NestedOut.Nested()

}

打印
嵌套类的构造器

25、局部嵌套类
  • 放在方法或函数中定义的嵌套类就叫做局部嵌套类。
  • 局部嵌套类尽在该方法或函数中有效，由于局部嵌套了诶不能在方法或函数以外的地方使用，因此局部嵌套类也不能使用访问控制符修饰
  • 如果需要用局部嵌套类定义变量，创建实例或派生子类，只能在局部嵌套类所在的方法或函数中进行。
class LocalNestedClass{
    fun info(){
        open class NestedBase(var a:Int=0){

        }
        //定义局部嵌套类的子类
        class NestedSub(var b:Int=0):NestedBase(){

        }
        //创建局部嵌套类的对象
        val ns=NestedSub()
        ns.a=5
        ns.b=8
        println("NestedSub对象的a和b属性是:${ns.a},${ns.b}")
    }
}
fun main(args:Array<String>){
    LocalNestedClass().info()

}

打印
NestedSub对象的a和b属性是:5,8

26、匿名内部类

kotlin抛弃了java的匿名内部类功能，提供了更加强大的语法，对象表达式

27、对象表达式

对象表达式和匿名内部类区别
匿名内部类只能知道你个一个父类型（父接口或父类）
对象表达式课指定0-n个父类型（父接口或父类）

对象表达式的语法格式如下

object[:0-个父类型]{
//对象表达式的类体部分
}

对象表达式还有如下规则

  • 对象表达式不能是抽象类，应为要创建实例
  • 对象表达式不能定义构造器，但对象表洒水可以定义初始化快，可以通过初始化快来完成构造器需要完成的事情
  • 对象表达式可以包含内部类，但不能包含嵌套类
 interface Outputable {
    fun output(msg:String)
}

abstract class Product(var price:Double){
    abstract  val name:String
    abstract fun printInfo()
}


fun main(args:Array<String>){
    //指定一个父类型或接口的对象表达式
    var ob1=object :Outputable{
        override fun output(msg: String) {
            for(i in 1..6){
                println("<h${i}>${msg}</h${i}>")
            }
        }
    }

    ob1.output("疯狂教育中心")
    println("------")

    //指定零个父类型的对象表达水
    var ob2=object{
        //初始化快
        init {
            println("初始化快")
        }
        //属性
        var name="kotlin"
        //方法
        fun test(){
            println("test方法")
        }

        //只能包含内部类，不能包含嵌套类
        inner class Foo
    }
    println(ob2.name)
    ob2.test()
    println("------")

    //指定两个父类型的对象表达式
    //由于Product只有一个带参数的构造器，因此需要传入构造器参数
    var ob3=object:Outputable,Product(28.8){
        override fun output(msg: String) {
            println("输出信息：+msg")
        }
        override val name:String
        get() = "激光打印机"

        override fun printInfo() {
            println("高速激光大衣你急，支持自动双面打印")
        }
    }
    println(ob3.name)
    ob3.output("kotlin真不错")
    ob3.printInfo()
    
}

打印：

<h1>疯狂教育中心</h1>
<h2>疯狂教育中心</h2>
<h3>疯狂教育中心</h3>
<h4>疯狂教育中心</h4>
<h5>疯狂教育中心</h5>
<h6>疯狂教育中心</h6>
------
初始化快
kotlin
test方法
------
激光打印机
输出信息：+msg
高速激光大衣你急，支持自动双面打印
28、对象声明和单例模式

语法格式为：

object ObjectName[:0-个父类型]{
//对象表达式的类体部分
}

对象声明和对象表达式的区别

  • 对象表达式是一个表达式，不能包含内部类，而对象声明不是表达式，不能赋值
  • 对象声明课把傲寒嵌套类，不能包含内部类，而对象表达式可包含内部类，不能包含嵌套类
  • 对象声明不能定义在函数和方法内，但对象表达式可嵌套在其他对象声明或非内部类中
interface Outputable {
    fun output(msg:String)
}

abstract class Product(var price:Double){
    abstract  val name:String
    abstract fun printInfo()
}

//指定一个父类型（接口）的对象表达式
object Myobject1:Outputable{
    override fun output(msg: String) {
        for(i in 1..6){
            println("<h${i}>${msg}</h${i}>")
        }
    }
}

//指定零个父类型（接口）的对象表达式
object Myobject2{
    //初始化快
    init {
        println("初始化快")
    }
    //属性
    var name="kotlin"
    //方法
    fun test(){
        println("test方法")
    }

    //只能包含内部类，不能包含嵌套类
    class Foo
}

//指定两个父类型的对象表达式
//由于Product只有一个带参数的构造器，因此需要传入构造器参数
object Myobject3:Outputable,Product(28.8){
    override fun output(msg: String) {
        println("输出信息：+msg")
    }
    override val name:String
        get() = "激光打印机"

    override fun printInfo() {
        println("高速激光打印机，支持自动双面打印")
    }
}
fun main(args:Array<String>){
   
    Myobject1.output("疯狂教育中心")
    println("------")
    
    println(Myobject2.name)
    Myobject2.test()
    println("------")

    
    println(Myobject3.name)
    Myobject3.output("kotlin真不错")
    Myobject3.printInfo()

}

打印

<h1>疯狂教育中心</h1>
<h2>疯狂教育中心</h2>
<h3>疯狂教育中心</h3>
<h4>疯狂教育中心</h4>
<h5>疯狂教育中心</h5>
<h6>疯狂教育中心</h6>
------
初始化快
kotlin
test方法
------
激光打印机
输出信息：+msg
高速激光打印机，支持自动双面打印
29、伴生对象和静态成员
  • 在类中定义的对象声明，可使用companion修饰，这样该对象就变成了伴生对象
  • 每个类最多只能定义一个伴生对象，伴生对象相当于外部类的对象，程序可以通过外部类直接调用伴生对象的成员。
interface Outputable {
    fun output(msg:String)
}
class Myclass{
    //使用compantion修饰的伴生对象
    companion object Myobject1:Outputable{
        val name="name属性值"
        override fun output(msg: String) {
            for (i in 1..6){
                println("<h${i}>${msg}</h${i}>")

            }
        }
    }
}

fun main(args:Array<String>){
    //使用伴生对象所在的类调用伴生对象的方法
    Myclass.output("疯狂教育")//使用类名直接调用
    println(Myclass.name)//使用类名直接调用
}

打印：

<h1>疯狂教育</h1>
<h2>疯狂教育</h2>
<h3>疯狂教育</h3>
<h4>疯狂教育</h4>
<h5>疯狂教育</h5>
<h6>疯狂教育</h6>
name属性值

从以上代码中可以看到，伴生对象的名称不重要（myobject1根本没用到），因此伴生对象可以省略名称。省略名称后，如果程序真的要访问伴生对象，则可以他通过companion名称进行访问

interface Outputable {
    fun output(msg:String)
}
class Myclass{
    //使用compantion修饰的伴生对象
    companion object :Outputable{
        val name="name属性值"
        override fun output(msg: String) {
            for (i in 1..6){
                println("<h${i}>${msg}</h${i}>")

            }
        }
    }
}

fun main(args:Array<String>){
    //使用伴生对象所在的类调用伴生对象的方法
    Myclass.output("疯狂教育")//使用类名直接调用
    println(Myclass.Companion)//使用类名调用companion关键字
}
30、伴生对象的扩展

为伴生对象扩展的方法和属性，就相当于为伴生对象所在的外部类扩展了静态成员，可通过外部类的类名访问这些扩展成员。

interface Outputable {
    fun output(msg:String)
}
class Myclass{
    //使用compantion修饰的伴生对象
    companion object :Outputable{
        val name="name属性值"
        override fun output(msg: String) {
            for (i in 1..6){
                println("<h${i}>${msg}</h${i}>")

            }
        }
    }
}

//为伴生对象扩展的方法
fun Myclass.Companion.test(){
    println("为伴生对象扩展的方法")
}

//为伴生对象扩展的属性
val Myclass.Companion.foo
get() = "为伴生对象扩展的属性"


fun main(args:Array<String>){
    //使用伴生对象所在的类调用伴生对象的方法
    Myclass.output("疯狂教育")//使用类名直接调用
    println(Myclass.name)//使用类名调用companion关键字
    //通过伴生对象所在对的类调用为伴生对象扩展的成员
    Myclass.test()
    println(Myclass.foo)
}

打印

<h1>疯狂教育</h1>
<h2>疯狂教育</h2>
<h3>疯狂教育</h3>
<h4>疯狂教育</h4>
<h5>疯狂教育</h5>
<h6>疯狂教育</h6>
name属性值
为伴生对象扩展的方法
为伴生对象扩展的属性
31、枚举类入门

枚举类是一种特殊的类，可以有自己的属性、方法，可以实现一个或多个接口，也可以定义自己的构造器

枚举类与普通类的区别

  • 枚举类可以实现一个或多个接口，继承自kotlin.Enum类
  • 使用enum定义的非抽象的枚举类不能使用open修饰，不能派生子类
  • 枚举类的构造器只能使用private访问控制符，如果省略了构造器的访问控制符，则默认private修饰
  • 枚举类的所有实例必须在枚举类的第一行显式列出

枚举类默认提供如下两个方法


 - EnumClass.valueOf（value：String）：EnumClass
 - EnumClass.values：Array<EnumClass>

案例

enum class Season{
//在第一行列出4个枚举实例
    SPRING,SUMMER,FALL,WINTER
}

fun main(args:Array<String>){
   //枚举默认有一个values（）方法，返回该枚举类所有实例(因为不是继承自Object，而是继承制ENUM类)
    for (s in Season.values()){
        println(s)
    }
    val seasonName="SUMMER"
    val s:Season=Season.valueOf(seasonName)
    println("-----")
    println(s)
    println("-----")
    //直接访问枚举值
    println(Season.WINTER)

}

打印

SPRING
SUMMER
FALL
WINTER
-----
SUMMER
-----
WINTER

由于枚举类继承自kotli.ENUM类，父类提供了如下属性和方法

  • name属性，返回此枚举实例的名称，也就是枚举值之一
  • ordinal属性，返回枚举值在枚举类中的索引值，从零0
  • intcompareTo（E o）方法：用于与指定对的枚举对象比较顺序
  • String toString（）：返回枚举常量的名称，与name属性相似，但toString方法用得更多
32、枚举类的属性、方法、构造器
  • 枚举类式设计为不可变类，因此他的属性值不允许改变，这样会更安全，因此尽职开发者对属性赋值，并推荐是用val为枚举声明只读属性
  • 由于是只读属性，枚举必须在构造器中为这些属性指定初始值（或在初始化快中指定初始值，但少用）因此应当为枚举类显示定义带参数的构造器
  • 一旦为枚举类显式地定义了带参数的构造器你，在列出枚举值时就必须对应地传入参数
//使用主构造器声明cnname只读属性
enum class Gender(var cnName:String){
    MALE("男"),FAMALE("女");//因为后面有额外的枚举成员，这里用了分号结束，等同有MALE=new Gender("男")
    //定义方法
    fun info(){
        when(this){
            MALE-> println("天行健，君子以自强不息")
            FAMALE-> println("唯小人与女子难养也")
        }
    }

}

fun main(args:Array<String>){
  //通过Gender的valueOf（）方法更久枚举名获取枚举值
    val g=Gender.valueOf("FAMALE")
    //访问枚举值的cnName属性
    println("${g}代表${g.name}")
    //调用info方法
    g.info()//g不是枚举值吗，怎么又成了枚举实例了，因为枚举类的每一枚举值就是一个枚举实例

}

打印：
FAMALE代表FAMALE
唯小人与女子难养也

33、实现接口的枚举类

枚举类实现接口也需要实现该接口所包含的方法

interface GenderDesc {
    fun info()
}
//使用主构造器声明cnname只读属性
enum class Gender(var cnName:String):GenderDesc{
    MALE("男"),FAMALE("女");//因为后面有额外的枚举成员，这里用了分号结束，等同有MALE=new Gender("男")
    //定义方法
    override  fun info(){
        when(this){
            MALE-> println("天行健，君子以自强不息")
            FAMALE-> println("唯小人与女子难养也")
        }
    }

}

fun main(args:Array<String>){
  //通过Gender的valueOf（）方法更久枚举名获取枚举值
    val g=Gender.valueOf("FAMALE")
    //访问枚举值的cnName属性
    println("${g}代表${g.name}")
    //调用info方法
    g.info()//g不是枚举值吗，怎么又成了枚举实例了，因为枚举类的每一枚举值就是一个枚举实例

}

打印：
FAMALE代表FAMALE
唯小人与女子难养也

34、包含抽象方法的抽象枚举类
  • 枚举类中包含抽象方法时依然不能使用abstract修饰，系统会自行添加上去
  • 在定义每个枚举值时必须为抽象成员提供实现

案例：每个枚举操作定义具体的计算方法，来实现抽象计算方法

enum class Operation{
    PLUS{
        override fun eval(x: Double, y: Double): Double {
            return x+y
        }
    },
    MINUS{
        override fun eval(x: Double,y: Double)=x-y
    },
    TIMS{
        override fun eval(x: Double, y: Double): Double {
            return x*y
        }
    },
    DIVIDE{
        override fun eval(x: Double, y: Double): Double {
            return x/y
        }
    };


    //为枚举类定义一个抽象方法，这个抽象方法由不同的枚举值提提供不同的实现
    abstract fun eval(x:Double,y: Double):Double
}

fun main(args:Array<String>){
    println(Operation.PLUS.eval(2.0,4.0))
    println(Operation.MINUS.eval(5.0,3.0))
    println(Operation.TIMS.eval(3.0,6.0))
    println(Operation.DIVIDE.eval(5.0,4.0))

}

打印：
6.0
2.0
18.0
1.25

35、类委托

kotlin的委托分为类委拖和属性委托
类委托的本质就是将本类需要实现的部分方法委托给了其他对象----相当于借用其他对象的方法作为自己的实现。
使用by关键字进行委托

interface Outputable {
    fun output(msg:String)
    var type:String
}
//定义一个DefaultOuput类实现outputable接口
class DefaultOutput:Outputable{
        override fun output(msg: String) {
            for (i in 1..6){
                println("<h${i}>${msg}</h${i}>")

            }
        }
    override var type:String="输出设备"

}

//定义Printer类，指定构造参数b作为委托对象
class Printer(b:DefaultOutput):Outputable by b
//定义projecto类，指定新建的对象作为委托对象
class Projector():Outputable by DefaultOutput(){
    override fun output(msg: String) {
        javax.swing.JOptionPane.showMessageDialog(null,msg)
    }
}


fun main(args:Array<String>){
    val output=DefaultOutput()
    //printer对象的委托对象是output
    var printer=Printer(output)
    //其实就是调用委托对象的output（）方法
    printer.output("疯狂教育机构")
    //其实就是调用委托对象的type属性方法
    println(printer.type)
    //projector对象的委托对象也是output
    var projector =Projector()
    //projector本身重写了outpu方法，所以此处是调用本类重写的方法
    projector.output("疯狂软件中心")
    //其实就是调用委托对象的type属性方法
    println(projector.type)

}

打印：

<h1>疯狂教育机构</h1>
<h2>疯狂教育机构</h2>
<h3>疯狂教育机构</h3>
<h4>疯狂教育机构</h4>
<h5>疯狂教育机构</h5>
<h6>疯狂教育机构</h6>
输出设备
输出设备
36、属性委托（没阿太看懂）

属性委托可以将多个类的类似属性同意交给委托对象集中实现，避免每个类都要单独实现这些属性

对于制定了委托对象的属性而言，由于她的实现逻辑已经交给了委托对象处理，因此开发者不能为委托属性提供getter和setter方法。

一旦将某个对象指定为属性的未委托对象，该对象就会全面接管该属性读取getter和写入setter操作，因此，属性的未谈妥对象无需实现任何接口。但一定要提供一个getValue（）方法和setValue（）方法

使用operator修饰符

import kotlin.reflect.KProperty

class PropertyDelegation{
    //该属性的委托对象是MyDelegation
    var name:String by MyDelegation()

}
class MyDelegation{
    private var _backValue="默认值"
    operator fun getValue(thisRef:PropertyDelegation,property:KProperty<*>):String{
        println("${thisRef}的${property.name}属性执行getter方法")
        return _backValue
    }
    operator fun setValue(thisRef: PropertyDelegation,property: KProperty<*>,newValue:String){
        println("${thisRef}的${property.name}属性执行settter方法,传入参数值为：${newValue}")
        _backValue=newValue
    }


}

fun main(args:Array<String>){
    val pd=PropertyDelegation()
    //读取属性，实际上是调用属性的委托对象的getter方法
    println(pd.name)
    //写入属性，实际上是调用属性的委托对象的setter方法
    pd.name="疯狂教育中心"
    println(pd.name)
}

打印：
PropertyDelegation@3c0ecd4b的name属性执行getter方法
默认值
PropertyDelegation@3c0ecd4b的name属性执行settter方法,传入参数值为：疯狂教育中心
PropertyDelegation@3c0ecd4b的name属性执行getter方法
疯狂教育中心

37、延迟属性
  • kotlin提供了一个lazy()函数，该函数接受一个lambda表达式作为参数，并返回一个lazy< T >对象
  • lazy < T > 对象包含了一个符合只读属性委托要求的getValue（）方法，因此该lazy对象可作为只读属性的委托对象
val lazyProp:String by lazy {
    println("第一次访问时执行代码块")
    "疯狂软件中心"
}

fun main(args:Array<String>){
    //两次访问lazyProp属性的值
    println(lazyProp)//第一次正常加载
    println(lazyProp)//第二次加载不在计算lambda表达式，而是直接返回第一次的值
}

打印：
第一次访问时执行代码块
疯狂软件中心
疯狂软件中心

lazy < T >的getValue（）方法的处理逻辑是，第一次调用该方法适合，程序会计算lambda表达式，并得到其返回值，以后程序再次调用该方法时，不再计算lambda表达式，而是直接使用第一次计算得到的返回值

38、属性监听

两个监听方法

  • fun < T >oberservable
  • fun < T >vetoable
    import kotlin.properties.Delegates
var observableProperty:String by Delegates.observable("默认值"){
    //lambda表达式的第一个参数代表被监听的属性
    //第二个参数代表修改之前的值
    //第三个参数代表被设置的新值
    property, oldValue, newValue ->
    println("${property}的${oldValue}被改为${newValue}")
}

fun main(args:Array<String>){
    //访问observableProp属性，不会触发监听器的lambda表达式
    println(observableProperty)
    //设置属性值，触发监听器的lambda表达式
    observableProperty="疯狂软件"
    println(observableProperty)

}

打印：
默认值
var observableProperty: kotlin.String的默认值被改为疯狂软件
疯狂软件

import kotlin.properties.Delegates

var vetoableProp:String by Delegates.vetoable("默认值"){
    //lambda表达式的第一个参数代表被监听的属性
    //第二个参数代表修改之前的值
    //第三个参数代表被设置的新值
    property, oldValue, newValue ->
    println("${property}的${oldValue}被改为${newValue}")
    newValue>oldValue
}

fun main(args:Array<String>){
    //访问vetoable属性，不会触发监听器的lambda表达式
    println(vetoableProp)
    //新值小于旧值，监听的lambda表达式false，新值设置失败
    vetoableProp= 15.toString()
    println(vetoableProp)
    //新值大于旧值，监听的lambda表达式true，新值设置成功
    vetoableProp= 25.toString()
    println(vetoableProp)

}

打印：
默认值
var vetoableProp: kotlin.String的默认值被改为15
默认值
var vetoableProp: kotlin.String的默认值被改为25
默认值

39、使用Map存储属性值

kotlin的map提供了如下方法：

operator fun....Map...getValue

MutableMap提供两个方法

operator fun....Map...getValue
operator fun....Map...setValue
  • 意味着mutableMap对象可作为读写对象的委托
  • 程序将类制度属性委托给Map对象管理，在这种情况下，对象本身并不负责存储对象状态，而是将对象状态保存在Map集合中。
  • 这么做的好处是，当程序需要和外部接口通信时，程序并不需要将该对象直接暴露出来，只要将该对象属性所委托的Map暴露出来即可，而Map则完整地保存了整个对象状态。
  • 下例将所有的只读属性都委托给一个Map对象，Item对象的每个属性名就相当于Map的key，属性值就相当于key对应的value
class Item(val map:Map<String,Any?>){
    val barCode:String by map
    val name:String by map
    val price:Double by map
}
fun main(args:Array<String>){
    val item=Item(mapOf(
            "barCode" to "12354",
            "name" to "疯狂kotlin讲义",
            "price" to 68.9
    ))

    println(item.barCode)
    println(item.name)
    println(item.price)
    println("*********")
    //将对象持有的map暴露出来，其他程序可以通过标准map读取数据

    val map=item.map
    println(map["barCode"])
    println(map["name"])
    println(map["price"])
}

打印
12354
疯狂kotlin讲义
68.9

12354
疯狂kotlin讲义
68.9

上例改为MutableMap也是成立的，并且另外加了写的属性

class MutableItem(val map:MutableMap<String,Any?>){
    val barCode:String by map
    val name:String by map
    val price:Double by map
}
fun main(args:Array<String>){
    val item=MutableItem(mutableMapOf(
            "barCode" to "12354",
            "name" to "疯狂kotlin讲义",
            "price" to 68.9
    ))

    println(item.barCode)
    println(item.name)
    println(item.price)
    println("*********")
    //将对象持有的map暴露出来，其他程序可以通过标准map读取数据

    val map=item.map
    println(map["barCode"])
    println(map["name"])
    println(map["price"])
    map["price"]=999.9
    println(item.price)
}

打印
12354
疯狂kotlin讲义
68.9

12354
疯狂kotlin讲义
68.9
999.9

40、局部属性委托

指定了委托对象的局部变量诚挚为“局部委托属性”-其实还是局部变量。只是对该变量的读取、赋值操作都交给了委托对象去实现

局部变量的委托对象，对于只读属性要实现operator修饰的getValue方法，该方法第一个参数是Nothing？类型。代表永不存在的对象

同样的以上读写属性也类似

import kotlin.reflect.KProperty

class Mydelegation{
    private var _backValue="默认值"
    operator fun getValue(thisRef:Nothing?,property:KProperty<*>):String{
        println("${thisRef}的${property.name}属性执行getter方法")
        return _backValue
    }
    operator fun setValue(thisRef:Nothing?,property:KProperty<*>,newValue:String) {
        println("${thisRef}的${property.name}属性执行setter方法,传入参数值为${newValue}")
        _backValue=newValue
    }

}
fun main(args:Array<String>){
    var name:String by Mydelegation()
    //访问局部变量，实际是调用mydelegete对象的getValue（）方法
    println(name)
    //对局部变量赋值，实际是调用mydelegete对象的setValue（）方法
    name="新的值"
    println(name)

}

打印
null的name属性执行getter方法
默认值
null的name属性执行setter方法,传入参数值为新的值
null的name属性执行getter方法
新的值

可以利用lazy（）函数对局部变量延迟初始化

41、委托工厂（真心没懂）

委托工厂对象也可以作为委托对象，委托工厂需要提供如下方法
operator fun provideDelegate：该方法的参数与委托的getValue方法的两个参数的意义相同

import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty

class MyTarget{
    //该属性的委托对象是provideDelegate（）方法返回的mydelegation对象
    var name:String by PropertyChecker()
}

class PropertyChecker () {
    operator fun providerDelegate(thisRef: MyTarget,property: KProperty<*>):ReadWriteProperty<MyTarget,String>{
        //插入自定义代码，可执行任意业务操作
        checkProperty(thisRef,property.name)
        //返回实际委托对象
        return Mydelegation()
    }

    private fun checkProperty(thisRef: MyTarget, name: String) {
        println("检查属性")
    }
}

class Mydelegation:ReadWriteProperty<MyTarget,String>{
    private var _backValue="默认值"
    override fun getValue(thisRef:Nothing?,property:KProperty<*>):String{
        println("${thisRef}的${property.name}属性执行getter方法")
        return _backValue
    }
    override fun setValue(thisRef:Nothing?,property:KProperty<*>,newValue:String) {
        println("${thisRef}的${property.name}属性执行setter方法,传入参数值为${newValue}")
        _backValue=newValue
    }
}


fun main(args:Array<String>){
    //创建对象（初始化属性），调用委托工厂的providerDelegate()方法
    val pd=MyTarget()
    //读取属性，实际上是调用属性委托对象的getter方法
    println(pd.name)
    //写入属性，实际上是调用属性委托对象的setter方法
    pd.name="疯狂教育"
    println(pd.name)
}
心湖中的石子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习小贴士之内部类
weixin_45534000的博客
11-25 119
内部类一.静态内部类二.局部内部类 在类内部也可以定义另一个类。如果在类Outer的内部再定义一个类Inner，此时类Inner就称为内部类，而类Outer则称为外部类。 内部类可分为静态类，成员类，局部类，匿名类四种。 内部类可声明成public或private。当内部类声明成public或private时，对其访问的限制与成员变量和成员方法完全相同。 范例： public class Ou...
java 静态内部类初始化_Java中内部类的使用总结
weixin_35724999的博客
02-25 1597
1、非静态内部类定义内部类很简单，只要把一个类放在另一个类内部定义即可。public class OuterClass{//此处可以定义内部类}注意：同一个java源文件定义了多个类，它们之间是相互独立的，那种情况不是内部类。内部类做为其外部类的成员，因此可以使用任意访问控制符如private、protected和public修饰。外部类的上一级程序单元是包，所以它只有2个作用域:同一个包和任何位...
kotlin——减少if的使用和嵌套、完美的登录校验、Map存储某个函数、三元
wy313622821的博客
09-25 792
1、使用三元运算符 三元运算符减少if的嵌套 var a = if (true) 1 else 0 1、使用多态减少if
Kotlin集合中的元素组合
dlz00001的博客
06-09 418
我不是普通的StackOverflow用户，既不是贡献者，也不是提出问题。 但是，我最近偶然发现了一个问题 ，试图提供帮助...并失败了。 有人指出我的答案是错误的-感谢所有这样做的人。 我认为失败是学习新事物的好时机！ 在这篇文章中，我想详细介绍我进一步研究后学到的知识：有几种方法可以将Kotlin stdlib中现有集合中的元素进行组合。 与下一个结合 第一组合功能是将一个...
《疯狂JAVA讲义》学习笔记（一）
心砚THU的专栏
07-14 2390
本人之前一直从事iOS开发，最近开始接触Eclipse插件开发，打算先重拾一下扔了很久的Java。看到大家都在网上推荐李刚的《疯狂JAVA讲义》，于是下了一本开始学习。以下为前七章本人记录的一些要点和体会
Android：这是一份全面 & 详细的Kotlin入门学习指南，android开发者文档隐私权限
m0_65511992的博客
12-24 182
e. 数组类型（Arrays） 实现方式：使用Array类 使用方法：size 属性、get方法和set 方法。注：使用 [] 重载了 get 和 set 方法，可通过下标获取 / 设置数组值。 创建方式：方式1 = 函数arrayOf()；方式2 = 工厂函数 // 方式1：使用arrayOf创建1个数组：[1,2,3] val a = arrayOf(1, 2, 3) // 方式2：使用工厂函数创建1个数组[0,2,4] val b = Array(3, { i -> (i * 2) }) /
kotlin 实战之面向对象特性全方位总结，2021年Android开发突破20k有哪些有效的路径
m0_64319455的博客
11-20 257
kotlin 为我们提供了一种混用冲突的解决方案，当继承的类和接口拥有相同签名方法时子类必须重写父类相同签名方法，否则无法编译通过，此外需要显式通过<>语法指定使用哪个基类的方法。案例如下： interface Nb { fun test() { println(“nb”) } } open class Tt { open fun test() { println(“tt”) } } class ChildNb: Nb, Tt() { //当继承的类和接口拥有相同签名方法时子类必须重写父类相同签
Android开发必看：一文教你完全理解DataBinding框架（下，flutterpageview嵌套
m0_64382950的博客
11-27 322
/> 代码如下： // 设置 inflate 回调 mBinding.view 《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》 【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享 Stub.setOnInflateListener(new ViewStub.OnInflateListener() { @Override public void onInflate(ViewStub stub, View view) {
Android kotlin Jetpack mvvm 项目，kotlinlambda表达式的脱离
m0_64319112的博客
11-21 445
LiveData的优势 确保界面符合数据状态:LiveData 遵循观察者模式。当底层数据发生变化时，LiveData 会通知 Observer 对象。您可以整合代码以在这些 Observer 对象中更新界面。 不会发生内存泄漏:观察者会绑定到 Lifecycle 对象，并在其关联的生命周期遭到销毁后进行自我清理。 不会因 Activity 停止而导致崩溃:如果观察者的生命周期处于非活跃状态（如返回栈中的 Activity），则它不会接收任何 LiveData 事件。 不再需要手动处理生命周期:界面组件只
深入解析Kotlin 协程与 JetPack 组件
2401_84121980的博客
04-21 818
考虑到文章的篇幅问题，我把这些问题和答案以及我多年面试所遇到的问题和一些面试资料做成了PDF文档《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！**如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）考虑到文章的篇幅问题，我把这些问题和答案以及我多年面试所遇到的问题和一些面试资料做成了PDF文档。
java用匿名内部类实现类似jquery.map和join方法
qq_36804701的博客
03-11 413
jquery的map方法可以把List&lt;map&gt;对象中的某项属性提取成list对象,然后join拼接成字符串，java中却没有类似的方法。我之前写过List&lt;String&gt;和String[]对象的join方法 public static String join(List&lt;String&gt; arr,String split) { if(arr == nul...
kotlin 中的 "for" 循环和迭代map
shenshizhong的专栏
09-15 7092
文章目录 场景 “for” 循环 迭代map 总结 场景 kotlin 中的 “for” 循环和迭代 map 与我们熟知的 java 中的有什么区别呢，有哪些更好的表现形式呢? “for” 循环 kotlin “for”循环结构：for (i in a..b) a代表起始值，b代表结束值。..表示区间。例如for (i in 1..100) 注
kotlin中map的使用技巧
热门推荐
张小挑的博客
06-22 4万+
map
kotlin有关map和flatMap
new_abc的专栏
10-09 8166
val list= listOf(1,2,3,4,5) val list2=list.map { listOf(it+1) } list2.map { println("my value is ${it}") } println(list2) println("----------------------------") val list3 = li...
Kotlin中变换函数map与flatmap
Android、HTML、CSS、JS、JAVA、Kotlin、PHP等技术
02-10 1145
//Kotlin中变换函数map与flatmap fun main() { val list = listOf("张三", "李四", "王五") //原理：把匿名函数最后一行的返回值加入一个新的集合，新集合的泛型是R，并且返回新集合 val list2: List<Int> = list.map { //it == T == 元素 == String "[$it]" 88 } println(list2).
kotlin中的Map集合类
秦川小将
02-23 3万+
Kotlin中的Map分为： 只读Map。 可变的MutableMap(MutableMap、HashMap、LinkedHashMap)。 Map源码： private object EmptyMap : Map&lt;Any?, Nothing&gt;, Serializable { private const val serialVersionUID: L...
中国石油大学(北京)克拉玛依校区在广东2021-2024各专业最低录取分数及位次表.pdf
最新发布
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
浙江越秀外国语学院在广东2021-2024各专业最低录取分数及位次表.pdf
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
Kotlin面向对象教程：类与继承解析
"Kotlin面向对象编程的基本概念和特性，包括类、构造函数、初始化块、继承、重写以及变量初始化。" 在Kotlin中，面向对象编程是其核心特性之一，提供了丰富的语法支持，使得开发者能高效地构建可维护和可扩展的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值