Kotlin的解析(中)

前言

  通过上一篇的Kotlin介绍了一些基本的变量,方法,函数,类等的基本讲解,接下来,让我们更近一步的学习,深入一点的知识

1.  枚举类和扩展

1.1 枚举类

  Kotlin的枚举类和Java的非常相似,具有类的特性,一般会将可枚举的同类型一组值作为枚举类定义,由于每一枚举都是个对象,可能在性能上还是不推荐用,Android中已经用注解慢慢取代了,这种枚举的使用

1.1.1 枚举类的基本用法

  在kotlin中,枚举类型是以类的形式存在的,因此成为枚举类

enum class Direction {
NORTH,SOUTH,WEST,EAST
}
复制代码

1.1.2 枚举值指定对应的数值

  从下面的代码可以看出,除了基本的语法不同,实现的规则和Java的非常相似

enum class Direction private constructor(val d:Int){ 
    SOUTH(1),WEST(2);

    override fun toString(): String {
        return d.toString()
    }
}

fun main(args:Array<String>){
var dir1 : Direction = Direction. SOUTH
var dir2  = Direction. WEST
println(dir1)//输出的是1
println(dir2)//输出的是2
}
复制代码

1.1.3 枚举的其他拓展

  var dir1 : Direction = Direction. WEST
        Log.i("tag",dir1.name)//输出的是:WEST
        Log.i("tag",dir1.ordinal.toString()) //输出的是在枚举中的位置 1
        Log.i("tag",dir1.toString()) //输出的是传入的数值
        Log.i("tag",Direction.valueOf("WEST").toString()) //输出的是传入的数值

//如果要得到所有枚举的值,可以使用values的方法
for(d in Direction.values()){
println(d)
}
复制代码
1.2 扩展

  扩展是Kotlin中非常重要的功能,可以在没有源代码的情况下向类中添加成员,也可以啊子团队开发的情况下,通过扩展,将模块分散给多个人开发

1.2.1 扩展原生API

Kotlin的原生的集合扩展

//这个方法放哪里呢?一般都放在Kotlin文件顶层,当然,也可以放在调用swap方法的位置前面
fun MutableList<Int>.swap(index1:Int ,index2:Int){
            //为MutableList添加一个swap的方法,用于交互任意两个集合元素的位置
            var tmp = this[index1]
            this[index1] = this[index2]
            this[index2] = tmp;
        }

val tab = mutableListOf(1,2,3)
        tab.swap(0,2) //原生里面是没有这个方法的,通过扩展就可以了,牛逼
        Log.i("tag","jihe:  " + tab.toString())//输出[3,2,1]

复制代码

JDK标准的集合类ArrayList添加了一个hellow的方法

 fun ArrayList<Int>.hellow(string: String){
            println(string)
        }

        var list: ArrayList<Int> = ArrayList();
        list.add(20)
        list.add(30)
        list.add(40)
        list.add(50)
        list.swap(0,2)//这个是原生自带的
        list.hellow("牛逼吧!!!嘻嘻") //这个是上面自己写的一个方法
复制代码

1.2.2 扩展自定义类

  扩展类的目的很多,除了系统类需要扩展之外,我们自己编写的类有时候也需要扩展,但是我们有不想去类里面修改,这时候这个功能就相得益彰

open class Parent(val va1: Int, val va2: Int) {//使用open声明,才能允许其他类继承
    var mVal1 = va1
    var mVal2 = va2
    fun add() = this.mVal1 + this.mVal2
}

class Child(va1: Int, va2: Int) : Parent(va1, va2) {
    fun sub() = mVal1 - mVal2
}


        fun Parent.log() {
            Log.i("tag", "父类:" + "${mVal1} +${mVal2} = ${add()}")
        }

        fun Child.log() {
            Log.i("tag", "子类:" + "${mVal1} -${mVal2} = ${sub()}")
        }

        var par1: Parent = Parent(1, 2)
        var par2: Parent = Child(1, 2)
        var chil1: Child = Child(1, 2)

        par1.log()//父类:1 +2 = 3
        par2.log()//父类:1 +2 = 3
        chil1.log()//子类:1 -2 = -1



open class Parent(val va1: Int, val va2: Int) {
    var mVal1 = va1
    var mVal2 = va2
    fun add() = this.mVal1 + this.mVal2
//内部成员函数,和扩展同名,扩展覆盖不了内部
fun log() {
        Log.i("tag", "父类:自己" + "${mVal1} +${mVal2} = ${add()}")
    }
}


fun Parent.log() {
            Log.i("tag", "父类:" + "${mVal1} +${mVal2} = ${add()}")
        }

        fun Child.log() {
            Log.i("tag", "子类:" + "${mVal1} -${mVal2} = ${sub()}")
        }

        var par1: Parent = Parent(1, 2)
        var par2: Parent = Child(1, 2)
        var chil1: Child = Child(1, 2)

        par1.log()//父类:自己1 +2 = 3
        par2.log()//父类:自己1 +2 = 3
        chil1.log()//父类:自己1 +2 = 3
 
复制代码

  上面可以看出:(1)尽管par2的实例对象是Child,但是通过扩展的方法,并没有重写父类的扩展方法,因此par2调用的还是父类的方法。 (2)类内部成员函数和通过扩展添加的成员函数冲突,那么内部成员函数的优先级更高,通过扩展无法覆盖内部成员函数

1.2.3 扩展伴随对象

  如果类中有伴随对象(由于Kotlin类不支持静态成员变量,因此引入了伴随对象,来解决类没有静态成员所带来的尴尬),那么可以利用扩展对象添加成员

