Kotlin - 类和对象

Kotlin 支持函数式编程和面向对象编程。谈到 Kotlin 的函数式特性，我们有函数、高阶函数和 lambda 等概念，这些概念将 Kotlin 表示为一种函数式语言。

Kotlin 还支持面向对象编程 (OOP)，并提供抽象、封装、继承等特性。本教程将以简单的步骤教你所有 Kotlin OOP 特性。

面向对象编程 (OOP) 允许我们使用对象来解决复杂问题。

Kotlin 类

类是对象的蓝图，它定义了一个模板，用于创建所需的对象。

类是任何面向对象编程语言的主要构建块。Kotlin 类使用 **class** 关键字定义。以下是创建 Kotlin 类的语法：

Kotlin 类声明类似于 Java 编程，它由一个 **类头** 和一个用大括号括起来的 **类体** 组成。

class ClassName { // Class Header

   //
   // Variables or data members
   // Member functions or Methods
   //
   ...
   ...
}

默认情况下，Kotlin 类是 **public** 的，我们可以使用不同的修饰符来控制类成员的可见性，我们将在 **可见性修饰符** 中学习。

Kotlin 对象

对象是从 Kotlin 类创建的，它们共享类中定义的公共属性和行为，分别以数据成员（属性）和成员函数（行为）的形式。

声明类对象的语法是：

var varName = ClassName()

我们可以使用 **.**（点）运算符访问类的属性和方法，如下所示：

var varName = ClassName()

varName.property = <Value>
varName.functionName()

示例

以下是一个示例，我们将创建一个 Kotlin 类及其对象，通过该对象我们将访问该类的不同数据成员。

class myClass {
   // Property (data member)
   private var name: String = "Tutorialspoint.com"

   // Member function
   fun printMe() {
      print("The best Learning website - " + name)
   }
}
fun main(args: Array<String>) {
   val obj = myClass() // Create object obj of myClass class
   obj.printMe() // Call a member function using object
}

上面的代码将在浏览器中产生以下输出，我们在这里使用它自己的对象 **obj** 调用 **myClass** 的 **printMe()** 方法。

The best Learning website - Tutorialspoint.com

Kotlin 嵌套类

根据定义，当一个类在另一个类中创建时，它被称为 **嵌套类**。

Kotlin 嵌套类默认是静态的，因此，无需创建该类的任何对象即可通过 **.** 点运算符访问它。同时，我们不能在嵌套类中访问外部类的成员。

以下是创建嵌套类的简单语法：

class OuterClass{
   // Members of Outer Class
   class NestedClass{
      // Members of Nested Class
   }
}

现在我们可以像下面这样创建嵌套类的对象：

val object = OuterClass.NestedClass()

示例

以下示例显示了 Kotlin 如何解释嵌套类。

fun main(args: Array<String>) {
   val obj = Outer.Nested()

   print(obj.foo())
}
class Outer {
   class Nested {
      fun foo() = "Welcome to The TutorialsPoint.com"
   }
}

运行上述 Kotlin 程序时，将生成以下输出：

Welcome to The TutorialsPoint.com

Kotlin 内部类

当嵌套类用关键字 **inner** 标记时，它将被称为 **内部类**。内部类可以被外部类的成员访问。

与嵌套类不同，内部类可以访问外部类的成员。我们不能直接创建内部类的对象，但可以使用外部类对象创建。

以下是创建内部类的简单语法：

class OuterClass{
   // Members of Outer Class
   class inner InnerClass{
      // Members of Inner Class
   }
}

现在我们可以像下面这样创建内部类的对象：

val outerObj = OuterClass()
val innerObj = outerObj.InnerClass()

示例

以下示例显示了 Kotlin 如何解释内部类。

fun main(args: Array<String>) {
   val obj = Outer().Inner()

   print(obj.foo())
}
class Outer {
   private val welcomeMessage: String = "Welcome to the TutorialsPoint.com"
   inner class Inner {
      fun foo() = welcomeMessage
   }
}

运行上述 Kotlin 程序时，将生成以下输出：

Welcome to The TutorialsPoint.com

匿名内部类

匿名内部类是一个非常好的概念，它使程序员的生活非常轻松。每当我们实现一个接口时，匿名内部块的概念就会出现。在运行时使用对象引用创建接口的对象的概念称为匿名类。

示例

以下示例显示了如何创建接口以及如何使用匿名内部类机制创建该接口的对象。

fun main(args: Array<String>) {
   var programmer :Human = object:Human { // Anonymous class
      override fun think() { // overriding the think method
         print("I am an example of Anonymous Inner Class ")
      }
   }
   programmer.think()
}
interface Human {
   fun think()
}

运行上述 Kotlin 程序时，将生成以下输出：

I am an example of Anonymous Inner Class

Kotlin 类型别名

Kotlin 类型别名意味着为现有类型提供替代名称的方法。类型别名提供了一种更简洁的方式来编写更易读的代码。

考虑以下返回用户信息（名字、姓氏和年龄）的函数：

fun userInfo():Triple<String, String, Int>{
   return Triple("Zara","Ali",21)
}

现在我们可以为给定的 **Triple** 创建一个类型别名，如下所示：

typealias User = Triple<String, String, Int>

最后，上面的函数可以写成如下所示，它看起来比上面的代码更简洁：

fun userInfo():User{
   return Triple("Zara","Ali",21)
}

示例

以下是一个完整的可运行示例，演示了在 Kotlin 中使用类型别名。

typealias User = Triple<String, String, Int>

fun main() {
    val obj = userInfo()

    print(obj)
}

fun userInfo():User{
   return Triple("Zara","Ali",21)
}

运行上述 Kotlin 程序时，将生成以下输出：