第4章类与面向对象编程

在前面的章节中，我们学习了Kotlin的语言基础知识、类型系统等相关的知识。在本章节以及下一章中，我们将一起来学习Kotlin对面向对象编程以及函数式编程的支持。

本章我们介绍Kotlin的面向对象编程。

4.1 面向对象编程简史

50年代后期，在用FORTRAN语言编写大型程序时，由于没有封装机制，那个时候的变量都是“全局变量”，那么就会不可避免的经常出现变量名冲突问题。在ALGOL60中采用了以 Begin - End 为标识的程序块，使块内变量名是局部的，以避免它们与程序中块外的同名变量相冲突。在编程语言中首次提供了封装（保护）的机制。此后，程序块结构广泛用于Pascal 、Ada、C等高级语言之中。

60年代中后期，Simula语言在ALGOL基础上研制开发，它将ALGOL的块结构概念向前发展一步，提出了对象的概念，并使用了类，也支持类继承。其后的发展简史如下图所示：

面向对象发展简史

阿伦·凯（Alan Kay）是Smalltalk面向对象编程语言的发明人之一，也是面向对象编程思想的创始人之一，同时，他还是笔记本电脑最早的构想者和现代Windows GUI的建筑师。最早提出PC概念和互联网的也是阿伦·凯，所以人们都尊称他为“预言大师”。他是当今IT界屈指可数的技术天才级人物。

面向对象编程思想主要是复用性和灵活性（弹性）。复用性是面向对象编程的一个主要机制。灵活性主要是应对变化的特性，因为客户的需求是不断改变的，怎样适应客户需求的变化，这是软件设计灵活性或者说是弹性的问题。

Java是一种面向对象编程语言，它基于Smalltalk语言，作为OOP语言，它具有以下五个基本特性：

1.万物皆对象，每一个对象都会存储数据，并且可以对自身执行操作。因此，每一个对象包含两部分：成员变量和成员方法。在成员方法中可以改变成员变量的值。

2.程序是对象的集合，他们通过发送消息来告知彼此所要做的事情，也就是调用相应的成员函数。

3.每一个对象都有自己的由其他对象所构成的存储，也就是说在创建新对象的时候可以在成员变量中使用已存在的对象。

4.每个对象都拥有其类型，每个对象都是某个类的一个实例，每一个类区别于其它类的特性就是可以向它发送什么类型的消息，也就是它定义了哪些成员函数。

5.某一个特定类型的所有对象都可以接受同样的消息。另一种对对象的描述为：对象具有状态(数据，成员变量)、行为(操作，成员方法)和标识(成员名，内存地址)。

面向对象语言其实是对现实生活中的实物的抽象。

每个对象能够接受的请求(消息)由对象的接口所定义，而在程序中必须由满足这些请求的代码，这段代码称之为这个接口的实现。当向某个对象发送消息(请求)时，这个对象便知道该消息的目的(该方法的实现已定义)，然后执行相应的代码。

我们经常说一些代码片段是优雅的或美观的，实际上意味着它们更容易被人类有限的思维所处理。

对于程序的复合而言，好的代码是它的表面积要比体积增长的慢。

代码块的“表面积”是是我们复合代码块时所需要的信息（接口API协议定义）。代码块的“体积”就是接口内部的实现逻辑（API背后的实现代码）。

在面向对象编程中，一个理想的对象应该是只暴露它的抽象接口（纯表面，无体积），其方法则扮演箭头的角色。如果为了理解一个对象如何与其他对象进行复合，当你发现不得不深入挖掘对象的实现之时，此时你所用的编程范式的原本优势就荡然无存了。

面向对象编程是一种编程思想，相比于早期的结构化程序设计，抽象层次更高，思考解决问题的方式上也更加贴近人类的思维方式。现代编程语言基本都支持面向对象编程范式。

计算机领域中的所有问题,都可以通过向上一层进行抽象封装来解决.这里的封装的本质概念，其实就是“映射”。从面向过程到面向对象，再到设计模式，架构设计，面向服务，Sass/Pass/Iass等等的思想，各种软件理论思想五花八门，但万变不离其宗——

