《在飞Android Kotlin实战》之基础篇7

hi各位亲，这篇主要介绍下Android开发中Kotlin的常用的一些基础知识

像range,var val, ${} ，if else，while等等这些十分基础东西不是本系列的宗旨，所以不再介绍，亲可以查阅其他资料，望谅解。

一：运算符重载

   //重载++运算符，程序员每次升级涨薪20%
  private fun test运算符重载() {
        var pro = Programmer()
        Log.e("fffpzf", "pro_level:${pro.level}pro_money:${pro.money}")
        pro++
        pro++
        Log.e("fffpzf", "升级后pro_level:${pro.level}，pro_money:${pro.money}")
    }

    class Programmer {
        var level = 0
        var money = 10000

        operator fun inc(): Programmer {
            level++
            money = (money * 1.2).toInt()
            return this
        }
    }
===
pro_level:0pro_money:10000
升级后pro_level:2，pro_money:14400
===

二：constructor

 //构造函数
    //test Constructor begin
    private fun testConstructor() {
        var programmer = Programeer("张", 24, 157)
    }

    class Programeer(var name: String, var age: Int) {
        constructor(name: String, age: Int, phone: Int) : this(name, age) {
            Log.e("fffpzf", "constructor....,name=${name},age=${age},phone=${phone}")
        }
    }
    //test Constructor end
===
constructor....,name=张,age=24,phone=157
===
简单写法
  fun testUser(){
        var zhansan=User("张三 ",25,1501)
        Log.e("fffpzf","zhangsan:"+  zhansan.phone)
 }

 class User(var name:String,var age:Int,var phone:Int){
        fun getAAA(){

        }
    }

三：继承、接口、抽象类

//test 继承begin
    private fun test继承() {
        //注意：Kotlin默认类final的所以不能被继承，我们需要open关键字来允许继承
        var father = Father()
        father.writeNovel()
        var son = Son()
        son.writeNovel()

    }

    open class Father {
        open var name = "张一"
        var age = 60
        //open 允许子类重载writeNovel方法，如果没有open子类无法重载
        open fun writeNovel() {
            Log.e("fffpzf", "father=${name},写历史小说...")
        }
    }

    class Son : Father() {
        override var name = "张二"
        //        age （Father中age不是open所以无法重载）
        override fun writeNovel() {
//            super.writeNovel()
            Log.e("fffpzf", "son=${name},写玄幻小说....")
        }
    }
===
father=张一,写历史小说...
son=张二,写玄幻小说....
===
    //test 继承end

    //test 接口begin
    interface Ball {
        fun footBall()
        fun basketBall()
    }

    fun test接口() {
        var zs = zhangsan()
        zs.basketBall()
        zs.footBall()
    }

    class zhangsan : Object(), Ball {
        override fun footBall() {
            Log.e("fffpzf", "张三会足球。。")
        }

        override fun basketBall() {
            Log.e("fffpzf", "张三不会篮球。。")
        }
    }
===
张三不会篮球。。
张三会足球。。
===
    //test 接口end

    //test 多态begin
    open class Water {
        open fun color() {}
    }

    class YellowRiver : Water() {
        override fun color() {
            Log.e("fffpzf", "黄河水黄色...")
        }
    }

    class QinghaiLake : Water() {
        override fun color() {
            Log.e("fffpzf", "青海湖透明...")
        }
    }


    fun test多态() {
        var yellowRiver = YellowRiver()
        yellowRiver.color()
        var qingHaiRiver: Water = QinghaiLake()
        if (qingHaiRiver is QinghaiLake) {
            var q = qingHaiRiver as QinghaiLake
            q.color()
        }
    }
    //test 多态end
===
黄河水黄色...
青海湖透明...
===

四：嵌套类、内部类

    //嵌套类是static的不能访问外部类中的字段，inner修饰的内部类可以访问外部类中的字段，如果inner类想访问外部类中的相同字段可以用this
    class Outer{
        var outer_name="张三"
        inner class Inner{
            var inner_name="李四"
            fun eat(){
                Log.e("fffpzf","外部名${outer_name},内部名:${inner_name}")
            }
        }
    }

    fun test内部类(){
        var outer=Outer()
        outer.Inner().eat()
    }
    //test嵌套类与内部类 end
===
外部名张三,内部名:李四
===

五：泛型 https://blog.csdn.net/pangzaifei/article/details/85338620转载请注明出处

//test泛型与泛型上限begin
     open class Parent<T>(var t:T){}
    class Son1:Parent<String>("张三"){}
    class Son2:Parent<Int>(0){}


    fun test泛型(){
        var son1=Son1()
        Log.e("fffpzf","son1:"+son1.t)
        var son2=Son2()
        Log.e("fffpzf","son2:"+son2.t)
    }
===
son1:张三
son2:0
===
    //泛型上限：指定T的范围是Son1及其子类
    class Son3<T:Son1>(t:T):Parent<Int>(10)
    fun test泛型上限(){
        var son1=Son1()
        var son3=Son3(son1)
        Log.e("fffpzf","son3:"+son3.t)
    }
===
son3:10
===
    //test泛型与泛型上限end

    //解决泛型擦除 begin   inline+reified
    fun test泛型擦除(){
        Log.e("fffpzf","获取T.className:"+test2("asdv"))
    }

//    fun <T> test1(t:T){
//        T::class.java.name//这地报错，因为泛型被擦除了，所以无法找到::class.java.namae
//    }
    //解决泛型擦除
    inline fun <reified T> test2(t:T): String? {
       return T::class.java.name
    }

    //解决泛型擦除 end

    //out关键字相当于java中的<? extends XXX> begin
    //同理in关键字相当于java中的<? super XXX>
    //*号同java中的<?>相同
   class TestOut{
        fun testOut1(list:ArrayList<out Father>){
        }

        fun testOut2(){
            var list=ArrayList<Father>()
            testOut1(list)
            var sonList=ArrayList<Son>()
            testOut1(sonList)//如果上面不加out这句话无法使用，因为kotlin会判断test1中的参数是Father类型的，及时子类也不行，所以需要out关键字修饰
        }
        fun testOut3(list:ArrayList<in Father>){
        }
        fun testOut4(list2:ArrayList<*>){
        }
    }
    //out关键字相当于java中的<? extends XXX>  end
===
获取T.className:java.lang.String
===

Ps:我是在飞~~，只有空闲时间才能更新博客，所以本系列偏快速入门，主要讲实战中经常用到内容，让你快速上手。所以文章尽量简短，敬请谅解，本系列文章默认阅读者已经熟悉java语言，希望我的博客对你有帮助！

《在飞Android Kotlin实战》之基础篇7

猜你喜欢