Kotlin 类 - Kotlin 构造函数

在本教程中,我们将讨论 Kotlin 的 [对象导向编程]( / 社区 / 教程 / oops-concepts-java-example) 概念,我们将详细讨论 Kotlin 类。

科特林班

kotlin class, kotlin constructor A class is a blue print defined which groups functions and properties. Classes in Kotlin are defined using the keyword class followed by the class name. The body goes inside the curly braces.

1class FirstClass {
2}

类的一个实例以如下方式实例化:

1val firstClass =  FirstClass()
2var new = FirstClass() //here new is the name of the var.

与Java不同的是,Kotlin中的新不是一个关键字,默认的类在Kotlin中是终点,所以Java中的上面的定义相当于这样:

1public final class FirstClass {
2}

因此,默认情况下,Kotlin 中的类不具有继承性. 为了使类成为非最终类,我们需要添加关键字打开。

1open class Me{
2}

开放注释允许其他人继承这个类。

科特林类例子

让我们创建一个包含几个函数和一个属性的类,我们将看到如何访问该类的函数和属性,此外,我们将看到如何设置会员属性。

 1class User {
 2
 3    var loggedIn: Boolean = false
 4    val cantChangeValue = "Hi"
 5
 6    fun logOn() {
 7        loggedIn = true
 8    }
 9
10    fun logOff() {
11        loggedIn = false
12    }
13}
14
15fun main(args: Array<String>) {
16
17    val user = User()
18    println(user.loggedIn) //false
19    user.logOn()
20    println(user.loggedIn) //true
21    user.logOff()
22    println(user.loggedIn) //false
23    user.cantChangeValue = "Hey" //won't compile. Can't modify a final variable.
24
25}

函数 main 属于 Test.kt 类. 要访问成员和函数,我们需要使用点操作员. 不能使用点操作员重新设置 val 属性。

科特林 init

Kotlin init 块定义如下所示。

 1class User {
 2
 3    init{
 4        print("Class instance is initialised.")
 5    }
 6
 7    var loggedIn: Boolean = false
 8    val cantChangeValue = "Hi"
 9
10    fun logOn() {
11        loggedIn = true
12    }
13
14    fun logOff() {
15        loggedIn = false
16    }
17}

init区块内的代码是类被实例化时首先执行的代码。 init区块每次实例化时都会运行,随后我们将看到的任何类型的构造器。

 1class MultiInit(name: String) {
 2
 3    init {
 4        println("First initializer block that prints ${name}")
 5    }
 6
 7    init {
 8        println("Second initializer block that prints ${name.length}")
 9    }
10}
11
12fun main(args: Array<String>) {
13    var multiInit = MultiInit("Kotlin")
14}
15
16//Following is printed in the log console.
17//First initializer block that prints Kotlin
18//Second initializer block that prints 6

Kotlin 类允许在声明中使用如下所示的也函数来打印属性。

 1class MultiInit(name: String) {
 2    val firstProperty = "First property: $name".also(::println)
 3
 4    init {
 5        println("First initializer block that prints ${name}")
 6    }
 7
 8    val secondProperty = "Second property: ${name.length}".also(::println)
 9
10    init {
11        println("Second initializer block that prints ${name.length}")
12    }
13}
14
15fun main(args: Array<String>) {
16
17    var multiInit = MultiInit("Kotlin")
18}
19
20//Following gets printed.
21//First property: Kotlin
22//First initializer block that prints Kotlin
23//Second property: 6
24//Second initializer block that prints 6

Kotlin 制造商

Kotlin Constructors 是用于初始化属性的特殊成员函数. Kotlin 中的 Constructors 与 Java 相比有不同的编写和结构。

 1class Student {
 2    var name: String
 3    val age : Int
 4
 5    init {
 6        name = "Anupam"
 7        age = 24
 8    }
 9
10    init {
11        name = "Anupam Chugh"
12        //age = 26
13    }
14}
15
16fun main(args: Array<String>) {
17
18    val student = Student()
19    println("${student.name} age is ${student.age}")
20    student.name = "Your"
21    //student.age = 26 //won't compile. age is val
22    println("${student.name} age is ${student.age}")
23
24}
25
26//Following is printed on the console:
27//Anupam Chugh age is 24
28//Your age is 24

主要建设者

Kotlin 中的主要制造商定义在下面的类标题中。

1class User(var name: String, var isAdmin: Boolean) {
2
3    init {
4        name = name + " @ JournalDev.com"
5        println("Author Name is $name. Is Admin? $isAdmin")
6    }
7}

主要构建者定义在类标题中。我们已经在构建器本身中定义了属性类型(val/var)。

1class User(name: String, isAdmin: Boolean)

在上面的代码中,既不能重新分配名称,也不能重新分配 isAdmin。

 1class User(name: String, val isAdmin: Boolean) {
 2
 3    var username  = name
 4    val _isAdmin = isAdmin
 5
 6    init {
 7        username= username + " @ JournalDev.com"
 8        println("Author Name is $name. Is Admin? $_isAdmin")
 9    }
10}
11
12fun main(args: Array<String>) {
13
14    var user = User("Anupam",false)
15    user.isAdmin = true //won't compile since isAdmin is val
16    user._isAdmin = true //won't compile. Same reason.
17    user = User("Pankaj",true)
18}
19
20//Following is printed in the log console.
21//Author Name is Anupam. Is Admin? false
22//Author Name is Pankaj. Is Admin? true

Kotlin 制造商默认值

