Kotlin 之旅4 面向对象-CSDN博客

###Kotlin面向对象

####类的定义与初始化

示例代码如下所示：

//需要被继承的话，需要加上open标识
//类的成员需要加上var标识
open class Human(var name: String, var age: Int) {
	//构造方法的方法体
    init {
        println("我是一个${this.javaClass.simpleName},$name，今年岁$age")
    }
}

//通过冒号:来继承，成员的初始化类似于C++
class Man(name: String, age: Int) : Human(name, age) {

	//成员函数	   
	fun say() {
        println("你好，我是$name，年龄是$age")
    }
}

//类只有属性没有方法的话，就不需要大括号了
class Woman(name: String, age: Int) : Human(name, age)

fun main(args: Array<String>) {

	//构造类的对象
    val m = Man("楠宝宝", 20)
    m.say()

    val wm = Woman("璐宝宝", 18)

	//类似于Java，Kotlin中任意类都是Any的子类
	println(m is Any)
}
复制代码

其中，类的最完整的写法是要加上修饰符和constructor（构造函数）：

open class Human public constructor(var name: String, var age: Int) {
    init {
        println("我是一个${this.javaClass.simpleName},$name，今年岁$age")
    }
}
复制代码

####类的属性

如下面的代码所示，类的属性可以在构造方法的参数列表中用var或者val定义，也可以在类内部定义。（注意：没有var或者val声明的都为构造方法的一般形参）

class Man(var name: Int, args: Int) {
    var age: Int = 0
}
复制代码

Kotlin中默认为属性实现了get/set方法，但是我们可以重写，可以修改访问权限，比如我们在get/set中打印一句话：

class Man(var name: Int, args: Int) {
    var age: Int = 0

    protected set(value) {
        println("我是set方法")
        field = value
    }
    
    get() {
        println("我是get方法")
        return field
    }
}
复制代码

属性的初始化：

class X

class Man(var name: Int, args: Int) {
	//基本的几种类型可以直接用默认值初始化
    var age: Int = 0
	//var用lateinit关键字延迟初始化
    lateinit var s: String
	//val用lazy延迟初始化
    val x: X by lazy {
		//传入的是一个Lambda表达式，返回值是X类型
        X()
    }
}
复制代码

属性的初始化尽量在构造方法中完成，如果无法完成初始化，那么尝试降级为局部变量
基本的几种类型可以直接用默认值初始化，var用lateinit关键字延迟初始化，val用lazy延迟初始化
可空类型慎用null初始化，因为可空类型使用起来比较麻烦

####接口与抽象类

接口可以理解为是一种协议，不能够有状态；而抽象类可以理解为半成品，可以有状态。

例子代码如下：

interface A {
    //接口中的变量不可以初始化，也就是不能有状态，必须由类实现后使用
    var i: Int
    //与Java不一样，Kotlin中的接口可以有没有状态的默认实现
    fun a() {
        println(i)
    }
}

abstract class B {
    //抽象类中的变量必须初始化
    var j = 10
    //抽象方法必须复写
    abstract fun b()
    //非抽象方法不用复写，需要添加open关键字才能覆写
    fun c(){
        
    }
}

class C(override var i: Int) : B(), A {
    
    override fun a() {
        super.a()
    }

    override fun b() {

    }
}
复制代码

####接口代理

通过by关键字可以进行接口代理：

interface IA {
    fun a()
}

class A() : IA {
    override fun a() {
        println("test")
    }
}

//接口代理，IA的实现实际上是交给a来进行代理
class B(val a: A) : IA by a {

}

fun main(args: Array<String>) {

    val a = A()
    val b = B(a)
    b.a()

}
复制代码

####接口方法冲突

接口方法可以有默认实现。

接口冲突：签名一致，而且返回值类型相同的冲突。这时候子类（实现类）必须覆写冲突的方法，并且通过泛型类解决冲突，例如：

interface A {
    fun a(): Int {
        return 1
    }
}

interface B {
    fun a(): Int {
        return 2
    }
}

abstract class C() {
    open fun a(): Int {
        return 2
    }
}

class D() : C(), A, B {
    override fun a(): Int {
        return super<A>.a()
    }
}
复制代码

