Kotlin Class 自定义类

1.Kotlin 构造器写法有4种

1.1 第一种写法 类似Java

/**
 * 默认类  就是 public类型，并且成员变量也是 public类型
 */
class Dog {
    //成员必须 初始化 ，不像Java
    var name: String = ""
    var age: Int = 0

    //构造器第一种写法 类似Java
    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1.2 第二种写法,直接在类名后面写

/**
 * 构造器的第二种写法 直接写在类名的后面
 */
class Dog2 constructor(name: String, age: Int) {
    var name = name
    var age = age

}
1
2
3
4
5
6
7

1.3 第三种写法，直接把constructor 省略

/**
 * 构造器的第三种写法， 类似上面的，直接把constructor省略
 */
class Dog3(name:String,age:Int){
    val name =
}
1
2
3
4
5

1.4 推荐！直接在构造器中定义了接收参数

/**
 * 推荐！！！
 *
 * 构造器的第四种写法， 直接在构造器中定义好参数 省略了自定义参数接收构造器
 */
class Dog4(var name:String, var age: Int){

}
1
2
3
4
5
6
7

2. 使用自定的Class

/**
 * 自定义定义Class
 */
fun main(args: Array<String>) {

    val candyDog = Dog("candy", 23)
    println(candyDog.age)
    println(candyDog.name)

      //推荐的写法 ，它可以直接定义出来成员变量 name 和 age 
    val candyDog4 = Dog4("candy",25)
    println(candyDog4.name)
    println(candyDog4.age)

    val candyDog3 = Dog3("candy",25)
    //println(candyDog3.name)// 报错，因为没有自定义name变量
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.自定义接口

省区了public ，默认都是public

interface SimpleInfo{
    fun simpleMethod()
}
1
2

实现： 通过 :接口名称 去实现

class SimpleClass(var x:Int) :SimpleInfo{

    //override 强制需要，提醒你复写了什么方法
    override fun simpleMethod() {

    }
}

java中

@Override 并且不是强制的
1
2
3
4
5
6
7
8
9
10

4. 抽象类

abstract class AbsClass{
      //抽象方法 不需要方法体，需要被重写
    abstract fun absMethod()
        //默认是 final 方法 子类不能重写
    fun abspriviteMethod2(){}
        //open关键字 表示子类可以去重写
    open fun absPublicMethod3(){}
}
1
2
3
4
5
6
7

open class AbsChild(var x: Int) : AbsClass() , SimpleInfo{
    override fun simpleMethod() {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun absMethod() {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    //给该方法指定了 final 则 子类AbsChild2 无法重写它
    final override fun absPublicMethod3() {
    }
}


class AbsChild2(var y: Int) : AbsChild(y) {

    override fun simpleMethod() {
    }

    override fun absMethod() {
    }

      //无法重写absPublicMethod3 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

5.Property

java 定义类中的属性

public class Person {

    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

kotlin只需要这样写 即实现了get set

class Person(age: Int, name: String) {
    var age: Int = age
    var name: String = name
}
1
2
3

kotlin中类的属性 和Java中有点区别 （kotlin的幕后属性才和java的field对应）

接口不能有

age是一个property类型，它内部的field才和java的属性对应，age 默认会带有get set方法，也可以重写get set方法

class Person(age: Int, name: String) {
    var age:Int = age
    get() {
        println("get field $field")
        return field
    }
    set(value) {
        println("set field $field")
    }

    var name:String=name //name 这个 property 已经默认带了 get set 方法

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

属性引用：

属性引用和方法引用类似 通过 类名：：属性/对象：：属性

val noReceiverAgeRef = Person::age //这种是没有绑定receiver的 属性引用

val receiverAgeRef = person::age //这种是绑定了receiver的 属性引用

fun main(args: Array<String>) {

    //实例化
    val person = Person(23, "Johnny")
    println(person.age) //直接方法属性
    println(person.name)

    //绑定了receiver 的 引用
    val ageRef = person::age
    //通过property去掉用get set
    ageRef.set(25)
    println(ageRef.get())

        //未绑定receiver
    val noReceiverAgeRef = Person::age
    val person2 = Person(99, "candy")
    //未绑定receiver时候 调用set get需要先绑定
    noReceiverAgeRef.set(person2, 55)
    println(noReceiverAgeRef.get(person2))

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

欢迎大家访问 个人博客 Johnny小屋
欢迎关注个人公众号