你要解决一个怎样的问题？
你的问题领域是怎样的？
你的模型（数据结构）是什么？
你的算法是什么？
你对这个世界的本质认知是怎样的？
你的业务领域的逻辑问题，流程是什么？
等等。

我对OO编程的目标从来就不是复用。相反，对我来说，对象提供了一种处理复杂性的方式。这个问题可以追溯到亚里士多德：您把这个世界视为过程还是对象？在OO兴起运动之前，编程以过程为中心--例如结构化设计方法。然而，系统已经到达了超越其处理能力的复杂性极点。有了对象，我们能够通过提升抽象级别来构建更大的、更复杂的系统--我认为，这才是面向对象编程运动的真正胜利。（Grady Booch，统一建模语言UML创始人）

面向对象编程的以现实世界中的事物(对象)为中心来思考, 认识问题, 并根据这些事物的本质特征, 把它们抽象表示为系统中的类。其核心思想可以用下图简要说明：

面向对象编程

面向对象编程基于类编程，更加贴近人类解决问题的习惯方法。让软件世界更像现实世界。面向对象编程通过抽象出关键的问题域来分解系统。对象不仅能表示具体的事物，还能表示抽象的规则、计划或事件。关于面向对象编程的核心的概念如下图所示

面向对象编程的核心的概念

4.2 声明类

本节介绍Kotlin中类和构造函数的声明。

4.2.1 空类

使用class关键字声明类。我们可以声明一个什么都不干的类

class AnEmptyClass

fun main(args: Array<String>) {
    val anEmptyClass = AnEmptyClass() // Kotlin中不需要使用new
    println(anEmptyClass)
    println(anEmptyClass is AnEmptyClass) // 对象实例是AnEmptyClass类型
    println(anEmptyClass::class)
}

输出

com.easy.kotlin.AnEmptyClass@2626b418
true
class com.easy.kotlin.AnEmptyClass (Kotlin reflection is not available)

4.2.2 声明类和构造函数

在Kotlin中，我们可以在声明类的时候同时声明构造函数，语法格式是在类的后面使用括号包含构造函数的参数列表

class Person(var name: String, var age: Int, var sex: String) { // 声明类和构造函数
    override fun toString(): String { // override关键字，重写toString()
        return "Person(name='$name', age=$age, sex='$sex')"
    }
}

使用这样的简洁语法，可以通过主构造器来定义属性并初始化属性值（这里的属性值可以是var或val）。

在代码中这样使用Person类

val person = Person("Jack", 29, "M")
println("person = ${person}")

输出

person = Person(name='Jack', age=29, sex='M')

另外，我们也可以先声明属性，等到构造实例对象的时候再去初始化属性值，那么我们的Person类可以声明如下

class Person1 {
    lateinit var name: String // lateinit 关键字表示该属性延迟初始化
    var age: Int = 0  // lateinit 关键字不能修饰 primitive 类型
    lateinit var sex: String
    override fun toString(): String {
        return "Person1(name='$name', age=$age, sex='$sex')"
    }
}

我们可以在代码中这样创建Person1的实例对象

    val person1 = Person1()
    person1.name = "Jack"
    person1.age = 29
    person1.sex = "M"
    println("person1 = ${person1}")

输出

person1 = Person1(name='Jack', age=29, sex='M')

如果我们想声明一个具有多种构造方式的类，可以使用 constructor 关键字声明构造函数，示例代码如下

class Person2() { // 无参的主构造函数
    lateinit var name: String
    var age: Int = 0
    lateinit var sex: String

    constructor(name: String) : this() { // this 关键字指向当前类对象实例
        this.name = name
    }

    constructor(name: String, age: Int) : this(name) {
        this.name = name
        this.age = age
    }

    constructor(name: String, age: Int, sex: String) : this(name, age) {
        this.name = name
        this.age = age
        this.sex = sex
    }

    override fun toString(): String {
        return "Person1(name='$name', age=$age, sex='$sex')"
    }
}

上面的写法，总体来看也有些样板代码，其实在IDEA中，我们写上面的代码，只需要写下面的3行，剩下的就交给IDEA自动生成了

