一 静态方法

java中定义静态方法只需要在方法前添加static即可；

kotlin中有四种方式：object的单例类模式、companion object（可以局部写静态方法）、JvmStatic注解模式、顶层函数模式。

1.1 object

用object修饰的类，实际上是单例类，在Kotlin中调用时是类名加方法直接使用。

object Util {

    fun doAction(){

        Log.v("TAG","doAction")

    }

}


//kotlin中调用

Util.doAction()


//java中调用 INSTANCE是Util的单例类

Util.INSTANCE.doAction();

1.2 companion object

用companion object修饰的方法也能通过类名加.直接调用，但是这时通过伴生对象实现的。它的原理是在原有类中生成一个伴生类，Kotlin会保证这个伴生类只有一个对象。

class Util{

    //此处是单例类可以调用的地方

    companion object {

        fun doAction(){

            Log.v("TAG","doAction")

        }

    }

    //此处是普通方法

    fun doAction2(){

        Log.v("TAG","doAction")

    }

}


//kotlin调用

Util.doAction()


//java调用，Companion是单例类

Util.Companion.doAction();

1.3 @JvmStatic注解

给单例类(object)和伴生对象的方法加@JvmStatic注解，这时编译器会将这些方法编译成真正的静态方法。

注意：JvmStatic只能注释在单例类或companion object中的方法上。

class Util{

    //此处是单例类可以调用的地方

    companion object {

        @JvmStatic

        fun doAction(){

            Log.v("TAG","doAction")

        }

    }


    //此处是普通方法

    fun doAction2(){

        Log.v("TAG","doAction")

    }


}


//kotlin中的调用

Util.doAction()


//java中的调用，成为了真正的单例类

Util.doAction();

1.4 顶层方法

顶层函数是指那些没有定义在任何类中的函数，写在任何类的外层即可，kotlin会将所有顶层函数编译成静态方法，可以在任何位置被直接调用。

//在类的外部

fun doAction(){

}

class Util {  

}


//kotlin调用方式

doAction()


//java调用方式,真正的静态方法

UtilKt.doAction();

二 infix函数

infix函数作用：将函数调用的语法修改了一下。

比如：A to B 等于 A.to(B)。

实现方式：在函数前面加上infix即可。

限制条件：1.不能是顶层函数；2.参数只能有一个。

例子：

infix fun String.beginsWith(p:String) = startsWith(p)

三 利用高阶函数简化常用API

apply函数简化intent.putExtra():

 fun SharedPreferences.open(block: SharedPreferences.Editor.() -> Unit) {

        val editor = edit()

        editor.block()

        editor.apply()

    }



使用：

     getSharedPreferences("user", Context.MODE_PRIVATE).open {

            putString("username", "Lucas")

            putBoolean("graduated", false)

        }

简化SharedPreferences:

 fun SharedPreferences.open(block: SharedPreferences.Editor.() -> Unit) {

        val editor = edit()

        editor.block()

        editor.apply()

    }



使用：

     getSharedPreferences("user", Context.MODE_PRIVATE).open {

            putString("username", "Lucas")

            putBoolean("graduated", false)

        }

简化ContentValues:

fun cvOf(vararg pairs: Pair<String, Any?>) =  ContentValues().apply {

        for(pair in pairs){

            val key = pair.first

            val value = pair.second

            when(value){

                is Int -> put(key, value)

                is Long -> put(key, value)

                is Short -> put(key, value)

                is Float -> put(key, value)

                is Double -> put(key, value)

                is Boolean -> put(key, value)

                is String -> put(key, value)

                is Byte -> put(key, value)

                is ByteArray -> put(key, value)

                null -> putNull(key)

            }

        }

    }

懒加载技术实现lazy():

  fun <T> later(block: () -> T) = Later(block)


    class Later<T>(val block: () -> T){

        var value: Any? = null


        operator fun getValue(any: Any?, prop: KProperty<*>): T{

            if (value == null){

                value = block

            }

            return value as T

        }

    }


使用：

    val haha:String by later {

        "hhaa"

    }

泛型实化简化startActivity()并附带intent传值:

    inline fun <reified T> startActivity(context: Context, block: Intent.() -> Unit){

        val intent = Intent(context, T::class.java)

        intent.block()

        context.startActivity(intent)

    }

使用：

  startActivity<MainActivity>(this){

        putExtra("haha","1111")

        putExtra("hahaaaa","1111")

    }

简化N个数的最大值最小值：

   fun <T : Comparator<T>> MyMax(vararg nums: T): T{

        if (nums.isEmpty()) throw RuntimeException("params can not be empty")

        var maxNum = nums[0]

        for (num in nums){

            if (num > maxNum){

                maxNum = num

            }

        }

        return maxNum

    } 


使用：

       val a = 1

        val b = 3

        val c = 2

        val largest = MyMax(a,b,c)

简化Toast：

    fun String.showToast(context: Context, duration: Int = Toast.LENGTH_SHORT){

        Toast.makeText(context, this, duration).show()

    }

    fun Int.showToast(context: Context, duration: Int = Toast.LENGTH_SHORT){

        Toast.makeText(context, this, duration).show()

    }


用法：

        "ahah".showToast(this, Toast.LENGTH_LONG)

简化Snackbar:

fun View.showSnackbar(text: String, actionText: String?=null, duration: Int = Snackbar.LENGTH_SHORT, block: (() -> Unit)? =null){

        val snackbar = Snackbar.make(this, text, duration)

        if (actionText != null && block != null){

            snackbar.setAction(actionText){

                block()

            }

        }

        snackbar.show()

    }


    fun View.showSnackbar(text: String, actionResId: Int?=null, duration: Int = Snackbar.LENGTH_SHORT, block: (() -> Unit)? =null){

        val snackbar = Snackbar.make(this, text, duration)

        if (actionResId != null && block != null){

            snackbar.setAction(actionResId){

                block()

            }

        }

        snackbar.show()

    }