技术特工队Android开发经验谈Android开发

Kotlin开发基础(三)

2018-05-15  本文已影响14人  技术特工队
想第一时间获取我的最新文章,请关注公众号: 技术特工队

本篇文章主要介绍类的继承,接口,复写,单例,以及object属性的介绍。

继承

Kotlin中的继承方式与Java类似,Java中所有对象都继承自Object,而Kotlin中所有对象均继承自Any。两者均不能多继承,只是表现形式不同,Kotlin继承使用冒号表示。想要复写某个方法,则也需要将方法标记为open的才可以被复写。
切记一个类想要被继承,必须用 openabstract 关键字 声明。
示例如下;

open class person(name: String) // 必须申请为open才可以继承,

class  male(name: String): Person(name)

抽象类

抽象类与这里与Java是一致的,通过abstract关键字标记为抽象类,抽象类中抽象方法也用 abstract标记。有了abstract 则不再需要使用open进行标注了。
示例如下:

open class person() { 
    open fun eat() {}
}
abstract class oldPerson(): person() { 
    override abstract fun sleep()
}

接口

Kotlin中的接口需要使用关键字interface进行声明,Kotlin 的接口既包含抽象方法的声明,也可以包含实现,且接口中也可以申明属性,默认属性要求是抽象的,或者是提供访问器,其接口中的属性不能有field属性关键字。
示例如下:

interface MyInterface { 
    val prop: Int // 抽象的
    val propertyWithImplementation: String get() = "foo"
    fun foo() { //方法实现
        print(prop)
    } 
}
class Child : MyInterface { 
    override val prop: Int = 29
}

接口中已经实现的方法,在子类中进行复写不需要在加open关键字。
在接口中

复写

复写关键字为 override,与Java的区别是没有了@符号了。复写这里需要注意两点

  1. var可以复写val类型的,但是反之不行。
  2. 想要复写父类的方法,父类方法必须加open关键字标识。

复写的规则中,如果继承和实现了同样的方法名,则必须在子类对该方法进行复写,以为编译器不知道该调用那个父类的方法。示例如下:

open class A {
    open fun f() { print("A") } 
    fun a() { print("a") }
}
interface B {
    fun f() { print("B") } // 接口成员默认就是“open”的 
    fun b() { print("b") }
}
class C() : A(), B {
    // 编译器要求覆盖 f(),因为不知道该调用哪个父类的方法
    override fun f() {
        super<A>.f() // 调用 A.f()
        super<B>.f() // 调用 B.f() 
    }
}

data数据类

在与服务器交互中经常有数据类,在Kotlin中直接使用data标记为数据类,它会根据构造函数的属性生成equalshashcodetoString 方法,当然这块我们也是可以重写的。
需要注意的是:

  1. 数据类主构造函数至少有一个参数
  2. 主构造函数的所有参数需要标记为 valvar

单例声明

在Java中写一个单例是很麻烦的事情,也有很多种不通过的写法,需要考虑多线程问题,但在Kotlin中单例就变得简单的多,使用 object关键字就可以实现单例,我们看下示例代码:

object Person {
    fun eat(){
        print("eat")
    }
}

翻译成为Java代码如下:

public final class Person {
   public static final Person INSTANCE;

   public final void eat() {
      String var1 = "eat";
      System.out.print(var1);
   }

   static {
      Person var0 = new Person();
      INSTANCE = var0;
   }
}

看到上面代码实际为一个单例默认的饿汉模式实现。

对象表达式

当需要修改一个类的部分功能,可以不通过显式实现一个该类的子类方式来实现。在Java中,通过匿名内部类来实现;在Kotlin中,概括为对象表达式和对象声明。最常见的就是我们代码中设置Listener。示例如下:

val test = object : View.OnClickListener() {
    override fun onClick(p0: View?) {
        Log.v("TAG","click listener")
    }
}

还有这种用法

val adHoc = object {  
  var x: Int = 0  
  var y: Int = 0  
}  
print(adHoc.x + adHoc.y)  

伴生对象

Kotlin中没有静态的属性和方法的概念, Kotlin官网建议我们使用包级别的函数,来替代静态方法。当然也可以在类内使用companion object关键字声明一个伴生对象。 如下:

class Test {
    companion object {
        val  TAG = "TEST"
    }
    fun test(){
        Log.v(Test.TAG,"test method")
    }
}

object的使用有很多种,可参考这篇文章。 http://liuqingwen.me/blog/2017/06/20/object-vs-companion-object-in-kotlin/

总结:

Kotlin 中的继承和接口大体上与 Java 一致,尤其是在 Java 8 后面的语法, 接口中可以包含实现了,和抽象类的概念更近了点,但是两个还是有些许的差别,这点需要自己多体会。

上一篇 下一篇

猜你喜欢

热点阅读