Kotlin学习 - 类和对象-Toy模板网

这篇具有很好参考价值的文章主要介绍了Kotlin学习 - 类和对象。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

类定义

使用Java定义一个Person类，代码如下：

public class Person {
    private final String name;
    private final int age;

    public Person() {       
    }

    ...
}

使用Kotlin来定义这个类

class Person {
    var name = ""
    var age = 0
    fun printInfo() {
        println("$name's age is $age")
    }
}

新建对象代码：

fun main() {
   val person = Person()
   person.name = "Kotlin"
   person.age = 20
   person.printInfo()
}

//输出
Kotlin's age is 20

属性field、setter、getter

针对类中定义的每个属性，Kotlin都会产生一个field，一个getter，和一个setter（只读属性没有setter方法），field用来存储属性性的数据，无法直接定义field。Kotlin会封装field，保护里面的数据，只暴露给getter和setter使用。

Kotlin会提供默认的getter和setter方法，在需要的时候，也可以重新自定义getter和setter方法。代码如下：

class Person {
    //属性必须赋值除非是可空类型
    var nickName: String? = null
    var age = 0
    
    var name = ""
        set(value) {        	
        	field = value.trim()
        }       
        get() = field.capitalize()
}

对于可空属性的空判断使用

class Person {
	//属性必须赋值除非是可空类型
	var nickName: String? = null
    var age = 0
    
    var name = ""
        set(value) {
        	field = value.trim()
        }
        get() = field.capitalize()


    //如果一个函数即可变又可为空，可以在使用前使用also或者let进行判空处理
    fun printHello() {
   		nickName?.also {
            println("also - hello $it")
        }
        nickName?.let {
            print("let - hello $it")
        }
    }
}

关于标准库函数的使用可以看下Kotlin学习 - Kotlin中的标准函数let、with、run、apply、also，看下使用代码：

fun main() {
	var p = Person()
    p.name = "Lucky"
    println(p.name)
    p.name = " tom"
    println(p.name)
	p.nickName = "kk"
    p.printHello()
}
//运行结果
Lucky
Tom
also - hello kk
let - hello kk

类继承

反编译下上面的Kotlin代码

public final class Person {
   @NotNull
   private final String name;
   ...
}

Person类前有final修饰符，也就是默不可以被继承，而且有public修饰符，Kotlin的默认访问修饰符就是public。

如果我们声明一个新的类想继承Person，就需要借助open关键字。只需在Person类前加上open：

open class Person {
    var name = ""
    var age = 0
    fun printInfo() {
        println("$name's age is $age")
    }
}

再反编译下：

public class Person {
   @NotNull
   private final String name;
   ...
}

final修饰符没了，新建一个Student类继承Person，代码如下：

class Student : Person(){
    ...
}

类构造

1、主构造：直接写在类后面，有点像函数的入参，例如上面定义的Person类修改如下。

open class Person constructor(_name: String, val age: Int) {
    val name: String
	
	init{
		this.name = _name.capitalize()
	}
	
    fun printInfo() {
        println("$name 's age is $age")
    }
}

上面的定义中，关键字constructor表示开始构造函数的声明，如果主构造方法没有访问修饰符或注解，可以去掉该关键字。

init引入一个初始化语句块，在类创建的时候执行。

构造函数中可以定义个临时变量，然后在给属性进行赋值，例如：_name为临时变量，内部给成员属性name进行赋值。和Java中的this.name = _name一个意思。也可以直接在构造方法中定义属性，例如：val age: Int。下面是去掉关键字constructor后的代码：

open class Person (_name: String, val age: Int) {
    val name: String
	
	init{
		this.name = _name.capitalize()
	}
	
    fun printInfo() {
        println("$name 's age is $age")
    }
}

由于修改了Person的构造函数，此时Student 报错，因为之前使用的是Person无参构造，上面我们修改了Person的构造，则不存在无参构造了。修改代码如下：

class Student(name: String,  age: Int, val nickName: String, val grade: Int) : Person(name, age){
   	...
}

2、次构造
任何一个类只能有一个主构造，但是可以有多个次构造。当一个类既有主构造又有次构造函数时，所有的次构造函数都要调用主构造。