class Person2 {
    lateinit var name: String
    var age: Int = 0
    lateinit var sex: String
}

自动生成构造函数的操作示意图

1.在当前类中“右击”鼠标操作，选择Generate （在Mac上的快捷键是 Command + N）

右击鼠标操作

点击之后，跳出对话框：生成次级构造函数

选择Generate

选择构造函数的参数

生成次级构造函数

选中相应的属性，点击OK，即可生成。

一个属性都不选，生成

constructor()

选择一个 name 属性，生成

    constructor(name: String) {
        this.name = name
    }

选择name，age属性生成

    constructor(name: String, age: Int) : this(name) {
        this.name = name
        this.age = age
    }

3个属性都选择，生成

    constructor(name: String, age: Int, sex: String) : this(name, age) {
        this.name = name
        this.age = age
        this.sex = sex
    }

最后，我们可以在代码中这样创建Person2的实例对象

    val person21 = Person2()
    person21.name = "Jack"
    person21.age = 29
    person21.sex = "M"
    println("person21 = ${person21}")

    val person22 = Person2("Jack", 29)
    person22.sex = "M"
    println("person22 = ${person22}")

    val person23 = Person2("Jack", 29, "M")
    println("person23 = ${person23}")

实际上，我们在编程实践中用到最多的构造函数，还是这个

class Person(var name: String, var age: Int, var sex: String)

而当确实需要通过比较复杂的逻辑来构建一个对象的时候，可采用构建者（Builder）模式来实现。

4.3 抽象类与接口

抽象类表示“is-a”的关系，而接口所代表的是“has-a”的关系。

抽象类用来表征问题领域的抽象概念。所有编程语言都提供抽象机制。机器语言是对机器的模仿抽象，汇编语言是对机器语言的高层次抽象，高级语言（Fortran，C，Basic等）是对汇编的高层次抽象。而我们这里所说的面向对象编程语言是对过程函数的高层次封装。这个过程如下图所示

编程语言的抽象机制

抽象类和接口是Kotlin语言中两种不同的抽象概念，他们的存在对多态提供了非常好的支持。这个机制跟Java相同。

4.3.1 抽象类与抽象成员

抽象是相对于具象而言。例如设计一个图形编辑软件，问题领域中存在着长方形(Rectangle)、圆形(Circle)、三角形(Triangle)等这样一些具体概念，它们是具象。但是它们又都属于形状(Shape)这样一个抽象的概念。它们的关系如下图所示

形状Shape的抽象继承关系

对应的Kotlin代码如下

package com.easy.kotlin

abstract class Shape

class Rectangle : Shape() // 继承类的语法是使用冒号 : , 父类需要在这里使用构造函数初始化

class Circle : Shape()

class Triangle : Shape()

因为抽象的概念在问题领域中没有对应的具体概念，所以抽象类是不能够实例化的。下面的代码编译器会报错

val s = Shape() // 编译不通过！不能实例化抽象类

我们只能实例化它的继承子类。代码示例如下

val r = Rectangle()
println(r is Shape) // true

现在我们有了抽象类，但是没有成员。通常一个类的成员有属性和函数。抽象类的成员也必须是抽象的，需要使用abstract 关键字修饰。下面我们声明一个抽象类Shape，并带有width ，heigth，radius属性和 area() 函数，代码如下

abstract class Shape {
    abstract var width: Double
    abstract var heigth: Double
    abstract var radius: Double
    abstract fun area(): Double
}

这个时候，继承抽象类Shape的方法如下

class Rectangle(override var width: Double, override var heigth: Double, override var radius: Double) : Shape() { // 声明类的同时也声明了构造函数
    override fun area(): Double {
        return heigth * width
    }
}

class Circle(override var width: Double, override var heigth: Double, override var radius: Double) : Shape() {
    override fun area(): Double {
        return 3.14 * radius * radius
    }
}

其中，override 是覆盖写父类属性和函数的关键字。

在代码中这样调用具体实现的类的函数

