对象表达式(object expression)

Java当中匿名内部类在很多场景都得到了大量使用。
Kotlin的对象表达式就是为了解决匿名内部类的一些缺陷而产生的。

内部类特点
1.匿名内部类是没有名字的类
2.匿名内部类一定继承了某个父类，或者实现了某个接口
3.Java运行时会将该匿名内部类当做它所实现的接口或是所继承的父类来看待。

对象表达式格式

object [: 若干个父类型，中间用逗号分隔]{

}

实例代码1

interface MyInterface{
    fun myPrint(i:Int)
}

abstract class MyAbstractClass {
    abstract val age: Int

    abstract fun printMyAbstractClassInfo()
}

fun main(args: Array<String>) {
    var myObject = object : MyInterface {
        override fun myPrint(i: Int) {
            println("i的值是$i")
        }

    }

    myObject.myPrint(100)

    println("--------------")

    var myObject2 = object {
        init {
            println("初始化块执行")
        }

        var myProperty = "hello world"

        fun myMethod() = "myMethod"

    }

    println(myObject2.myProperty)
    println(myObject2.myMethod())

    println("----------------")

    var myObject3 = object : MyInterface, MyAbstractClass() {
        override fun myPrint(i: Int) {
            println("i的值是$i")
        }

        override val age: Int
            get() = 30

        override fun printMyAbstractClassInfo() {
            println("printMyAbstractClassInfo invoked")
        }
    }

    myObject3.myPrint(200)
    println(myObject3.age)
    myObject3.printMyAbstractClassInfo()
}

输出

i的值是100
--------------
初始化块执行
hello world
myMethod
----------------
i的值是200
30
printMyAbstractClassInfo invoked

示例代码2

package com.leofight.kotlin3

class MyClass {
    private var myObject = object {
        fun output() {
            println("output invoked")
        }
    }

    fun myTest() {
        println(myObject.javaClass)
        myObject.output() //去掉private修饰符此处无法使用
    }

}

class MyClass2 {
    private fun method1() = object {
        val str = "hello"
    }

    internal fun method2() = object {
        var str = "world"
    }

    fun test() {
        val str = method1().str
        //val str2 = method2().str //not work
    }
}

fun main(args: Array<String>) {
    var myClass = MyClass()
    myClass.myTest()

}

输出

class com.leofight.kotlin3.MyClass$myObject$1
output invoked

匿名对象只能在局部变量范围内或者被private修饰的成员变量范围内才能被识别出其真正的类型。如果将匿名对象当做一个public方法的返回类型或者是public属性的类型，那么该方法或者属性的真正类型就是该匿名对象所声明的父类型，如果没有声明任何父类型，那么其类型就是Any;在这种情况下，匿名对象中所声明的任何成员都是无法访问的。

示例代码3

fun main(args: Array<String>) {
    var i = 100

    var myObject = object {
        fun myMethod() {
            i++
        }
    }

    myObject.myMethod()
    println(i)
}

输出

101

类似于Java的匿名内部类，Kotlin对象表达式中的代码是可以访问到外层的变量。
与Java不同的是，外层变量无需声明为final。

示例代码4（java代码）

package com.leofight.kotlin3;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class JFrameTest {

    public static void main(String[] args) {
        JFrame jFrame = new JFrame("My JFrame");
        JButton jButton = new JButton("My JButton");

        jFrame.addWindowListener(new WindowListener() {
            @Override
            public void windowOpened(WindowEvent e) {
                System.out.println("windowOpened");
            }

            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("windowClosing");
            }

            @Override
            public void windowClosed(WindowEvent e) {

            }

            @Override
            public void windowIconified(WindowEvent e) {

            }

            @Override
            public void windowDeiconified(WindowEvent e) {

            }

            @Override
            public void windowActivated(WindowEvent e) {
                System.out.println("windowActivated");
            }

            @Override
            public void windowDeactivated(WindowEvent e) {

            }
        });

//        jButton.addActionListener(new ActionListener() {
//            @Override
//            public void actionPerformed(ActionEvent e) {
//                System.out.println("Button pressed");
//            }
//        });
        //Lambda表达式
        jButton.addActionListener(event -> {
            System.out.println("Button pressed");
        });

        jFrame.add(jButton);
        jFrame.pack();
        jFrame.setVisible(true);
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

示例代码5（kotlin代码与示例代码4功能一样）

package com.leofight.kotlin3

import java.awt.event.ActionEvent
import java.awt.event.ActionListener
import java.awt.event.WindowEvent
import java.awt.event.WindowListener
import javax.swing.JButton
import javax.swing.JFrame

fun main(args: Array<String>) {
    val jFrame = JFrame("My JFrame")
    val jButton = JButton("My JButton")

    jFrame.addWindowListener(object : WindowListener {
        override fun windowDeiconified(e: WindowEvent?) {

        }

        override fun windowClosing(e: WindowEvent?) {
            println("windowClosing")
        }

        override fun windowClosed(e: WindowEvent?) {

        }

        override fun windowActivated(e: WindowEvent?) {
            println("windowActivated")
        }

        override fun windowDeactivated(e: WindowEvent?) {

        }

        override fun windowOpened(e: WindowEvent?) {
            println("windowOpened")
        }

        override fun windowIconified(e: WindowEvent?) {

        }

    })
    /*
        如果对象是Java函数式接口的一个实例（即只拥有一个抽象方法的接口），
        那么可以通过Lambda表达式来调用，其中lambda表示式前面加上接口的类型。
     */
    /* jButton.addActionListener(object :ActionListener{
         override fun actionPerformed(e: ActionEvent?) {
             println("Button pressed")
         }
 
     })*/

    //Lambda
    jButton.addActionListener({ println("Button pressed") })

    val listener = ActionListener { println("hello world") }
    println(listener.javaClass)
    println(listener.javaClass.superclass)

    println(listener::class.java)
    println(listener::class.java.superclass)

    jFrame.add(jButton)
    jFrame.pack()
    jFrame.isVisible = true
    jFrame.defaultCloseOperation = JFrame.EXIT_ON_CLOSE

}