對象表達式

有時候我們想要創建一個對當前類有一點小修改的對象，但不想重新聲明一個子
類。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++
}
})
}