Kotlin笔记（四）

接口

fun main() {
    val im = IM(2)
    println(im.back())
}

//kotlin接口可以定义属性，不过很少使用
interface IFCallBack {
    val a:Int
    var b:Int
    fun back() : String
}

//实现里面属性和方法都需要加override关键字
//接口是var，实现不能是val，反之是可以的
class IM(override val a: Int) : IFCallBack {

    override var b:Int = 4

    override fun back(): String {
        return (a + b).toString()
    }
}

抽象类

fun main() {
    val main = MainActivity()
    main.initView()
}

class MainActivity : BasActivity(name = "main"){
    override fun onCreate() {
    }
    public override fun initView() {
        super.initView()
    }
}

//抽象类规则与java一致。单继承多实现
abstract class BasActivity (name:String) {
    //抽象方法
    abstract fun onCreate()

    //子类可以覆盖重写的方法需要加open
    protected open fun initView() {
    }
}

泛型类

fun main() {
    val arr = Arr("abc")
    arr.pri(12)
    val arr2 = Arr("dfd")
    arr2.pri(false)
}
//泛型类和java写法一样
class Arr<T : String>(item:T) {
    private var sub = item

    fun <R> pri(r:R) : T {
        println("$sub $r")
        return sub
    }
}

vararg可变长参数

fun main() {
    add(1, 2, 3)
}
//vararg表示可变长参数，相当于java的...
fun add(vararg item:Int) {
    item.forEach {
        println(it)
    }
}

out协变，in逆变

//out协变关键字表示泛型只能作为方法返回值
interface Production<out T> {
    fun product() : T
}
//in逆变关键字表示泛型只能作为方法入参
interface Consumer<in T> {
    fun consumer(item:T)
}
//无关键字泛型既能为方法入参也能为方法返回值
interface ProductionConsumer<T> {
    fun productConsumer(item:T) : T
}

//食物类
open class Food
//快餐食物类
open class FastFood : Food()
//汉堡类
class Burger : FastFood()

//食物商店
class FoodStore : Production<Food> {
    override fun product(): Food {
        println("create Food")
        return Food()
    }
}
//快餐食物商店
class FastFoodStore : Production<FastFood> {
    override fun product(): FastFood {
        println("create FastFood")
        return FastFood()
    }
}
//汉堡商店
class BurgerStore : Production<Burger> {
    override fun product(): Burger {
        println("create Burger")
        return Burger()
    }
}
//食物消费者
class EveryBody : Consumer<Food> {
    override fun consumer(item: Food) {
        println("eat Food")
    }
}
//快餐消费者
class FastPeople : Consumer<FastFood> {
    override fun consumer(item: FastFood) {
        println("eat FastFood")
    }
}
//汉堡消费者
class BurgerPeople : Consumer<Burger> {
    override fun consumer(item: Burger) {
        println("eat Burger")
    }
}

fun main() {
    val food1:Production<Food> = FoodStore()
    food1.product()//create Food
    //使用out关键字的泛型，子类泛型对象可以赋值给父类泛型对象
    val food2:Production<Food> = FastFoodStore()
    food2.product()//create FastFood
    val food3:Production<Food> = BurgerStore()
    food3.product()//create Burger

    //使用in关键字的泛型，父类泛型对象可以赋值给子类泛型对象
    val people1:Consumer<Burger> = EveryBody()
    people1.consumer(Burger())//eat Food
    val people2:Consumer<Burger> = FastPeople()
    people2.consumer(Burger())//eat FastFood
    val people3:Consumer<Burger> = BurgerPeople()
    people3.consumer(Burger())//eat Burger
}

reified关键字

open class Young {
    open val name:String? = null
}
class Boy(override val name: String) : Young()
class Girl(override val name:String) : Young()

//通过reified配合inline内联保存泛型对象类型使用
//内联使用inline关键字使得代码编译时期将执行语句替换到相应位置，少创建对象，优化内存
//下面方法编译后将不存在，语句直接合并至main方法中
inline fun<reified T> getT(item:Young, createT:()->T) : T {
    //传入一个对象，若是T直接返回，否则重新创建一个T对象返回
    return if (item is T) {
        item
    } else{
        createT()
    }
}

