精华内容
下载资源
问答
  • Kotlin的对象表达式与Java中的匿名内部类的主要区别:匿名内部类只能指定一个父类型,但对象表达式可以指定0~N个肤类型。 一、对象表达式 对象表达式的语法格式如下: object [: 0~N个父类型]{ //对象表达式的类...
  • 错误信息:只有 assignment、call、increment、decrement 和 new 对象表达式可用作语句; 分析:发生这种情况一般是在赋值时把“=”写成了“==”,例如:textBox1.Text=='a';另一种情况就是调用方法是没有加(),...

    错误信息:只有 assignment、call、increment、decrement 和 new 对象表达式可用作语句;

    分析:发生这种情况一般是在赋值时把“=”写成了“==”,例如:textBox1.Text=='a';另一种情况就是调用方法是没有加(),比如this.Hide()。

    解决方法:

    一个是,只是用this.Close();first.Show();进行窗口跳转的时候,软件提示需要简化名称,即按照Form f1 = new first();f1.Show();的样式进行书写。


     

    第二个是,按照上述修改后,运行程序的时候,这两个窗口都被关闭了。这是因为C#里面的窗体是线程创建的,一个窗体就是一个线程的。
    从第一个线程里面new出来的窗体,是上一个窗体的子线程。所以,当父线程关闭后,就会关闭掉子线程了。解决方法是,创建一个窗体或者线程。
    如果是窗体就隐藏这个主窗体(主线程)即使用this.Hide()。还可以在Program.cs文件里面 加入Application.Run(new 窗体名());
    类似于一种声明,表示在当前线程上开始运行标准应用程序消息循环,并使指定窗体可见。

    转载于:https://www.cnblogs.com/jlutiger/p/9337699.html

    展开全文
  • ES6对象表达式和添加属性

    万次阅读 2019-03-12 11:10:18
    我们定义了2个变量,books对象的属性刚好和定义的变量名相同,则可以简写。 如果对象属性study是个方法,则可以简写为study(){} let books = { study:function(){ } }; let js = "javascript", ...

    对象表达式

    我们定义了2个变量,books对象的属性刚好和定义的变量名相同,则可以简写。
    如果对象属性study是个方法,则可以简写为study(){}

    let books = {
    	study:function(){
    	}
    };
    
    let js = "javascript",
    	h5 = "html4";
    let books = {
    	js,//如果属性名和变量名字一样,并且属性的值就是变量的值可以这样简写 等价于js:js
    	h5,
    	study(){
    		return `我要学习${js}${h5}`;
    	}
    }
    console.log(books.study());
    

    对象属性

    let books = {};
    let c3 = "new css";
    books.js = "javascript";
    books["new html"] = "html5";
    books[c3] = "css3";
    console.log(books);
    

    我们定义了一个books的空对象,我们可以直接用.给对象添加属性
    如果属性名存在空格,可以使用[""],也可以使用变量。

    展开全文
  • 对象表达式与对象声明 有时候,我们需要创建一个对某个类做了轻微改动的类的对象,而不用为之显式声明新的子类。 Kotlin 用对象表达式和对象声明处理这种情况。 对象表达式 要创建一个继承自某个(或某些)类型的...

    对象表达式与对象声明

    有时候,我们需要创建一个对某个类做了轻微改动的类的对象,而不用为之显式声明新的子类。 Kotlin 用对象表达式和对象声明处理这种情况。

    对象表达式

    要创建一个继承自某个(或某些)类型的匿名类的对象,我们会这么写:

    window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) { /*……*/ }
    
        override fun mouseEntered(e: MouseEvent) { /*……*/ }
    })
    

    如果超类型有一个构造函数,则必须传递适当的构造函数参数给它。 多个超类型可以由跟在冒号后面的逗号分隔的列表指定:

    open class A(x: Int) {
        public open val y: Int = x
    }
    
    interface B { /*……*/ }
    
    val ab: A = object : A(1), B {
        override val y = 15
    }
    

    任何时候,如果我们只需要“一个对象而已”,并不需要特殊超类型,那么我们可以简单地写:

    fun foo() {
        val adHoc = object {
            var x: Int = 0
            var y: Int = 0
        }
        print(adHoc.x + adHoc.y)
    }
    

    请注意,匿名对象可以用作只在本地和私有作用域中声明的类型。如果你使用匿名对象作为公有函数的返回类型或者用作公有属性的类型,那么该函数或属性的实际类型会是匿名对象声明的超类型,如果你没有声明任何超类型,就会是 Any。在匿名对象中添加的成员将无法访问。

    class C {
        // 私有函数,所以其返回类型是匿名对象类型
        private fun foo() = object {
            val x: String = "x"
        }
    
        // 公有函数,所以其返回类型是 Any
        fun publicFoo() = object {
            val x: String = "x"
        }
    
        fun bar() {
            val x1 = foo().x        // 没问题
            val x2 = publicFoo().x  // 错误:未能解析的引用“x”
        }
    }
    

    对象表达式中的代码可以访问来自包含它的作用域的变量。

    fun countClicks(window: JComponent) {
        var clickCount = 0
        var enterCount = 0
    
        window.addMouseListener(object : MouseAdapter() {
            override fun mouseClicked(e: MouseEvent) {
                clickCount++
            }
    
            override fun mouseEntered(e: MouseEvent) {
                enterCount++
            }
        })
        // ……
    }
    

    对象声明

    单例模式在一些场景中很有用, 而 Kotlin(继 Scala 之后)使单例声明变得很容易:

    object DataProviderManager {
        fun registerDataProvider(provider: DataProvider) {
            // ……
        }
    
        val allDataProviders: Collection<DataProvider>
            get() = // ……
    }
    

    这称为对象声明。并且它总是在 object 关键字后跟一个名称。 就像变量声明一样,对象声明不是一个表达式,不能用在赋值语句的右边。

    对象声明的初始化过程是线程安全的并且在首次访问时进行。

    如需引用该对象,我们直接使用其名称即可:

    DataProviderManager.registerDataProvider(……)
    

    这些对象可以有超类型:

    object DefaultListener : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) { …… }
    
        override fun mouseEntered(e: MouseEvent) { …… }
    }
    

    注意:对象声明不能在局部作用域(即直接嵌套在函数内部),但是它们可以嵌套到其他对象声明或非内部类中。

    伴生对象

    类内部的对象声明可以用 companion 关键字标记:

    class MyClass {
        companion object Factory {
            fun create(): MyClass = MyClass()
        }
    }
    

    该伴生对象的成员可通过只使用类名作为限定符来调用:

    val instance = MyClass.create()
    

    可以省略伴生对象的名称,在这种情况下将使用名称 Companion:

    class MyClass {
        companion object { }
    }
    
    val x = MyClass.Companion
    

    其自身所用的类的名称(不是另一个名称的限定符)可用作对该类的伴生对象 (无论是否具名)的引用:

    class MyClass1 {
        companion object Named { }
    }
    
    val x = MyClass1
    
    class MyClass2 {
        companion object { }
    }
    
    val y = MyClass2
    

    请注意,即使伴生对象的成员看起来像其他语言的静态成员,在运行时他们仍然是真实对象的实例成员,而且,例如还可以实现接口:

    interface Factory<T> {
        fun create(): T
    }
    
    class MyClass {
        companion object : Factory<MyClass> {
            override fun create(): MyClass = MyClass()
        }
    }
    
    val f: Factory<MyClass> = MyClass
    

    当然,在 JVM 平台,如果使用 @JvmStatic 注解,你可以将伴生对象的成员生成为真正的静态方法和字段。更详细信息请参见Java 互操作性一节 。

    对象表达式和对象声明之间的语义差异
    对象表达式和对象声明之间有一个重要的语义差别:

    • 对象表达式是在使用他们的地方立即执行(及初始化)的;
    • 对象声明是在第一次被访问到时延迟初始化的;
    • 伴生对象的初始化是在相应的类被加载(解析)时,与 Java 静态初始化器的语义相匹配。
    展开全文
  • 在Kotlin中,oject的神奇之对象表达式,什么是对象表达式呢?我们把它认为是一个匿名类的实例,该匿名类可以继承自某个类或者多个接口。不过,我们需要通过object关键字将其声明,表示这是一个对象。对于文章开始的...

    概述

    在Java中,不管是为了实现接口,或者是抽象类,我们总是习惯使用匿名内部类。最熟悉的例子,莫过于对单击事件的监听,也就是这样写:

    btn.setOnClickListener(new OnClickListener{
        // 处理单击事件逻辑
        *** 
    });
    

    尽管该匿名类只能被使用一次,这样,我们没有必要再去实现OnClickListener接口并创建一个类,从而简化了代码。可是,在Kotlin中,并没有匿名类这一概念。巧妇无米之炊啊,碰到监听事件或者回调,是不是得老老实实的写一个实现类呢???尽管Kotlin没有匿名内部类,恰巧其用object一个简单的关键字,解决了这一个问题。下面我们来看看神奇的object有什么魔法效果呢?

    对象表达式

    在Kotlin中,oject的神奇之对象表达式,什么是对象表达式呢?我们把它认为是一个匿名类的实例,该匿名类可以继承自某个类或者多个接口。不过,我们需要通过object关键字将其声明,表示这是一个对象。对于文章开始的单击事件监听我们可以这么写:

    btn.setOnClickListener(object : OnClickListener{
        // 处理单击事件逻辑
        *** 
    });
    


    1. 如果被继承的基类中为有参构造器且没有无参构造器时,那么必须向构造器传递适当的参数,否则编译器会报错。
    2. 对象表达式内的代码可以访问创建这个对象的代码范围内的变量,与Java不同的是,被访问的变量不需要被限制为final变量。

      val a = 10
      
      val listener = object : Info("submit"),IClickListener {
          override fun doClick() {
              println("a:$a")
          }
      
      }
      
      listener.doClick() // 打印 a:10
      
    3. “只需要对象”, 而不需要继承任何有价值的基类, 可以简单写:

      val adHoc = object {
          var x: Int = 0
          var y: Int = 0
      }
      
      print(adHoc.x + adHoc.y)
      

    对象声明

    当关键字object之后指定了一个名称, 那么它就不再是“对象表达式”,而是一个对“对象声明”。此时,此对象不再是表达式,看作类的变种更为合适吧,不能再将其赋值给一个变量。在使用它时,只需要它的名字引用即可。

    object MyInfo: Info("submit"),IClickListener {
    
        override fun doClick() {
            println("MyInfo do click, $text") // Log: MyInfo do click, , submit
        }
    }
    
    fun main(args: Array<String>) {
    
        MyInfo.doClick()
    }
    


    注:

    1. 对象声明不可以是局部的(也就是说, 不可以直接嵌套在函数之内), 但可以嵌套在另一个对象声明之内, 或者嵌套在另一个非内部类(non-inner class)内。
    2. 被成名的对象可以被指定基类(类、接口)
    3. 对象声明不能指定构造函数
    4. 与对象表达式相似,如果被继承的基类中为有参构造器且没有无参构造器时,那么必须向构造器传递适当的参数,否则编译器会报错。

    伴随对象

    这里又有一个疑惑,实际开发时,我们总是把公用的方法,声明为静态方法,以便在任何地方都可以调用。可是,在Kotlin中,并不支持静态方法,尽管官方推荐我们使用包级别的方法,可是这远远不能满足我们的需求。有人说了,我们可以声明一个对象,在这个对象中包含这个这些公有的方法。如果这么做,每次调用时都需要创建一个新的对象,就算是使用了单例模式,也与我们的想法相离甚远。

    在Kotlin中,有这么一个关键字 companion,可以用来标记对象声明。假如用其标注声明对象,又有什么效果呢?例如:在类Books内,声明对象ComBooks,并用companion关键字

    class Books(var name: String, val page: Int) {
        companion object ComBooks{
            val a : Int = 10
            fun doNote() {
                println("do note")
            }
        }
    }
    
    fun main(args: Array<String>) {
        Books.ComBooks.doNote()
    
        println("Book.a = ${Books.ComBooks.a}")
    
        println("-------------")
    
        Books.doNote()
    
    }
    
    // Log
    do note
    Book.a = 10
    -------------
    do note
    

    从上述代码中,我们可以看出 伴随对象的调用不用创建包含伴随对象的实例,调用方式有两种,一种是类名.伴随对象.XX,另外一种方式是类名.xx。这也没有什么啊?只不过是在类的内部,声明了一个对象而已,也没有啥变化。费解….

    对象表达式(声明)和伴随对象的区别

    • 对象表达式在使用的地方被立即执行。
    • 对象声明是延迟加载的, 在第一次使用的时候被初始化。
    • 伴生对象所在的类被加载,伴生对象被初始化,与Java静态成员一样。(啊啊啊 这里才算明白,伴随对象的效果啊!!!)




    Kotlin讨论群:451492685

    展开全文
  • ES6中对象的字面量是发生了翻天覆地的变化,变得非常简便 目录 属性简洁表达式 属性名表达式 方法的name属性 属性简洁表达式 ES6中允许使用变量来作为属性和方法,书写更简便。 const foo = "bar"...
  • 编译器错误消息: CS0201: 只有 assignment、call、increment、decrement 和 new 对象表达式可用作语句
  • Kotlin基础教程-对象表达式和声明

    千次阅读 2017-06-06 11:56:44
    对象表达式和声明 对象表达式open class E(x: Int) { public open val y: Int = x } val ab = object : E(1){ override val y = 14 }代码扩展了类E的成员属性,增加了y属性。对象声明object Singleton { val name...
  • C#基于表达式(Expression)实现对象深拷贝,包含了核心类及示例数据。这是一个比较简单的帮助类,可作学习参考
  • 只有assignment、call、increment和new对象表达式可用作语句 是怎么一回事??原因之一:原来是程序中多写了一个等于号this.Lable1.ForeColor== Color.Blue;应该换成this.Lable1.ForeColor= Color.Blue; 
  • JavaScript提供了一个RegExp对象来完成有关正则表达式的操作和功能,每一条正则表达式模式对应一个RegExp实例。有两种方式可以创建RegExp对象的实例。
  • Python中的类提供了面向对象编程的所有基本功能:类的继承机制允许多个基类,派生类可以覆盖基类中的任何方法,方法中可以调用基类中的...这篇文章主要介绍了Python面向对象总结及类与正则表达式 ,需要的朋友可以参考下
  • 易语言正则表达式对象类模块源码 系统结构:创建,匹配,搜索全部,取匹配文本,取子表达式个数,取子匹配文本, ======窗口程序集1 | | | |------ __启动窗口_创建完毕 | | | |------ _按钮1_被单击
  • 主要介绍了Java 使用正则表达式对象实现正则的获取功能 ,需要的朋友可以参考下
  • 第2章 运算符、表达式与内置对象
  • 主要介绍了EL表达式的隐式对象,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 这里新建一个UserInfo对象,用来测试lambda表达式排序,属性如下: public class UserInfo { private int id; private int age; private String name; public UserInfo(int id, int age, String name) { this....
  • EL表达式获取对象属性的原理是这样的: 以表达式${user.name}为例 EL表达式会根据name去User类里寻找这个name的get方法,此时会自动把name首字母大写并加上get前缀,一旦找到与之匹配的方法,El表达式就会认为这就是...
  •  RegExp对象表示正则表达式,RegExp是正则表达式的缩写,它是对字符串执行模式匹配的强大工具。RegExp对象用于规定在文本中检索的内容。当您检索某个文本时,可以使用一种模式来描述要检索的内容。RegExp就是这种...
  • 我们知道,访问对象的属性的时候有两种写法:...答案是在写法二中,我们可以在方括号中写入表达式,用表达式的值作为对象的属性。所以写法二还可以写成如下的形式:demo1['prop' + '2'] = 2; 在ES5的年代,在对象字面量
  • 易语言正则表达式对象源码,正则表达式对象,正则表达式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 916,773
精华内容 366,709
关键字:

对象表达式