对象表达式

有时候我们想要创建一个对当前类有一点小修改的对象，但不想重新声明一个子
类。java 用匿名内部类的概念解决这个问题。Kotlin 用对象表达式和对象声明巧妙
的实现了这一概念。

java实现

class MyClass
{
    public String name;
    public MyClass(String name)
    {
        this.name = name;
    }
    public void verify()
    {
        System.out.println("verify");
    }
}
public class ObjectExpression
{
    public static void process(MyClass obj)
    {
        obj.verify();
    }
    public static void main(String[] args)
    {
        process(new MyClass("Mary"){
            @Override
            public void verify()
            {
                System.out.println("object verify");
            }
        });

    }
}

kotlin实现：
（1）基本使用
如果父类有构造函数，则必须传递相应的构造参数。多个父类可以用逗号隔开，跟在冒号后面

//  对象和委托：对象表达式
//  Kotlin中的对象是为了代替Java中的匿名类
open class KotlinClass(name:String)
{
    open var name = name
    open fun verify()
    {
        println("verify")
    }
}
interface MyInterface
{
    fun closeData()
    {
        println("closeData")
    }
}
fun process(obj:KotlinClass)
{
    obj.verify()
    if(obj is MyInterface)
    {
        obj.closeData()
    }
}
fun main(args: Array<String>)
{
    process(object :KotlinClass("John"),MyInterface{
        override fun verify() {
            println("object verify")
        }
    });
    //  直接建立对象
    fun foo()
    {
        val obj = object
        {
            var x:Int = 10
            var y:Int = 20
        }
        println(obj.x + obj.y)
    }
    foo()
}

（2）没有父类的对象
有时候我们只是需要一个没有父类的对象，我们可以这样写：

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

（3）访问封闭作用域内的对象
像 java 的匿名内部类一样，对象表达式可以访问闭合范围内的变量 (和 java 不一样
的是，这些变量不用是 final 修饰的)

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