fun main() {
    val boy1 = getT(Girl("Girl1")) {
        Boy("Boy1")
    }
    println(boy1.name)
    val boy2 = getT(Boy("Boy2")) {
        Boy("Boy3")
    }
    println(boy2.name)
}

扩展函数

fun main() {
    println("abc".addPlus())
    println("abc".addMoreOne(3))
    12.pri()
    "aaa".pri()
    "sss".anyPri().addPlus().anyPri()
    val strNull:String? = null
    strNull.priNotNull("is Null")
    "The People's Republic of China".numVowels.anyPri()
}
//扩展函数，给任意一个类添加自定义函数，后续该类对象可以直接使用
//扩展函数原理是编译阶段生成一个方法，将前置对象以入参形式传入方法中
//String后面加上plus字符串，单行语句可简写为fun String.addPlus() = this + "plus"
fun String.addPlus() : String {
    return this + "plus"
}
//字符串后面添加num个1
fun String.addMoreOne(num:Int) = this + "1".repeat(num)
//Any父类设置一种打印方法
private fun Any.pri() : Any {
    println(this)
    return this
}
//字符串子类覆盖Any类的方法
private fun String.pri() : String {
    println("字符串$this")
    return this
}
//泛型扩展函数，灵活度更高，apply，let等标准函数的源码都是这个写出来的
private fun <T> T.anyPri() : T {
    println(this)
    return this
}
//可空类型的扩展函数
private fun String?.priNotNull(default:String) = println(this ?: default)
//扩展属性
//定义String的属性表示元音字母的数量
private val String.numVowels
    get() = count {"aeiou".contains(it)}

infix关键字

fun main() {
    val ic = InfixClass()
    ic add 5
    ic pri "abc"
}

//infix关键字使用在有单个参数的类函数与扩展函数中，调用时可省略点和括号
class InfixClass {
    private val num = 20
    infix fun add(other:Int) = println(num + other)
}
infix fun<T> InfixClass.pri(t:T) = println(t)

Kotlin导包别名

package com.kevin.kotlin_test.ext

//定义取集合中的随机元素方法
fun <T> Iterable<T>.randomItem() : T = this.shuffled().first()

package com.kevin.kotlin_test

//导包使用，通过as关键字能取别名使用
import com.kevin.kotlin_test.ext.randomItem as rand

fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    println(list.rand())
}

泛型匿名扩展函数

fun main() {
    val rm = Rm().rm {
        a = "is A"
        b = "is B"
    }
    println(rm.toString())
}
//泛型匿名扩展函数，很多标准函数的原理
//入参是泛型匿名扩展函数的好处是能将对象本身以this隐式传入方法体中（带接收者的函数字面量）
private fun <T> T.rm(block: T.() -> Unit) : T {
    block()
    return this
}
class Rm {
    var a:String? = null
    var b:String? = null
    override fun toString(): String {
        return "a=$a b=$b"
    }
}

DSL-变换函数

//函数式编程范式（DSL）：主要依赖于高阶函数（以函数为入参或出参）返回的数据
//Kotlin支持面向对象编程范式和函数式编程范式混用
//函数式编程主要由三类函数构成：变换transform，过滤filter，合并combine。
//每类函数都是针对集合数据类型设计，目标是产生一个最终结果，可以通过链式构建多个简单函数解决复杂的计算
//函数式编程的设计理念是不可变数据的副本在链上函数间传递
fun main() {
    //变换函数会遍历集合内容，用一个以值参形式传入变换器函数，变换每一个元素，然后返回已修改的元素的集合给链上其他函数使用
    //map函数返回的集合中元素个数与原函数必须一样，但元素类型可以不一样
    val list = listOf(1, 2, 3, 4, 5)
    val list2 = list.map {
        it + 2
    }.map {
        it - 3
    }.map {
        "num = $it"
    }
    println(list)
    println(list2)
    println(list2[0]::class.simpleName)
    //flatMap函数将操作多个集合之后进行合并返回合并后的集合
    val flatList = listOf(listOf(1, 2, 3), listOf("4", 5, 6)).flatMap {
        it - 2
    }
    println(flatList)
    flatList.forEach {
        println(it::class.simpleName)
    }
    //对象数据操作，返回元素的引用地址不变
    val dataList = listOf(DslData("DOG"), DslData("Cat"))
    val afterDataList = dataList.map {
        it.name = it.name + "S"
        it
    }
    println(dataList)
    println(afterDataList)
}

