Kotlin - 类和对象

Kotlin 支持函数式编程和面向对象编程。在谈论 Kotlin 的函数式特性时，我们有函数、高阶函数和 lambda 等概念，它们代表了 Kotlin 作为一种函数式语言。

Kotlin 还支持面向对象编程 (OOP)，并提供抽象、封装、继承等功能。本教程将通过简单的步骤教您所有 Kotlin OOP 功能。

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

Kotlin 类

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

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

Kotlin 类声明类似于 Java Programmig，由类头和用大括号括起来的类体组成。

class ClassName { // Class Header

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

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

Kotlin 对象

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

声明类对象的语法是：

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 程序时，它将生成以下输出：