Kotlin基础--静态方法、静态变量和常量

在Java中我们通常会使用静态变量和静态方法作为工具类。

public class StaticUtils {

    public static String staticProperty;

    public static String getStaticProperty(){
        return staticProperty;
    }

}

那如何在Kotlin中类名直接调用类的方法和变量呢？先来看看 object 关键字的作用。

object

object 和 class 一样是关键字，o必须是小写的。这个和Java的Object不一样。Any在Kotlin中与Java的Object是一样的作用，都是所有类的基类。
object 在 Kotlin 中可以实现类名直接调用变量和方法。作用类似于 Java 的 static 关键字。但是不一样的是，object 是放在类名之前。

object KotlinStaticUtils {
    val name: String = "name"
    fun setAge(){
        println("setAge")
    }

}
//在调用的地方直接通过类名进行调用
 val name = KotlinStaticUtils.name

 KotlinStaticUtils.setAge()

在 Kotlin 中object KotlinStaticUtils 同时是一个线程安全的单例类。

继承以及实现

object 的类同时可以实现对其他类的继承和接口的实现。

open class BaseUtils {

    open fun baseMethod(){
        println("baseMethod")
    }

}
interface BaseInterfaceUtils {
    fun baseInterfaceMethod()
}
object KotlinStaticUtils : BaseUtils() , BaseInterfaceUtils{

    override fun baseMethod() {
        super.baseMethod()
        println("baseMethod children")
    }

    override fun baseInterfaceMethod() {
        println("baseInterfaceMethod")
    }

}

但是 object 修饰的类则不能被其他类继承

匿名类

匿名类的写法：

       val baseAbstract = object : BaseAbstract(){
            override fun baseAbstract() {
                printBaseMsg()
            }
        }

        val baseIntercae = object : BaseIntercae{
            override fun onClick(v: View) {
                println("onClick")
            }
        }

部分函数以及变量实现静态

object 类中的所有的变量和函数都是静态的，想要达到局部函数和变量是静态的可以这么写：

class Constants {
    
    object A {
        var tag = "Constants"
    }
    
}

A 就是 Constants 类的嵌套类，并且类是可以有多个嵌套类的。在调用的时候可以直接通过类名调用 A 中的函数和变量。

Constants.A.tag

可以通过如下的写法，省略调用时候的 A

class Constants {

    companion object {
        var methodName = "伴生类"
    }
}

companion 所修饰的 object 类叫做伴生类，每个类中只能有一个伴生类。Constants.methodName 可以直接通过类名调用。

top-level property or function

顶级函数、顶级变量（自我为了方便记忆的叫法）。

top-level 是属于 package 的，而不是 class 的，跟静态变量一样，是可以作用全局。

package com.example.kotlindemo.toplevel

/**
 * @author qinhaihang
 * @time   2019/11/26 23:42
 * @des
 *
 * @packgename com.example.kotlindemo.toplevel
 *
 */
var COUNT: Int = 0

fun addOne(data: Int): Int {
    return data + 1
}

之后可以直接在其他地方调用

for (i in 1 until 10){
        val data = addOne(2)
        Log.d("qq","data = $data")
}

obejct 和 top-level 的区别

1. top-level 更适合工具类
2. 如果需要有实现和继承，object 和 companion 则更合适

常量

Kotlin中的常量是完全不可以修改的，只能是基础类型以及String。常用的三种写法如下：

//在top-level中声明
package com.example.kotlindemo.staticdemo

/**
 * @author qinhaihang
 * @time   2019/11/27 22:55
 * @des
 *
 * @packgename com.example.kotlindemo.staticdemo
 *
 */
const val NUMBER_3 = 3

//在class中的伴生类声明
class Constants2 {

    companion object{
        const val NUMBER_1 = 1
    }

}

//在object类中声明
object Constants {

    const val NUMBER_1: Int = 0

}

以上就是一些常用的总结。还是参考了 抛物线的文章以及官网的文章