Kotlin中的类与继承

Java三大特性继承、多态、封装
Java学习中首先学习的是类的构建,那么必然要学习构造方法、属性、方法,那么就类比着学习Java的方式去学习下Kotlin中对应的构造方法、属性、方法,按照套路我们一定是先学构造函数的,嗯就这么定了

构造函数

同Java中一样,Kotlin的某个类中构造函数可以分为最多一个主构造函数和多个次级构造函数

主构造函数

废话不多说,先写一个Person类来看看
你可以写成这样的

    class Person constructor(name:String){
    }

也可以是这样的

    class Person(name:String){
    }

甚至可以是这样的

    class Person(var name:String){
    }

区别在哪里呢？

1. 首先第一种跟第二种的区别在于主构造函数中的参数没有用注解或者可见性修饰符(就知道你会问什么是可见性修饰符)那么constructor这个关键词是可以省略的
2. 那么第二种跟第三种的区别在哪里呢？如果我要在Person里面加一个方法,打个比方人总要吃饭的是吧,所以我们就在Person里面来个eat()的方法代码就变成下面这个样子了

    class Person(var name:String){
        fun eat(){
            println("$name 吃饭喽");
        }
    }

我们要在eat()方法中使用name这个属性,相当于直接帮我们声明好属性了,惊不惊喜？
3.关于var和val，var声明的可以再次被赋值,val只能访问
4.那么又来了个问题,我写了个主构造函数,万一我要在主构造函数中搞事情怎么办？没问题满足你

    class Person(var name:String){
        init{
            println("听说你要搞事情啊！")
        }
    }

可以写在init{}代码块之中去初始化一些你想做的事情(嗯，就是你想要的)

次级构造函数

次级构造函数就好办了,跟写java差不多,但是注意一点kotlin中写次级构造函数需要委托给主构造函数(什么？你就不写？编译时候分分钟给你报错，like this

1501664287939.png

同样例子如下

    class Person(var name:String){
        constructor(name:String,age:Int)
            println("constructor $name $age")
        }
    }

1.你上面不是说构造函数不能撸代码么？大佬们,放下菜刀我说的是主构造函数不能,另外还有一个小坑就是次级构造函数的参数是不能加修饰符的,不信你试试

属性

kotlin中的属性同Java中一样,只不过修饰符不大一样,除了可以写在主构造中直接声明属性以外,还可以直接写在类中

    class Person(var name:String){
        var int age;
        val String sex;
        constructor(name:String,age:Int)
            println("constructor $name $age")
        }
    }

区别在哪里呢？var修饰的属性相当于在Java中同事提供了getter、setter方法,而val修饰的相当于只提供了getter方法

方法

    class Person(var name:String){
    var int age;
    val String sex;
        constructor(name:String,age:Int)
            println("constructor $name $age")
        }
        
        fun eat(){
        }
        
        fun eat(String food):Boolean{
            return true;
        }
        
    }

同java中一样,有方法重载,不过Kotlin中如果方法有返回值可以简写，上述重载的带参数方法可以简写为

    fun eat(String food) = true;

类之间的继承

首先Java中的继承是需要使用关键词extend的默认所有类都继承自Object。在Kotlin中默认所有类都继承自Any，如果一个类要让其他类继承,那么这类就要用open关键词修饰，如下

    open class Animal(var name: String) {

        open val age: Int = 0
    
        constructor(name: String, age: Int) : this(name)
    
        init {
            println("animal: $name,$age")
        }
    
        fun play() {
            println("$name is playing")
        }
    
        open fun sleep() {
            println("$name is sleeping")
        }
    }

上面我们声明了一个Animal的超类,然后主构造声明了var修饰的属性name,一个声明为open val的属性age,然后有一个init初始化代码块,一个play()方法,一个open修饰的sleep()方法。我先不解释,再写一个他的子类等下一起解释

    class Dog(name: String, var sex: String) : Animal(name) {
        override var age: Int = 0
    
        init {
            println("Dog: $name,$age")
        }
    
        constructor(name: String, sex: String, age: Int) : this(name, sex) {
            this.age = age
            println("Dog $name，$sex，$age")
            super.play()
        }
    
        final override fun sleep() {
            println("dog is sleeping")
            super.sleep()
        }
    }

好了写好了一个Dog类，你可能会觉得这都是啥？你写这么多我怎么看？别急别急，我来慢慢解释

1. 首先我们既然要说类的继承,在Kotlin中类的继承有两点需要注意
   • 如果超类有主构造
     • 子类的主构造参数一定要写包含父主构造的所有参数,也就是说,你可以加参数
     • 啥？Animal里面不是还有另外一个构造函数么？你为啥不让Dog继承自另一个构造函数呢？可以让Dog写继承时候继承自另一个构造函数。like this class Dog(name: String, sex: String,int age) : Animal(name，age)啥？因为Animal的次级构造会调用主构造啊
   • 如果超类没有主构造，那么子类就要实现所有父类的次级构造函数,最常见的你一定想到了,自定义View是不是！like this

    class MyView : View {
        constructor(ctx: Context) : super(ctx)
    
        constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
    }

2. 关于在Animal中声明的一个属性open val age: Int = 0没错你有看到了open关键词,也就是说只要你将来要给子类去复写那就要用open修饰,为啥我要写这个呢？涨姿势的时刻到了，Dog类中,我们有override var age: Int = 0这样一段代码,修饰符直接替换成了var,也就是说在Dog类中age这个属性变成了可读可写的,是不是很神奇，反过来写是不行的,这也是Kotlin属性声明中要注意的一点
3. 上面强调了这么多了,不用我再说方法怎么去让子类重写了吧，还是超类的方法用open去修饰,子类直接复写就ok，注意一定要带上override,什么？你不想写？小明！滚出去！

多继承及内部类

1. 与Java一样,Kotlin中每个类也是只能有一个超类,但是可以实现多个接口,比如我现在声明了一个接口fly，接口中默认所有的方法还有参数都是被abstract open 修饰的，如果子类要实现这个接口只需要在:号之后的加上fly这个接口的声明即可,其中Animal()与fly的顺序无所谓,但是一般都会把超类写到前面
2. 关于内部类调用外部类的方法,则需要this@外部类名去调用外部类的方法,如果需要调用外部类超类的方法需要super@外部类名去调用.另外内部类的声明需要inner关键词,如果你需要获取内部类实例.就一下代码来说需要这么来写Bird("1",1).Inner()与java中稍有不同

    interface fly{
        fun flying()
    }

    class Bird(name:String,age:Int):Animal(name,age),fly {
    
        override fun flying() {
            println("$name age:$age is flying")
        }
    
        inner class Inner(){
            fun test(){
                println("inner class")
                this@Bird.flying()
            }
        }
    }

好了关于构造函数就说这么多吧，你问我哪里学的。。。
教程送给各位大佬,如果你是Kotlin大神

1501664672475.png

1501664853820.png