####继承

父类需要open才能被继承，抽象类除外
父类的方法、属性需要open才可以被覆写，默认都final
接口、接口方法、抽象类默认为open
覆写父类、接口的成员需要override关键字
继承类的时候实际上调用的父类的构造方法

####类成员的可见性

Kotlin中比较特殊的是internal关键字，是模块（Module）可见。

####单例

通过object关键字可以实现最简单的单例：

object MusicPlayer {
    fun play() {
        println("啦啦啦")
    }
}

fun main(args: Array<String>) {

    MusicPlayer.play()

}
复制代码

注意：

这种单例只有一个实现的对象
不能自定义构造方法
可以实现接口、继续父类

本质上，通过反编译成Java代码之后可以看到其实是最简单的单例的实现：

public final class MusicPlayer {
   public static final MusicPlayer INSTANCE;

   public final void play() {
      String var1 = "啦啦啦";
      System.out.println(var1);
   }

   private MusicPlayer() {
      INSTANCE = (MusicPlayer)this;
   }

   static {
      new MusicPlayer();
   }
}
复制代码

在Java中是这样使用这个单例的：

MusicPlayer.INSTANCE.play();
复制代码

####伴生对象与静态成员

注意点：

每个类都可以对应一个伴生对象
伴生对象的成员全局只有一个，是单例
相当于Java中的静态成员

例子：

class MusicPlayer {

    companion object {

        var SONG = "《萌萌哒》"
        @JvmField
        var TAG = MusicPlayer.javaClass.simpleName

        fun play(song: String) {
            println("啦啦啦:$song")
        }

        @JvmStatic
        fun stop() {

        }
    }

}

fun main(args: Array<String>) {

    val song = MusicPlayer.SONG
    MusicPlayer.play(song)

}
复制代码

在Java中调用的时候，加上JvmField、JvmStatic注解以后可以直接调用，不加的话必须间接调用，例如：

String song = MusicPlayer.Companion.getSONG();
MusicPlayer.Companion.play(song);

String tag = MusicPlayer.TAG;
MusicPlayer.stop();
复制代码

注意，当不是特别必要的时候，应该考虑使用包级函数，这样就可以解决使用一个类的方法导入了整个类的麻烦了，例如：

public inline fun minOf(a: Int, b: Int): Int {
    return Math.min(a, b)
}
复制代码

####方法重载与默认参数

JVM函数签名：函数名、参数列表，注意不包括返回值类型。

方法重载：方法重载主要是名称相同、参数不同的方法。

默认参数：可以为任意一个参数设置默认参数，函数调用产生混淆的时候使用具名参数即可。

下面是一个最简单的方法重载与默认参数的例子：

class A() {

	@JvmOverloads
    fun a(a: Int = 0) {
        println(a)
    }

    fun a(s: String) {
        println(s)
    }
}
复制代码

因为Java中没有默认参数，因此需要传参。需要添加@JvmOverloads才可以省略参数，直接使用默认参数。

######Tips：尽量避免使用重载。

####扩展成员

为了弥补一些类的不足，我们可以通过扩展成员来进行二次加工，例如我们可以扩展方法与属性：

//扩展方法
operator fun String.times(time: Int): String {

    val sb = StringBuilder()
    for (i in 0 until time) {
        sb.append(this)
    }

    return sb.toString()
}

//扩展属性
val String.a: String
    get() = "abc"

var String.b: String
    get() = "abc"
    set(value) {

    }

fun main(args: Array<String>) {

    val s = "1"
    //println(s.times(5))
    println(s * 5)

    println(s.a)
    println(s.b)

}
复制代码

注意：

扩展属性不能够直接初始化，需要通过实现get方法。
Java调用扩展方法、属性的相关信息，暂时放一放……

####属性代理

通过by关键字可以代理属性，类似于接口的代理：

class TestClass() {

    val s1 by lazy {
        "1"
    }

    val s2 by Delegates()

    var s3 by Delegates()

    override fun toString(): String {
        return "被代理的TestClass"
    }
}


class Delegates() {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        println("getValue 代理了 $thisRef 类的 ${property.name} 属性")
        return "2"
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("setValue 代理了 $thisRef 类的 ${property.name} 属性")
    }
}