fun main(args: Array<String>) {
    val r = Rectangle(3.0, 4.0, 0.0)
    println(r.area()) // 12.0
    val c = Circle(0.0, 0.0, 4.0)
    println(c.area()) // 50.24
}

抽象类中可以有带实现的函数，例如我们在抽象类Shape中添加一个函数onClick()

abstract class Shape {
    ...
    fun onClick() { // 默认是final的，不可被覆盖重写
        println("I am Clicked!")
    }
}

那么，我们在所有的子类中都可以直接调用这个onClick()函数

    val r = Rectangle(3.0, 4.0, 0.0)
    r.onClick() // I am Clicked!
    val c = Circle(0.0, 0.0, 4.0)
    c.onClick() // I am Clicked!

父类Shape中的onClick()函数默认是final的，不可被覆盖重写。如果想要开放给子类重新实现这个函数，我们可以在前面加上open 关键字

abstract class Shape {
    ...
    open fun onClick() {
        println("I am Clicked!")
    }
}

在子类中这样覆盖重写

class Rectangle(override var width: Double, override var heigth: Double, override var radius: Double) : Shape() {
    override fun area(): Double {
        return heigth * width
    }

    override fun onClick(){
        println("${this::class.simpleName} is Clicked!")
    }
}

fun main(args: Array<String>) {
    val r = Rectangle(3.0, 4.0, 0.0)
    println(r.area())
    r.onClick()
}

其中，this::class.simpleName 是Kotlin中的反射的API，在Gradle工程的build.gradle中需要添加依赖 compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version" ，我们将在后面的章节中详细介绍。

上面的代码运行输出

12.0
Rectangle is Clicked!

当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。具体的原则如下：

1.能够继承父类的public和protected成员变量；不能够继承父类的private成员变量；

2.对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

3.对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

4.3.2 接口

接口是一种比抽象类更加抽象的“类”。接口本身代表的是一种“类型”的概念。但在语法层面，接口本身不是类，不能实例化接口，我们只能实例化它的实现类。

接口是用来建立类与类之间的协议。实现该接口的实现类必须要实现该接口的所有方法。在Java 8 和Kotlin中，接口可以实现一些通用的方法。

接口是抽象类的延伸，Kotlin跟Java一样，不支持同时继承多个父类，也就是说继承只能存在一个父类（单继承）。但是接口不同，一个类可以同时实现多个接口（多组合），不管这些接口之间有没有关系。这样可以实现多重继承。

和Java类似，Kotlin使用interface作为接口的关键词：

interface ProjectService

Kotlin 的接口与 Java 8 的接口类似。与抽象类相比，他们都可以包含抽象的方法以及方法的实现:

interface ProjectService {
    val name: String
    val owner: String
    fun save(project: Project)
    fun print() {
        println("I am project")
    }
}

接口是没有构造函数的。我们使用冒号: 语法来实现一个接口，如果有多个用，逗号隔开：

class ProjectServiceImpl : ProjectService // 跟继承抽象类语法一样，使用冒号
class ProjectMilestoneServiceImpl : ProjectService, MilestoneService // 实现多个接口使用逗号( ，) 隔开

在重写print()函数时，因为我们实现的ProjectService、MilestoneService都有一个print()函数，当我们直接使用super.print()时，编译器是无法知道我们想要调用的是那个里面的print函数的，这个我们叫做覆盖冲突，如下图所示

覆盖冲突

这个时候，我们可以使用下面的语法来调用：

super<ProjectService>.print()
super<MilestoneService>.print()

4.4 object对象

单例模式很常用。它是一种常用的软件设计模式。例如，Spring中的Bean默认就是单例。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例。

Kotlin中没有 静态属性和方法，但是可以使用关键字 object 声明一个object 单例对象:

package com.easy.kotlin

object User {
    val username: String = "admin"
    val password: String = "admin"
    fun hello() {
        println("Hello, object !")
    }
}

fun main(args: Array<String>) {
    println(User.username) // 跟Java的静态类一样的调用形式
    println(User.password)
    User.hello()
}

Kotlin中还提供了 伴生对象 ，用companion object关键字声明:

