kotlin对象表达式

1.概念

? kotlin使用对象表达式代替java的匿名内部类语法。

? 语法格式:

object : [0-N个父类型] {
}

2.特点

  • 对象表达式不能是抽象类;
  • 对象表达式不能定义构造器;
  • 对象表达式可以包含内部类(inner),但不能包含嵌套类;
  • 对象表达式可以访问或修改所在局部范围的变量(相比之下,java只能访问effectivley final局部变量)。

3.定义对象表达式

fun main() {
    var localParam = 1
    /**
     * 定义一个对象表达式,实现了Sports接口
     */
    val badminton = object : Sports {
        override val name: String
            get() = "羽毛球"
    }
    println("运动类型:${badminton.name}")//运动类型:羽毛球
    /**
     * 定义一个对象表达式,没有任何父类
     */
    val running = object {
        val name = "短跑"
        fun playRules() {
            println("在跑道上比赛")
        }

        /**
         * 访问、修改局部变量
         */
        fun changeLocalParam() {
            localParam = 2
        }
    }
    println("运动类型:${running.name}")//运动类型:短跑
    running.playRules()//在跑道上比赛
    running.changeLocalParam()
    println("修改后的局部变量:$localParam")//修改后的局部变量:2

    /**
     * 定义一个对象表达式,可以继承0~1个父类,可以实现0~N个接口
     */
    val basketball = object : Ball(true), Sports {
        override val name: String
            get() = "篮球"

        override fun playRules() {
            println("在篮球场上比赛")
        }

        /**
         * 可以定义内部类,但不可以定义嵌套类
         */
        inner class FamousBasketballPlayers(val playerNames: ArrayList<String>)
    }
    println("运动类型:${basketball.name}")//运动类型:篮球
    println("${basketball.isBelongSports}")//true
    basketball.playRules()//在篮球场上比赛
    val famousPlayers = basketball.FamousBasketballPlayers(ArrayList(listOf("乔丹", "詹姆斯", "科比")))
    println(famousPlayers.playerNames)//[乔丹, 詹姆斯, 科比]

}

/**
 * 定义一个运动接口
 */
interface Sports {
    val name: String
}

/**
 * 定义一个球类抽象类
 */
abstract class Ball(val isBelongSports: Boolean) {
    abstract fun playRules()
}

4.对象表达式可以被编译器识别类型的情况

  • 对象表达式声明在方法/函数局部范围内,被当做局部变量时,可以被编译器识别出来真实类型
  • 对象表达式不是局部变量时,使用private修饰的对象表达式才能被编译器识别出来真实类型,只会被当成父类类型的一个实例。
/**
 * 定义一个类
 */
class RecognizeObjectExpression {
    /**
     * 定义一个父类抽象类
     */
    abstract class Parent {
        abstract val parentName: String
    }

    /**
     * private修饰的对象表达式,可以被编译器识别出类型
     */
    private val expression1 = object : Parent() {
        override val parentName: String
            get() = "expression1父类名字"
        val type = "private修饰点的对象表达式"
    }
    /**
     * public修饰的对象表达式,不可以被编译器识别出类型,
     */
    val expression2 = object : Parent() {
        override val parentName: String
            get() = "expression2父类名字"
        val type = "public修饰的对象表达式"
    }

    fun recognize() {
        val localExpression3 = object : Parent() {
            override val parentName: String
                get() = "localExpression3父类名字"
            val type = "局部变量对象表达式"
        }
        //private修饰的对象表达式,可以直接被识别出真实类型,调用该对象表达式的成员
        println(expression1.type)//private修饰点的对象表达式

        //非private修饰的对象表达式,不能被识别出真实类型,不能直接调用对象表达式的成员
//        println(expression2.type)//编译不通过
        println(expression2.parentName)//但可以知道父类是什么类型

        println(localExpression3.type)//局部对象表达式,可以直接被识别出真实类型
    }
}

fun main() {
    val recognizeObjectExpression = RecognizeObjectExpression()
    recognizeObjectExpression.recognize()
}

原文地址:https://www.cnblogs.com/nicolas2019/p/10959957.html

时间: 2024-10-09 18:45:24

kotlin对象表达式的相关文章

Kotlin 对象表达式和对象声明