fun main(args: Array<String>) {

    val t = TestClass()
    println(t.s1)
    println(t.s2)
    println(t.s3)

}
复制代码

对于val，代理类需要有getValue方法
对于val，代理类需要有getValue方法以及setValue方法

######Tips：代理是为了屏蔽内部的细节实现，例如我们有一个File属性，通过代理的方式，就可以把文件读取的代理写进代理里面了。

lazy也是一个代理，实现如下：

//Lazy的接口定义
public interface Lazy<out T> {
    public val value: T
    public fun isInitialized(): Boolean
}

//Lazy的扩展方法
@kotlin.internal.InlineOnly
public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value

//而Lazy的实现类是SynchronizedLazyImpl
@kotlin.jvm.JvmVersion
public fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
    private var initializer: (() -> T)? = initializer
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
    private val lock = lock ?: this
	
	//override了Lazy的value，并且重写了get方法
    override val value: T
        get() {
            val _v1 = _value
			//如果初始化了，直接返回
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return _v1 as T
            }

			//如果没有初始化，那么需要进行初始化
			//lazy有三种模式，默认是线程安全的
            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNINITIALIZED_VALUE) {
                    @Suppress("UNCHECKED_CAST") (_v2 as T)
                }
                else {
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }

    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE

    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."

    private fun writeReplace(): Any = InitializedLazyImpl(value)
}
复制代码

lazy有三种模式，默认是线程安全的模式：

@kotlin.jvm.JvmVersion
public fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
        when (mode) {
            LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
            LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
            LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
        }
复制代码

例如我们需要使用非线程安全的lazy：

val s1 by lazy(mode = LazyThreadSafetyMode.NONE) {
    "1"
}
复制代码

####数据类

类似于Java中的Bean，Kotlin中有数据类data class：

data class Person(val name: String, val age: Int)

fun main(args: Array<String>) {
    val p = Person("璐宝宝", 18)
    println(p)
}
复制代码

通过观看Kotlin的字节码，然后反编译成Java代码：

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

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final int getAge() {
      return this.age;
   }

   public Person(@NotNull String name, int age) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      super();
      this.name = name;
      this.age = age;
   }

   @NotNull
   public final String component1() {
      return this.name;
   }

   public final int component2() {
      return this.age;
   }

   @NotNull
   public final Person copy(@NotNull String name, int age) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      return new Person(name, age);
   }

   // $FF: synthetic method
   // $FF: bridge method
   @NotNull
   public static Person copy$default(Person var0, String var1, int var2, int var3, Object var4) {
      if((var3 & 1) != 0) {
         var1 = var0.name;
      }

      if((var3 & 2) != 0) {
         var2 = var0.age;
      }

      return var0.copy(var1, var2);
   }

   public String toString() {
      return "Person(name=" + this.name + ", age=" + this.age + ")";
   }

   public int hashCode() {
      return (this.name != null?this.name.hashCode():0) * 31 + this.age;
   }

   public boolean equals(Object var1) {
      if(this != var1) {
         if(var1 instanceof Person) {
            Person var2 = (Person)var1;
            if(Intrinsics.areEqual(this.name, var2.name) && this.age == var2.age) {
               return true;
            }
         }

         return false;
      } else {
         return true;
      }
   }
}
复制代码

可以看到：

Kotlin的数据类默认实现了toString、copy等方法
Kotlin的数据类是一个final类，不可以被继承，也没有默认的无参构造方法
Kotlin中有componentN方法，用于返回第几个属性

#####componentN方法

我们在Kotlin中可以这样赋值，本质上是调用了componentN方法：

val p = Person("璐宝宝", 18)
val (name, age) = p
复制代码

通过看字节码，可以看到的确是调用了componentN方法：

LINENUMBER 8 L1
NEW com/nan/kotlin/Person
DUP
LDC "\u7490\u5b9d\u5b9d"
BIPUSH 18
INVOKESPECIAL com/nan/kotlin/Person.<init> (Ljava/lang/String;I)V
ASTORE 1
复制代码