class DataProcessor {
    companion object DataProcessor {
        fun process() {
            println("I am processing data ...")
        }
    }
}

fun main(args: Array<String>) {
    DataProcessor.process() // I am processing data ...
}

一个类只能有1个伴生对象。

4.5 数据类

顾名思义，数据类就是只存储数据，不包含操作行为的类。Kotlin的数据类可以为我们节省大量样板代码（Java 中强制我们要去写一堆getter、setter，而实际上这些方法都是“不言自明”的），这样最终代码更易于理解和便于维护。

使用关键字为 data class 创建一个只包含数据的类：

data class LoginUser(val username: String, val password: String)

在IDEA中提供了方便的Kotlin工具箱，我们可以把上面的代码反编译成等价的Java代码。步骤如下

1.菜单栏选择：Tools -> Kotlin -> Show Kotlin Bytecode

菜单栏选择：Tools -> Kotlin -> Show Kotlin Bytecode

点击Decompile

点击Decompile

反编译之后的Java代码

反编译之后的Java代码

上面这段反编译之后的完整的Java代码是

public final class LoginUser {
   @NotNull
   private final String username;
   @NotNull
   private final String password;

   @NotNull
   public final String getUsername() {
      return this.username;
   }

   @NotNull
   public final String getPassword() {
      return this.password;
   }

   public LoginUser(@NotNull String username, @NotNull String password) {
      Intrinsics.checkParameterIsNotNull(username, "username");
      Intrinsics.checkParameterIsNotNull(password, "password");
      super();
      this.username = username;
      this.password = password;
   }

   @NotNull
   public final String component1() {
      return this.username;
   }

   @NotNull
   public final String component2() {
      return this.password;
   }

   @NotNull
   public final LoginUser copy(@NotNull String username, @NotNull String password) {
      Intrinsics.checkParameterIsNotNull(username, "username");
      Intrinsics.checkParameterIsNotNull(password, "password");
      return new LoginUser(username, password);
   }

   // $FF: synthetic method
   // $FF: bridge method
   @NotNull
   public static LoginUser copy$default(LoginUser var0, String var1, String var2, int var3, Object var4) {
      if ((var3 & 1) != 0) {
         var1 = var0.username;
      }

      if ((var3 & 2) != 0) {
         var2 = var0.password;
      }

      return var0.copy(var1, var2);
   }

   public String toString() {
      return "LoginUser(username=" + this.username + ", password=" + this.password + ")";
   }

   public int hashCode() {
      return (this.username != null ? this.username.hashCode() : 0) * 31 + (this.password != null ? this.password.hashCode() : 0);
   }

   public boolean equals(Object var1) {
      if (this != var1) {
         if (var1 instanceof LoginUser) {
            LoginUser var2 = (LoginUser)var1;
            if (Intrinsics.areEqual(this.username, var2.username) && Intrinsics.areEqual(this.password, var2.password)) {
               return true;
            }
         }

         return false;
      } else {
         return true;
      }
   }
}

编译器会从主构造函数中声明的属性，自动创建以下函数：

equals() / hashCode() 函数
toString() 格式为"LoginUser(username=" + this.username + ", password=" + this.password + ")"
component1()，component2() 函数返回对应下标的属性值，按声明顺序排列
copy() 函数: 根据旧对象属性重新 new LoginUser(username, password) 一个对象出来

如果这些函数在类中已经被明确定义了，或者从超类中继承而来，编译器就不再生成。

数据类有如下限制：

主构造函数至少包含一个参数
参数必须标识为val 或者 var
不能为 abstract, open, sealed 或者 inner
不能继承其它类 (但可以实现接口)

另外，数据类可以在解构声明中使用：

package com.easy.kotlin

data class LoginUser(val username: String, val password: String)

fun main(args: Array<String>) {
    val loginUser = LoginUser("admin", "admin")
    val (username, password) = loginUser
    println("username = ${username}, password = ${password}") // username = admin, password = admin
}

Kotlin 标准库提供了 Pair 和 Triple数据类。

4.6 注解

注解是将元数据附加到代码中。元数据信息由注解 kotlin.Metadata定义。

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.CLASS)
internal annotation class Metadata