Kotlin 用对象表达式和对象声明来实现创建一个对某个类做了轻微改动的类的对象,且不需要去声明一个新的子类. 对象表达式 通过对象表达式实现一个匿名内部类的对象用于方法的参数中: window.addMouseListener(object : MouseAdapter() { override fun mouseClicked(e: MouseEvent) { // ... } override fun mouseEntered(e: MouseEvent) { // ... } }) 对象

Kotlin 六 对象表达式和对象声明

一 对象表达式和对象声明 Kotlin 用对象表达式和对象声明来实现创建一个对某个类做了轻微改动的类的对象,且不需要去声明一个新的子类. 对象表达式 通过对象表达式实现一个匿名内部类的对象用于方法的参数中: window.addMouseListener(object : MouseAdapter() { override fun mouseClicked(e: MouseEvent) { // ... } override fun mouseEntered(e: MouseEvent) { /

只有 assignment、call、increment、decrement 和 new 对象表达式可用作语句

错误信息:只有 assignment.call.increment.decrement 和 new 对象表达式可用作语句: 分析:发生这种情况一般是在赋值时把"="写成了"==",例如:textBox1.Text=='a';另一种情况就是调用方法是没有加(),比如this.Hide(). 解决方法: 一个是,只是用this.Close();first.Show();进行窗口跳转的时候,软件提示需要简化名称,即按照Form f1 = new first();f1.Sh

kotlin中对象表达式

在kotlin中,也有类似的功能,但不是匿名类,而是对象,需要使用object关键字,对象要继承的列需要与object之间的冒号(:)分隔. fun main(arg: Array<String>) { process(MyClass("bill"))//输出verify process(object : MyClass("bill") { override fun verify() { super.verify()//输出verify println(

ES6基础之——对象表达式

这里定义了两个变量,一个是dessert,一个是drink, let dessert='cake',drink='orange'; 一.根据两个变量的值去定义一个对象,这个对象叫food,对象里面属性跟变量的名字是一样的,属性值对应上面的变量 let dessert='cake',drink='orange'; let food={ dessert:dessert, drink:drink, } console.log(food) //{dessert:'cake',drink:'orange'

Kotlin语言深入解析

课程介绍:在2017年的Google I/O大会上,Google正式宣布Kotlin将成为Android开发的官方支持语言.一时间,关于Kotlin的相关介绍如雨后春笋般涌现出来,Kotlin也很快成为近几个月来最为火热的开发语言之一.但值得一提的是,Kotlin出现至今已经有了几年的时间,甚至有不少公司的Android App已经部分或是全部采用Kotlin进行了开发,这得益于Kotlin精巧的设计.优雅的语法以及与Java 100%的互操作性.与Java相比,Kotlin是一门年轻的语言,但

Kotlin基础-对象声明和表达式

/* * 有时候只是要对某个类进行轻微改造,供临时使用,避免继承 * 对象声明和表达式就很有用 *对面向对象编程的优化,避免一些继承导致的代价过高 * */ //对中国人来说,这个类,可能各省人适合继承 open class China(var name:String){ open val skin="yellow" } fun main(args: Array<String>) { //但如果外国人入籍,就不适合用继承 //对象表达式:val 对象名=object:类,接

Kotlin 类和对象

类定义 Kotlin 类可以包含:构造函数和初始化代码块.函数.属性.内部类.对象声明. Kotlin 中使用关键字 class 声明类,后面紧跟类名: class Runoob { // 类名为 Runoob // 大括号内是类体构成 } 我们也可以定义一个空类: class Empty 可以在类中定义成员函数: class Runoob() { fun foo() { print("Foo") } // 成员函数 } 类的属性 属性定义 类的属性可以用关键字 var 声明为可变的,

JavaScript学习笔记【2】表达式和运算符、语句、对象

笔记来自<JavaScript权威指南(第六版)> 包含的内容: 表达式和运算符 语句 对象 表达式和运算符 数组直接量中的列表逗号之间的元素可以省略,这时省略的空位会填充值undefined.元素列表末尾可以留下单个逗号,这时并不会创建一个新的值为undefined元素. 属性访问表达式,.identifier的写法只适用于要访问的属性名称是合法的标识符,并且需要知道要访问的属性的名字.如果属性名称是一个保留字或者包含空格和标识符,或是一个数字(对于数组来说),则必须使用方括号的写法.当属性