Kotlin的對象表達式與Java中的匿名內部類的主要區別：匿名內部類只能指定一個父類型，但對象表達式可以指定0~N個膚類型。
一、對象表達式
對象表達式的語法格式如下：
object [: 0~N個父類型]{
//對象表達式的類體部分
}
對象表達式還有如下規則：
對象表達式不能是抽象類，因為系統在創建對象表達式時會立即創建對象。因此不允許將對象表達式定義成抽象類。
對象表達式不能定義構造器。但對象表達式可以定義初始化塊，可以通過初始化塊來完成構造器需要完成的事情。
對象表達式可以包含內部類，不能包含嵌套類。
package `0705`
interface Outputable {
fun output(msg: String)
}
abstract class Product(var price: Double) {
abstract val name: String
abstract fun printInfo()
}
fun main(args: Array) {
//指定一個父類型(接口)的對象表達式
var ob1 = object : Outputable {
override fun output(msg: String) {
for (i in 1..6) {
println("${msg}")
}
}
}
ob1.output("隨便輸出點什么吧")
println("-----------------------------------------------")
//指定零個父類型的對象表達式
var ob2 = object {
//初始化塊
init {
println("初始化塊")
}
//屬性
var name = "Kotlin"
//方法
fun test() {
println("test方法")
}
//只能包含內部類，不可以包含嵌套類
inner class Inner
}
println(ob2.name)
ob2.test()
println("-----------------------------------------------")
//指定兩個父類型的對象表達式
var ob3 = object : Outputable, Product(1.23) {
override fun output(msg: String) {
println("輸出信息：${msg}")
}
override val name: String
get() = "激光打印機"
override fun printInfo() {
println("高速極光打印機們支持自動雙面打印！")
}
}
println(ob3.name)
ob3.output("Kotlin慢慢學")
ob3.printInfo()
}
輸出結果：
隨便輸出點什么吧
隨便輸出點什么吧
隨便輸出點什么吧
隨便輸出點什么吧
隨便輸出點什么吧
隨便輸出點什么吧
-----------------------------------------------
初始化塊
Kotlin
test方法
-----------------------------------------------
激光打印機
輸出信息：Kotlin慢慢學
高速極光打印機們支持自動雙面打印！
Kotlin的對象表達式可分為兩種情形：
對象表達式在方法的局部范圍內，或使用private修飾的對象表達式，Kotlin編譯器可識別對象表達式的真實類型。
非private修飾的對象表達式與Java的匿名內部類相似，編譯器只會把對象表達式當成它所繼承的父類或所實現的接口處理。如果它沒有父類型，系統當它是Any類型。
package `0705`
class ObjectExprType {
private val ob1 = object {
val name: String = "Kotlin"
}
internal val ob2 = object {
val name: String = "Kotlin"
}
private fun privateBar()=object {
val name:String="Java"
}
fun publicBar()=object {
val name:String="Java"
}
fun test(){
//ob1是private對象表達式，編譯器可識別它的真實類型
println(ob1.name)
//ob2是非private對象表達式，編譯器當它是Any類型
// println(ob2.name)
//privateBar是private函數，編譯器可識別它返回的對象表達式的真實類型
println(privateBar().name)
//publicBar是非private函數，編譯器將它返回的對象表達式當成Any類型
// println(publicBar().name)
}
}
fun main(args: Array) {
ObjectExprType().test()
}
輸出結果：
Kotlin
Java
Kotlin編譯器可以識別private對象表達式的真實類型。
Kotlin的對象表達式可訪問或修飾其作用域內的局部變量。
fun main(args: Array) {
var a = 20
var obj = object {
fun change() {
println("change()方法修改變量a的值")
a++
}
}
obj.change()
println(a)
}
輸出結果：
change()方法修改變量a的值
21
Kotlin的對象表達式比Java的匿名內部類增強了三個方面：
對象表達式可指定多個父類型
Kotlin編譯器能更準確地識別局部范圍內private對象表達式的類型。
對象表達式可訪問或修改其所在范圍內的局部變量
二、對象聲明和單例模式
對象聲明的語法格式如下：
object ObjectName [: 0~N個父類型]{
//對象表達式的類體部分
}
對象聲明與對象表達式的語法很相似，區別在于：對象表達式在object關鍵字后沒有名字；而對象聲明需要在object關鍵字后指定名字。
兩者還有如下區別：
對象表達式是一個表達式，可以被賦值給變量；而對象聲明不是表達式，不能用于賦值。
對象聲明可包含嵌套類，不能包含內部類；而對象表達式可包含內部類，不能包含嵌套類。
對象聲明不能定義在函數和方法內；但對象表達式可嵌套在其他對象聲明或非內部類中。
package `0705`
interface Outputable {
fun output(msg: String)
}
abstract class Product(var price: Double) {
abstract val name: String
abstract fun printInfo()
}
//指定一個父類型的對象表達式
object MyObject1 : Outputable {
override fun output(msg: String) {
for (i in 1..6) {
println("${msg}")
}
}
}
//指定零個父類型的對象表達式
object MyObject2 {
//初始化塊
init {
println("初始化塊")
}
//屬性
var name = "Kotlin"
//方法
fun test() {
println("test方法")
}
//只能包含嵌套類，不可以包含內部類
class Inner
}
//指定兩個父類型的對象表達式
object MyObject3 : Outputable, Product(1.23) {
override fun output(msg: String) {
println("輸出信息：${msg}")
}
override val name: String
get() = "激光打印機"
override fun printInfo() {
println("高速極光打印機們支持自動雙面打印！")
}
}
fun main(args: Array) {
MyObject1.output("一起來學Kotlin")
println("-----------------------------------------------")
println(MyObject2.name)
MyObject2.test()
println("-----------------------------------------------")
println(MyObject3.name)
MyObject3.output("Kotlin真不錯")
MyObject3.printInfo()
}
輸出結果：
一起來學Kotlin
一起來學Kotlin
一起來學Kotlin
一起來學Kotlin
一起來學Kotlin
一起來學Kotlin
-----------------------------------------------
初始化塊
Kotlin
test方法
-----------------------------------------------
激光打印機
輸出信息：Kotlin真不錯
高速極光打印機們支持自動雙面打印！
對象聲明專門用于實現單例模式，對象聲明所定義的對象也就是該類的唯一實例，程序可通過對象聲明的名稱直接訪問該類的唯一實例。
三、伴生對象和靜態成員
在類中定義的對象聲明，可使用companion修飾，這樣該對象就變成了伴生對象。
每個類最多只能定義一個伴生對象，伴生對象相當于外部類的對象，程序可通過外部類直接調用伴生對象的成員。
package `0705`
interface CompanionTest {
fun output(msg: String)
}
class MyClass {
//使用companion修飾的伴生對象
companion object MyObject1 : CompanionTest {
val name = "name屬性值"
override fun output(msg: String) {
for (i in 1..6) {
println("${msg}")
}
}
}
}
fun main(args: Array) {
//使用伴生對象所在的類調用伴生對象的方法
MyClass.output("Kotlin必須學")
println(MyClass.name)
}
輸出結果：
Kotlin必須學
Kotlin必須學
Kotlin必須學
Kotlin必須學
Kotlin必須學
Kotlin必須學
name屬性值
伴生對象的主要作用就是為其所在的外部類模擬靜態成員，但只是模擬，伴生對象的成員依然是伴生對象本身的實例成員，并不屬于伴生對象所在的外部類。
四、伴生對象的擴展
伴生對象也可以被擴展。如果一個類具有伴生對象，則Kotlin允許為伴生對象擴展方法和屬性。
package `0705`
interface CompanionTest {
fun output(msg: String)
}
class MyClass {
//使用companion修飾的伴生對象
companion object : CompanionTest {
val name = "name屬性值"
override fun output(msg: String) {
for (i in 1..6) {
println("${msg}")
}
}
}
}
//為伴生對象擴展方法
fun MyClass.Companion.test() {
println("為伴生對象擴展的方法")
}
val MyClass.Companion.foo
get() = "為伴生對象擴展的屬性"
fun main(args: Array) {
//使用伴生對象所在的類調用伴生對象的方法
MyClass.output("Kotlin必須學")
println(MyClass.name)
//通過伴生對象所在的類調用為伴生對象擴展的成員
MyClass.test()
println(MyClass.foo)
}
輸出結果：
Kotlin必須學
Kotlin必須學
Kotlin必須學
Kotlin必須學
Kotlin必須學
Kotlin必須學
name屬性值
為伴生對象擴展的方法
為伴生對象擴展的屬性
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。