这个@Metadata信息存在于由 Kotlin 编译器生成的所有类文件中, 并由编译器和反射读取。例如，我们使用Kotlin声明一个注解

annotation class Suspendable // Java中使用的是@interface Suspendable

那么，编译器会生成对应的元数据信息

@Retention(RetentionPolicy.RUNTIME)
@Metadata(
   mv = {1, 1, 7},
   bv = {1, 0, 2},
   k = 1,
   d1 = {"\u0000\n\n\u0002\u0018\u0002\n\u0002\u0010\u001b\n\u0000\b\u0086\u0002\u0018\u00002\u00020\u0001B\u0000¨\u0006\u0002"},
   d2 = {"Lcom/easy/kotlin/Suspendable;", "", "production sources for module kotlin_tutorials_main"}
)
public @interface Suspendable {
}

Kotlin 的注解完全兼容 Java 的注解。例如，我们在Kotlin中使用Spring Data Jpa

interface ImageRepository : PagingAndSortingRepository<Image, Long> {
   
    @Query("SELECT a from #{#entityName} a where a.isDeleted=0 and a.isFavorite=1 and a.category like %:searchText% order by a.gmtModified desc")
    fun searchFavorite(@Param("searchText") searchText: String, pageable: Pageable): Page<Image>

    @Throws(Exception::class)
    @Modifying
    @Transactional
    @Query("update #{#entityName} a set a.isFavorite=1,a.gmtModified=now() where a.id=?1")
    fun addFavorite(id: Long)
}

用起来跟Java的注解基本一样。再举个Kotlin使用Spring MVC注解的代码实例

@Controller
class MeituController {
    @Autowired
    lateinit var imageRepository: ImageRepository

    @RequestMapping(value = *arrayOf("/", "meituView"), method = arrayOf(RequestMethod.GET))
    fun meituView(model: Model, request: HttpServletRequest): ModelAndView {
        model.addAttribute("requestURI", request.requestURI)
        return ModelAndView("meituView")
    }
}

从上面的例子，我们可以看出Kotlin使用Java框架非常简单方便。

4.7 枚举

Kotlin中使用 enum class 关键字来声明一个枚举类。例如

enum class Direction {
    NORTH, SOUTH, WEST, EAST // 每个枚举常量都是一个对象, 用逗号分隔
}

相比于字符串常量，使用枚举能够实现类型安全。枚举类有两个内置的属性：

    public final val name: String
    public final val ordinal: Int

分别表示的是枚举对象的值跟下标位置。例如上面的Direction枚举类，它的枚举对象的信息如下

>>> val north = Direction.NORTH
>>> north.name
NORTH
>>> north.ordinal
0
>>> north is Direction
true

每一个枚举都是枚举类的实例，它们可以被初始化：

enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}

枚举Color的枚举对象的信息如下

>>> val c = Color.GREEN
>>> c
GREEN
>>> c.rgb
65280
>>> c.ordinal
1
>>> c.name
GREEN

4.8 内部类

4.8.1 普通嵌套类

Kotlin中，类可以嵌套。一个类可以嵌套在其他类中，而且可以嵌套多层。

class NestedClassesDemo {
    class Outer {
        private val zero: Int = 0
        val one: Int = 1

        class Nested {
            fun getTwo() = 2
            class Nested1 {
                val three = 3
                fun getFour() = 4
            }
        }
    }
}

测试代码：

    val one = NestedClassesDemo.Outer().one
    val two = NestedClassesDemo.Outer.Nested().getTwo()
    val three = NestedClassesDemo.Outer.Nested.Nested1().three
    val four = NestedClassesDemo.Outer.Nested.Nested1().getFour()

我们可以看出，代码中 NestedClassesDemo.Outer.Nested().getTwo() 访问嵌套类的方式是直接使用 类名.来访问，有多少层嵌套，就用多少层类名来访问。

普通的嵌套类，没有持有外部类的引用，所以是无法访问外部类的变量的：

class NestedClassesDemo {
class Outer {
        private val zero: Int = 0
        val one: Int = 1