class SubClass  {
    companion object {
    }
}

fun  SubClass.Companion.nihao(){
           Log.i("tag","hello word!")
        }

SubClass.nihao();//不需要实例,直接类名调用
//扩展范围,放大
//在类中也可以使用扩展
复制代码

2.  数据类和封装

  数据类和封装是Kotlin中两种特殊的类,前者用于描述数据和相应的操作,后者相当于枚举类的扩展,用于描述有限的数据 #####2.1 数据类   数据类是Kotlin 的一个语法糖,Kotlin编译器会自动为数据类生产一些成员函数,以提高开发效率

2.1.1 使用数据类

//一般的类的书写
class User(var name: String, var sex: Int)  {
    var mName = name
    var mSex = sex
    override fun equals(other: Any?): Boolean {
    //重写,是不是感觉的很不爽,要写这么多
        if (other is User) {
            if (mName == other.mName && mSex == other.mSex) {
                return true
            }
        } else {
            return false
        }
        return false
    }
    override fun toString(): String {
      //重写,是不是Java中很烦,yes,很烦
        return "User {name = $mName \n sex = $mSex }"
    }
}

复制代码

  从上面User可以看出,只有name和sex是必要的,其余的都可以自动的推倒,而怎么弄呢?其实Kotlin中提供了,那就是在class前面加上data关键字就行了

data class Student(var name: String) {
    constructor():this("sdfdf")//为了添加一个无参的构造函数
}

var student = Student("xixi")
var student1 = Student("haha")
Log.i("tag", student.toString()); //输出:Student(name=xixi)
Log.i("tag", student1.toString());//输出: Student(name=haha)
Log.i("tag", student.equals(student1).toString());//输出:false
复制代码

  数据类和普通的类最大的不同,就是数据类可以根据构造器的参数自动生成相关的代码;如果Kotlin中,同事具有普通类,以及存储和管理数据的功能,建议直接使用数据类

编写数据类注意事项

(1)主构造器至少有一参数

(2)主构造器的参数必须标记为var/val

(3)数据类不能是抽象类,open类,封闭类(sealed)类或内部类(inner) 由于主构造器必须要有一个参数,不可能存在没有参数的主构造器,要想拥有,两种方案解决:

(1)为主构造器每个参数都加上默认值

data class User(val name :String="Bill", var age :Int = 10)
复制代码

(2)添加一个没有参数的构造器,调用主构造器时,指定默认参数

data class User(var name : String ,var age :Int){
//次构造函数
constructor():this("Devin","18")
}
复制代码

2.1.2 数据类成员的解构

  数据类成员解构,这里关键解构,也就是解除结构,在数据类中,用属性表示数据,这些属性属于同一数据类,要想使用这些属性,必须首先引用数据对象,这里的解构就是指将这些数据对象的属性提取出来,分别单独赋值给变量

  var student = Student("大家好")
  val (name) = student
  Log.i("tag", ";;;;;;"+name );//;;;;;;大家好
复制代码

2.1.3 封闭类

  封闭类也是Kotlin的一个语法糖,可以把它理解为枚举的扩展,一个封闭类,前面用sealed,可以有任意多个字对象,封闭类的值只能是这些字对象,使用封闭类的好处,主要是与when表达式配合,不需要再使用else形式

sealed class Icon ()
class Small() : Icon()
class Big() : Icon()

fun eval(icon: Icon) {
        when (icon) {
            is Small -> {
            }
            is Big -> {
            }
        }
    }

var big = Big()
        eval(big)
复制代码

3.  泛型

3.1 泛型基础

  所谓的泛型,就是指在定义数据结构时,只指定类型的占位符,等到使用该数据结构时在指定具体的数据类型

class Box<T>(t :T){
    var value = t
}

var box = Box<Int>(1)
Log.i("tag", ";;;;;;" + box.value);
复制代码
3.2 类型变异

  Kotlin泛型并没有提供通配符,取而代之的是out和in的关键字(1)用out声明的泛型占位符只能用在获取泛型类型值的地方(2)用in声明的泛型只能在设置泛型类型值的地方

(1). 使用out关键字

abstract class Source< out T> {
   abstract fun NextT(): T
}

fun demo(strs: Source<String>) {
//编译通过,因为T是一个out类型参数
    val ni: Source<Any> = strs
    
}
复制代码

(1).使用in关键字

abstract class Comparable<in T>{
    abstract fun comparaTo(other:T)
}

fun demo (x:Comparable<Number>){
//1.0时Double类型,Double时Number的子类型
    x.comparaTo(1.0)
    val y: Comparable<Double> = x
}
复制代码
3.3 泛型函数
 fun <T> single(item :T) :T{
        return item
    }

var single = single(1)
 Log.i("tag", ";;;;;;" + single);
复制代码
3.4 泛型约束

  最常见的约束是上界(upper bound),与Java的extends关键字相同,如果没有指定,默认使用的上界类型Any?,在定义泛型参数的尖括号内,只允许定义唯一一个上界,要是多个就的使用where

fun <T :Parent> convert(item :T){
}

fun<T>clone (list:List<T>,there:T):List<T> where T :Comparable,T:Cloneable{
//.....
}
复制代码

总结

  通过本章节的学习,了解到了枚举类,数据类,封闭类,泛型,而且学到了非常方便的一个扩展的实用语法,可以很方便的为原生Api以及其他类扩充方法,比较灵活方便,也希望此篇幅的知识对你有稍许的帮助

猜你喜欢

转载自juejin.im/post/5bf0e0466fb9a049fe34bcbf
0条评论
添加一条新回复