L2 LINENUMBER 9 L2 ALOAD 1 ASTORE 4 ALOAD 4 INVOKEVIRTUAL com/nan/kotlin/Person.component1 ()Ljava/lang/String; ASTORE 2 ALOAD 4 INVOKEVIRTUAL com/nan/kotlin/Person.component2 ()I ISTORE 3 ACONST_NULL ASTORE 4 L3

又例如我们在遍历数组的时候也可以这样写：

for ((index, value) in args.withIndex()) {
    println("$index : $value")
}
复制代码

withIndex()方法的实现如下：

public fun <T> Array<out T>.withIndex(): Iterable<IndexedValue<T>> {
    return IndexingIterable { iterator() }
}
复制代码

其中IndexedValue就是一个数据类：

public data class IndexedValue<out T>(public val index: Int, public val value: T)
复制代码

当然，一般的类也可以有componentN方法，注意是需要加上operator，因为这是操作符重载的方法：

class Test() {
    operator fun component1(): String {
        return "哈哈"
    }

    operator fun component2(): Int {
        return 1
    }
}

fun main(args: Array<String>) {

    val (str, i) = Test()

}
复制代码

#####构造方法与final的解决

因为Kotlin中的数据类都是final类不能被继承，又没有提供默认的构造方法，因此不能被一些含有反射构造类的框架使用。为了解决这个问题，需要引入两个插件，gradle脚本如下：

buildscript {
 
	//省略一些代码
    dependencies {
		//添加两个插件
        classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
        classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlin_version"
    }
}

//省略一些代码
apply plugin: 'kotlin-noarg'
apply plugin: 'kotlin-allopen'

//添加配置
noArg{
    annotation("com.nan.annotations.PoKo")
}

allOpen{
    annotation("com.nan.annotations.PoKo")
}

//省略一些代码
复制代码

其中的PoKo注解是一个自定义的注解：

annotation class PoKo
复制代码

最后通过看字节码可以发现我们的数据类已经不是final类型，并且有默认的构造方法了：

public class Person {
	//省略一些代码
	public Person() {
	}
}
复制代码

但是这是在编译出来字节码之后修改字节码实现的，我们自己调用的时候还是不能访问。但是我们可以通过类似于反射的手段来进行访问。

####内部类

#####内部类的访问控制

先来看一段Java代码：

public class OutterJava {

    //注意这里的访问权限
    public class InnerJava {
    }

    public static void main(String[] args) {

    }

}
复制代码

注意，内部的访问控制分为以下几种：

private：只有在外部类OutterJava的范围内可以访问
protect：在外部类OutterJava及其子类的范围内可以访问
不写权限（默认）：同一个包都可以访问
public：所有类都可以访问

然后来看Kotlin代码:

class Outter {
    private class Inner {

    }
}
复制代码

如此类推。

#####静态内部类与非静态内部类

先来说说非静态内部类，看一段Java代码：

public class OutterJava {

    public int i;

    public class InnerJava {
        public void test() {
            //非静态内部类持有外部类的this引用
            //比如下面两句代码是等价的
            System.out.println(i);
            System.out.println(OutterJava.this.i);
        }
    }

    public static void main(String[] args) {
    	//不能直接实例化内部类的对象
        //InnerJava inner = new InnerJava();
        OutterJava outter = new OutterJava();
        //非静态内部类需要用外部类的对象进行实例化
        InnerJava inner = outter.new InnerJava();
    }

}
复制代码

可以看出：

非静态内部类持有外部类的状态，即this引用
非静态内部类需要用外部类的对象进行实例化

下面来看静态内部类的Java代码：

public class OutterJava {

    public int i;

    public static class InnerJava {
        public void test() {
            //静态内部类持有外部类的this引用
            //比如下面两句代码是等价的
            //System.out.println(i);
            //System.out.println(OutterJava.this.i);
        }
    }

    public static void main(String[] args) {
        InnerJava inner = new InnerJava();
    }

}
复制代码

可以看出：

静态内部类没有持有外部类的状态、this引用
静态内部类不需要用外部类的对象进行实例化

在Kotlin中，内部类默认都是静态内部类，如果需要定义非静态内部类，需要加上inner关键字：

class Outter {

    val i: Int = 0