Kotlin 允许我们在构建器本身中指定默认值,如下所示。

 1class User(name: String, var website: String = "JournalDev") {
 2
 3    init {
 4        println("Author $name writes at $website")
 5    }
 6
 7    init {
 8        website = website + ".com"
 9        println("Author $name writes at $website")
10    }
11}
12
13fun main(args: Array<String>) {
14
15    var user = User("Anupam","JournalDev")
16    user = User("Pankaj","JournalDev")
17}
18
19//Following is printed on the console:
20//Author Anupam writes at JournalDev
21//Author Anupam writes at JournalDev.com
22//Author Pankaj writes at JournalDev
23//Author Pankaj writes at JournalDev.com

二级建设者

二级构造者是通过键入关键字constructor来写入类的体内。

 1class Student {
 2    var name: String
 3    val age : Int
 4
 5    constructor(name: String, age: Int)
 6    {
 7        this.name = name
 8        this.age = age
 9    }
10
11    fun printDetails()
12    {
13        println("Name is $name and Age is $age")
14    }
15
16}
17
18fun main(args: Array<String>) {
19
20    var student = Student("Anupam", 24)
21    student.printDetails()
22}
23
24//Following is printed in the console.
25//Name is Anupam and Age is 24

最常见的二级构建器的用途是在分类中,当你需要以不同的方式初始化类时。如果类包含一个主要构建器,二级构建器必须在声明中参考它。

 1class Student(var name: String, val age: Int) {
 2
 3    var skill: String
 4
 5    init {
 6        skill = "NA"
 7    }
 8
 9    constructor(name: String, age: Int, skill: String) : this(name, age) {
10        this.skill = skill
11    }
12
13    fun printDetails() {
14        if (skill.equals("NA"))
15            println("Name is $name and Age is $age")
16        else
17            println("Name is $name and Age is $age Skill is $skill")
18    }
19}
20
21//Following is printed in the log console:
22//Name is Anupam and Age is 24
23//Name is Anupam and Age is 24 Skill is Kotlin

「init」块用于初始化会员属性「技能」。

定制 Getter 和 Setters

到目前为止,我们已经访问和修改了类中的属性,使用类的实例上的点操作器. 让我们使用设置和获取语法来查看我们如何定制访问。

 1class Name{
 2    var post: String = "default"
 3    set(value) {if(!post.isNotEmpty()) {
 4        throw IllegalArgumentException(" Enter a valid name")
 5    }
 6                field = value
 7                print(value)
 8    }
 9
10}
11
12fun main(args: Array<String>) {
13
14    var name = Name()
15    name.post = "Kotlin Classes"
16    name.post = ""
17    name.post = "Kotlin Data Classes Our Next Tutorial"
18
19}

以下列印在日志控制台中:

1Kotlin Classes
2
3Exception in thread "main" java.lang.IllegalArgumentException:  Enter a valid name
4    at Name.setPost(Test.kt:16)
5    at TestKt.main(Test.kt:78)

设置器中的字段变量将保存较旧的值。

 1class Name{
 2    var post: String = "default"
 3    set(value) {if(!post.isNotEmpty()) {
 4        throw IllegalArgumentException(" Enter a valid name")
 5    }
 6                field = value
 7    }
 8    get() {
 9        return field.capitalize()
10    }
11
12}
13
14fun main(args: Array<String>) {
15
16    var name = Name()
17    name.post = "kotlin classes"
18    println(name.post)
19    name.post = "kotlin data Classes our next Tutorial"
20    println(name.post)
21
22}
23
24//Following is printed:
25//Kotlin classes
26//Kotlin data Classes our next Tutorial

capitalize() 将字符串的第一个字母加值。 ** 注意**:如果属性是 val,那么 set 方法不会编译。

Kotlin 可见性更改器

公共 :具有此修改器的任何类、函数、属性、接口或对象都是可见的,可以从任何地方访问
私有:使用此修改器定义的类/函数只能在同一文件中访问。

可见性修改器也适用于制造商. 将修改器分配给主要制造商需要我们在类标题中指定关键字制造商。

 1class Student private constructor (var name: String, val age: Int) {
 2
 3    var skill: String
 4
 5    init {
 6        skill = "NA"
 7    }
 8
 9    constructor(name: String, age: Int, skill: String) : this(name, age) {
10        this.skill = skill
11    }
12
13    fun printDetails() {
14        if (skill.equals("NA"))
15            println("Name is $name and Age is $age")
16        else
17            println("Name is $name and Age is $age Skill is $skill")
18    }
19}
20
21fun main(args: Array<String>) {
22
23    var student = Student("Anupam",24,"Kotlin")
24    student.printDetails()
25}
26
27//prints
28//Name is Anupam and Age is 24 Skill is Kotlin

在上面的代码中,我们只能使用次要构建器来实例化类在不同的函数中。

科特林抽象类

与Java一样,抽象的关键字在Kotlin中被用来声明抽象类。抽象类不能被实例化.但是,它可以由子类继承。

 1abstract class Person(name: String) {
 2
 3    init {
 4        println("Abstract Class. init block. Person name is $name")
 5    }
 6
 7    abstract fun displayAge()
 8}
 9
10class Teacher(name: String): Person(name) {
11
12    var age : Int
13
14    init {
15        age = 24
16    }
17
18    override fun displayAge() {
19        println("Non-abstract class displayAge function overridden. Age is $age")
20    }
21}
22
23fun main(args: Array<String>) {
24
25    val person = Teacher("Anupam")
26    person.displayAge()
27
28}
29
30//Following is printed in the console.
31//Abstract Class. init block. Person name is Anupam
32//Non-abstract class. Age is 24

** 注意**:抽象类默认为开放。所以不需要添加一个开放的修改器来允许分类。override关键字用于分类中的方法。我们已经在本教程中涵盖了kotlin类的基础知识。还有很多其他东西,如数据类、密封类、继承等。我们将在即将到来的教程中涵盖它们。