Kotlin学习记录——4.Kotlin类进阶介绍

小灰灰 2023-06-17 06:57 14阅读 0赞

### 文章目录 ###

*  1.继承
 *  2.抽象类
 *  3.接口
 *  4.复写
 *  5.data数据类
 *  6.单例声明
 *  7.对象表达式
 *  8.伴生对象

# 1.继承 #

Kotlin 中的继承方式与 Java 类似，Java 中所有对象都继承自 Object ，而 Kotlin 中所有对象均继承自 Any。两者均不能多继承，只是表现形式不同，Kotlin 继承使用冒号 : 表示。想要复写某个方法，则也需要将方法标记为 open 的才可以被复写。

**切记一个类想要被继承，必须用 `open` 或 `abstract` 关键字 声明。**

示例如下；

open class person(name: String) // 必须申请为open才可以继承，
    class  male(name: String)： Person(name)

# 2.抽象类 #

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

示例如下：

open class person() {  
        open fun eat() { }
    }
    abstract class oldPerson(): person() {  
        abstract fun sleep()
        override abstract fun eat() // 可以覆盖已实现的方法
    }

*  抽象类和抽象方法默认是 open 关键字修饰的
 *  复写抽象类中实现的方法，也必须要加 open 关键字才可复写
 *  抽象类有抽象方法和方法的实现，可以有成员属性

# 3.接口 #

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` 关键字。

# 4.复写 #

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

*  `var` 可以复写 `val` 类型的，但是反之不行。
 *  想要复写父类的方法，父类方法必须加 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() 
        }
    }

# 5.data数据类 #

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

**需要注意的是**：

*  数据类主构造函数至少有一个参数
 *  主构造函数的所有参数需要标记为 val 或 var；

如下：

data class User(val id: String, var name: String, var age: Int)

上面的数据类，表示数据类 User 中有三个属性，其中 id 只可读，因为 id 为 val 标识，还有 name, age 两个可读可写的属性。

# 6.单例声明 #

在 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;
       }
    }

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

# 7.对象表达式 #

当需要修改一个类的部分功能，可以不通过显式实现一个该类的子类方式来实现。在 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)

# 8.伴生对象 #

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/