class DslData(var name:String)

DSL-过滤函数

fun main() {
    //过滤函数 filter函数遍历集合，把使方法体中返回true的元素加入新集合
    val listFilter = listOf(1, 2, 3, 4, 5, 6).filter {
        it >= 4
    }
    println(listFilter)
}

DSL-合并函数

fun main() {
    val list1 = listOf("A", "B", "C")
    val list2 = listOf(1, 2, 3)
    //合并函数zip能将两个list合并成Pair元素集合，通过toMap方法可转成Map使用
    //合并的两个函数size不同的话生成的集合不会包含超出部分元素
    val zip = list1.zip(list2).toMap()
    println(zip)
    //fold函数表示对一个集合遍历处理，每次循环记录上次的处理结果提供给下一次循环
    //例如下面例子，对1,2,3,4四个数字分别进行平方后相加
    //fold函数入参表示记录的默认值，acc表示上次记录值，i表示当前循环中的元素
    val result = listOf(1, 2, 3, 4).fold(0) { acc, i ->
        acc + i*i
    }
    println(result)
}

DSL的算法示例

fun main() {
    //将二维list集合中带red的元素重新加入到一个新集合中
    val list = listOf(listOf("red apple", "green apple", "blue apple")
            , listOf("red fish", "blue fish")
            , listOf("yellow banana", "green banana"))
    val result = list.flatMap { it -> it.filter { it.contains("red") } }
    println(result)

    //求100以内的质数集合
    //until表示从一个数到最后一个数前一位循环遍历，..是包含最后一位数
    val result100 = (2..100).toList().filter { item ->
        //none表示没有一个符合的返回true
        //每个元素对2到它前一位遍历取模，若取出的结果数组中没有一个为0则代表此数为质数
        (2 until item).map { num -> item % num }.none { it == 0 }
    }
    println(result100)

    //取1到100以内前10个质数，take函数取集合前几位的元素
    println((2..100).toList().filter { it.isZhiShu() }.take(10))
    //generateSequence方法生成Sequence集合
    //在未知集合的size，定义集合的初始元素与下一个元素的生成规则，通过take生成满足条件的Sequence集合
    //不使用take直接使用toList会导致线程挂起
    println(generateSequence(2) { it + 1 }.filter { it.isZhiShu() }.take(10).toList())
}

fun Int.isZhiShu() :Boolean {
    (2 until this).map {
        if (this % it == 0) {
            return false
        }
    }
    return true
}

java与kotlin互相调用

package com.kevin.kotlin_test.ext;

import com.kevin.kotlin_test.JavaData;
import com.kevin.kotlin_test.Kotlin;

import java.io.IOException;

import kotlin.jvm.functions.Function1;

public class Test {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String kotlinClass() {
        System.out.println(Kotlin.javaFun());
        System.out.println(new JavaData().name);
        System.out.println(JavaData.MAX_NUM);
        JavaData.companionFun();
        try {
            Kotlin.javaException();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //java提供0个入参到22个入参的方法类型从Function0到Function22
        Function1<String, String> funData = Kotlin.getFunData();
        System.out.println(funData.invoke("KEVIN"));
        return null;
    }
}

//java调用全局函数变量可以使用的类名重命名
@file:JvmName("Kotlin")
package com.kevin.kotlin_test

import com.kevin.kotlin_test.ext.Test
import java.io.IOException

fun main() {
    val test = Test()
    //java中带有get和set前缀的public方法可直接简化使用
    test.name = "kevin"
    test.age = 22
    println(test.name)
    println(test.age)

    //调用java方法要注意使用空安全符
    test.kotlinClass()?.toString()
}

//java可以使用重载函数调用
@JvmOverloads
fun javaFun(a:String="a", b:String="b") = "aaa"

//java中可以捕获指定异常
@Throws(IOException::class)
fun javaException(){
    throw IOException()
}

class JavaData {
    //java可以直接使用kotlin的set和get方式调用
    @JvmField
    val name:String = "java"

    companion object {
        const val MAX_NUM = 10
        //java中直接通过类名调用伴生对象函数
        @JvmStatic
        fun companionFun() = println("companionFun")
    }
}

//java中调用函数属性
val funData = { it:String ->
    it.toLowerCase().capitalize()
}