定义构造函数的时候还可以给构造函数指定默认值，当用户调用不提供值参的时候，就使用默认值，代码如下：

class Student(name: String,  age: Int, val nickName: String, val grade: Int) : Person(name, age){
    constructor(name: String, age: Int, nickName: String) : this(name, age, nickName, 8) {
        
    }
    
    constructor() : this("Default", 12, "Default", 8) {
        
    }
    ...
}

使用方式：

fun main() {
    val student1 = Student("lucky", 20, "luck", 9)
    val student2 = Student("Joice", 20, "joo")
    val student3 = Student()
    
    println("${student1.name} + ${student1.nickName} + ${student1.age} + ${student1.grade}")
    println("${student2.name} + ${student2.nickName} + ${student2.age} + ${student2.grade}")
    println("${student3.name} + ${student3.nickName} + ${student3.age} + ${student3.grade}")
}

//运行结果：
Lucky + luck + 20 + 9
Joice + joo + 20 + 8
Default + Default + 12 + 8

3、无主构造

若类不使用主构造，则后续继承类也不需要使用构造即可去掉继承类的()，次构造可以调用父类构造super进行初始化，但是次构造的参数在其他地方无法引用。

open class Person {
    var name: String = ""
    var age: Int = 0
    
    constructor(_name: String, _age: Int) {
        this.name = _name
        this.age = _age
    }
}


class Student : Person {
    constructor(name: String, age: Int, nickName: String) : super(name, age) {

    }
    
	fun study() {
        //name，age可使用
        println(name + "is studying")
        //使用nickName则会报错，若nickName是主构造的参数则可引用
        //println(nickName) 报红
    }
}

初始化块

1、init 初始化块

在上面Person 类中，出现了一个init修饰的代码块，这个看起来和Java中的静态代码块很像，其实他们用法差异很大：

Java中的static表示的是静态代码块，在类加载的时候就会执行，不是在对象创建的时候执行
Kotlin中初始化代码块会在构造类实例的时候执行，即在对象创建的时候执行

初始化代码块作用：可以设置变量或值，及执行有效性检查，例如检查传给某构造函数的值是否有效，看下例子：

open class Person (_name: String, val age: Int) {
    var name = _name;
    
	init{
        require(age > 0){"age must be positive"}
        require(name.isNotBlank()){"person must be have a name"}
    }
    
	fun printInfo() {
        println("$name 's age is $age")
    }
}

上面代码就是对构造函数的传入值进行判断，并抛出异常。

2、初始化顺序

属性可以在主构造、次构造、init代码块中执行，那么他们的执行顺序是怎么样的呢：

open class Person (_name: String, val age: Int) {
    var name = _name;
    
    constructor() : this("Default", 12) {
        println("执行次构造函数")
    }
    
	init{
		println("执行init")
        require(age > 0){"age must be positive"}
        require(name.isNotBlank()){"person must be have a name"}
    }
    
	fun printInfo() {
        println("$name 's age is $age")
    }
}

将上面代码转为Java字节码候在反编译，看下：

//主构造函数
public Person(@NotNull String _name, int age) {
	Intrinsics.checkNotNullParameter(_name, "_name");
	super();
	this.age = age;
	this.name = _name;
	
	String var3 = "执行init";
	boolean var4 = false;
	System.out.println(var3);
	boolean var7 = this.age > 0;
	var4 = false;
    boolean var5 = false;
    boolean var6;
    String var9;
    if (!var7) {
       var6 = false;
       var9 = "age must be positive";
       throw (Throwable)(new IllegalArgumentException(var9.toString()));
    } else {
       CharSequence var8 = (CharSequence)this.name;
       var4 = false;
       var7 = !StringsKt.isBlank(var8);
       var4 = false;
       var5 = false;
       if (!var7) {
          var6 = false;
          var9 = "person must be have a name";
          throw (Throwable)(new IllegalArgumentException(var9.toString()));
       }
   }         
}
//次构造函数
public Person() {
    this("Default", 12);
    String var1 = "执行次构造函数";
    boolean var2 = false;
    System.out.println(var1);
}