    inner class Inner {

        val i: Int = 1

        fun test() {
            //访问自己的i
            println(this.i)
            println(this@Inner.i)

            //访问外部类的i
            println(this@Outter.i)
        }
    }
}

fun main(args: Array<String>) {

    val outter = Outter()
    val inner = outter.Inner()

}
复制代码

下面来看看默认下的静态内部类：

class Outter {

    val i: Int = 0

    class Inner {

        val i: Int = 1

        fun test() {
            //访问自己的i
            println(this.i)
            println(this@Inner.i)

            //静态内部类不能访问外部类的i
            //println(this@Outter.i)
        }
    }
}

fun main(args: Array<String>) {

    //静态内部类可以直接初始化
    val inner = Outter.Inner()

}
复制代码

使用场景：

内部实例必须依赖外部类的实例才能运行，使用非静态内部类
只是逻辑上的关系，可以不依赖实例的时候，使用静态内部类

#####匿名内部类

关于匿名内部类，看下面的例子：

open class Test {

}

interface OnClickListener {
    fun onClick(view: View)
}

class View {
    private var mOnClickListener: OnClickListener? = null

    fun setOnClickListener(listener: OnClickListener) {
        this.mOnClickListener = listener
    }
}

fun main(args: Array<String>) {

    val view = View()
    view.setOnClickListener(object : Test(), OnClickListener {
        override fun onClick(view: View) {

        }
    })

}
复制代码

注意：

通过object类写一个匿名内部类。
与Java不同的是，写匿名内部类的时候，可以直接继承的关系，如上面的代码所示。但是这种用法用得不多。
通过查看字节码，匿名内部类在运行的时候还是会分配一个类名的，甚至我们可以通过反射去获取

####枚举类的定义、静态方法和属性

枚举类也是一个类，只不过这种类比较特殊。下面是一个Kotlin的枚举类的基本使用例子：

enum class Lang(val mHello: String) {
    
    ENGLISH("hello"),
    CHINESE("你好");

    fun sayHello() {
        println(mHello)
    }
}

fun main(args: Array<String>) {
    
    Lang.CHINESE.sayHello()
    //打印顺序
    println(Lang.CHINESE.ordinal)
    println(Lang.CHINESE.name)
    //通过名字求枚举
    Lang.valueOf("CHINESE").sayHello()
    //打印所有枚举
    Lang.values().map(::println)

}
复制代码

下面几个注意的地方的：

Kotlin中枚举类同过enum class类定义，在Java中只是把class省略了而已。编译出来的字节码内容如下：

  //实质上Kotlin把枚举编译成字节码以后，构造方法protected，并且是final类型，不可继承
  public final enum com/nan/kotlin/Lang extends java/lang/Enum  {
  
    	public final static enum Lcom/nan/kotlin/Lang; ENGLISH
  
    	public final static enum Lcom/nan/kotlin/Lang; CHINESE
  
    	//在这里的静态块（类加载的时候）里面初始化所有枚举实现
    	static <clinit>()V

  	//构造方法是protect的，但是
  	protected <init>(Ljava/lang/String;ILjava/lang/String;)V
  }
复制代码

####密封类

密封类是子类可数，枚举类是实例可数。

在Kotlin1.1之前密封类只能在内部类定义，1.1之后可以在同一个文件中定义。

//sealed class，子类可数
sealed class PlayerCmd {

    //有很多个实例有参数，枚举不能做到，因为实例有限
    class Play(val url: String, val position: Long = 0) : PlayerCmd()
    class Seek(val position: Long = 0) : PlayerCmd()
    //只有一个实例
    object Pause : PlayerCmd()
    object Resume : PlayerCmd()
    object Stop : PlayerCmd()

}
复制代码

对比枚举类：

//枚举，实例可数
enum class PlayerState{
    IDEL,PAUSE,PLAYING
}
复制代码

如果觉得我的文字对你有所帮助的话，欢迎关注我的公众号：

我的群欢迎大家进来探讨各种技术与非技术的话题，有兴趣的朋友们加我私人微信huannan88，我拉你进群交（♂）流（♀）。

Kotlin 之旅4 面向对象

“相关推荐”对你有帮助么？