        class Nested {
            fun getTwo() = 2
            fun accessOuter() = {
                println(zero) // error, cannot access outer class
                println(one)  // error, cannot access outer class
            }
        }
}
}

4.8.2 嵌套内部类

如果一个类Inner想要访问外部类Outer的成员，可以在这个类前面添加修饰符 inner。内部类会带有一个对外部类的对象的引用：

package com.easy.kotlin

class NestedClassesDemo {
    class Outer {
        private val zero: Int = 0
        val one: Int = 1

        inner class Inner {
            fun accessOuter() = {
                println(zero) // works
                println(one) // works
            }

        }
    }
}

fun main(args: Array<String>) {
    val innerClass = NestedClassesDemo.Outer().Inner().accessOuter()
}

我们可以看到，当访问inner class Inner的时候，我们使用的是Outer().Inner(), 这是持有了Outer的对象引用。跟普通嵌套类直接使用类名访问的方式区分。

4.8.3 匿名内部类

匿名内部类，就是没有名字的内部类。既然是内部类，那么它自然也是可以访问外部类的变量的。

我们使用对象表达式创建一个匿名内部类实例：

class NestedClassesDemo {
    class AnonymousInnerClassDemo {
        var isRunning = false
        fun doRun() {
            Thread(object : Runnable { // 匿名内部类
                override fun run() {
                    isRunning = true
                    println("doRun : i am running, isRunning = $isRunning")
                }
            }).start()
        }
    }
}

如果对象是函数式 Java 接口，即具有单个抽象方法的 Java 接口的实例，例如上面的例子中的Runnable接口：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

我们可以使用lambda表达式创建它，下面的几种写法都是可以的：

            fun doStop() {
                var isRunning = true
                Thread({
                    isRunning = false
                    println("doStop: i am not running, isRunning = $isRunning")
                }).start()
            }

            fun doWait() {
                var isRunning = true
                val wait = Runnable {
                    isRunning = false
                    println("doWait: i am waiting, isRunning = $isRunning")
                }
                Thread(wait).start()
            }

            fun doNotify() {
                var isRunning = true
                val wait = {
                    isRunning = false
                    println("doNotify: i notify, isRunning = $isRunning")
                }
                Thread(wait).start()
            }

更多关于Lambda表达式以及函数式编程相关内容，我们将在下一章节中介绍。

本章小结

本章我们介绍了Kotlin面向对象编程的特性：类与构造函数、抽象类与接口、继承与组合等知识，同时介绍了Kotlin中的注解类、枚举类、数据类、嵌套类、内部类、匿名内部类、单例object对象等特性类。

总的来说，在面向对象编程范式的支持上，Kotlin相比于Java增加不少有趣的功能与特性支持，这使得我们代码写起来更加方便快捷了。

我们知道，在Java 8 中，引进了对函数式编程的支持：Lambda表达式、Function接口、stream API等，而在Kotlin中，对函数式编程的支持更加全面丰富，代码写起来也更加简洁优雅。下一章中，我们来一起学习Kotlin的函数式编程。

第4章类与面向对象编程

第4章类与面向对象编程

4.1 面向对象编程简史

4.2 声明类

4.2.1 空类

4.2.2 声明类和构造函数

4.3 抽象类与接口

4.3.1 抽象类与抽象成员

4.3.2 接口

4.4 object对象

4.5 数据类

4.6 注解

4.7 枚举

4.8 内部类

4.8.1 普通嵌套类

4.8.2 嵌套内部类

4.8.3 匿名内部类

本章小结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

第4章 类与面向对象编程

第4章 类与面向对象编程

4.1 面向对象编程简史

4.2 声明类

4.2.1 空类

4.2.2 声明类和构造函数

4.3 抽象类与接口

4.3.1 抽象类与抽象成员

4.3.2 接口

4.4 object对象

4.5 数据类

4.6 注解

4.7 枚举

4.8 内部类

4.8.1 普通嵌套类

4.8.2 嵌套内部类

4.8.3 匿名内部类

本章小结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

第4章类与面向对象编程

第4章类与面向对象编程