Kotlin函数

函数声明，函数用法

函数声明

Kotlin 中的函数使用 fun 关键字声明

fun bandLayout():Int{
}
fun test (str:String):String{
}
//参数默认值
fun test (str:String = "good"):String{
}
//继承方法时，子类不可有默认值
open class A {
    open fun foo(i: Int = 10) { /*……*/ }
}

class B : A() {
    override fun foo(i: Int) { /*……*/ }  // 不能有默认值
}

函数用法

setContentView(bandLayout())

可变数量的参数

fun <T> asList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    for (t in ts) // ts is an Array
        result.add(t)
    return result
}

函数作用域

在 Kotlin 中函数可以在文件顶层声明，这意味着你不需要像一些语言如 Java、C# 或 Scala 那样需要创建一个类来保存一个函数。此外除了顶层函数，Kotlin 中函数也可以声明在局部作用域、作为成员函数以及扩展函数

局部函数

//Kotlin 支持局部函数，即一个函数在另一个函数内部
fun dfs(graph: Graph) {
    fun dfs(current: Vertex, visited: MutableSet<Vertex>) {
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v, visited)
    }

    dfs(graph.vertices[0], HashSet())
}

泛型函数

fun <T> singletonList(item: T): List<T> { /*……*/ }

扩展函数

日期时间函数

日期时间格式符
小写的yyyy 表示4位年份数字,如 1949，2017等
大写的MM 表示2位月份数字,如 01 表示一月份，12表示12月份
小写的dd 表示2位数具体日期,如 08 表示当月8号，126表示当月26号
大写的HH 表示224小时制的两位小时数字，如19表示晚上7点
小写的hh 表示12小时制的两位小时数字，如06可同时表示早上6点和晚上6点(为避免歧义，12小时制在开发过程中比较少使用)
小写的mm 表示时间的两位数分钟数，如30表示30分钟
小写的ss 表示时间的两位数秒数，如10表示10秒
大写的SSS 表示时间的三位毫秒数字

val date1 = Date(); // 当前时间
val millisencond = date1.time // 时间戳，毫秒
val date2 = Date(millisencond) // 使用时间戳（毫秒）构建时间

// Date 格式化输出
val s1 = date1.toString() // Tue Jun 30 11:01:03 CST 2020
val f1 = SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS")
val s2 = f1.format(date1) // 2020-06-30 11:00:26.401

新特性建议使用LocalDateTime，LocalDate，LocalTime

val d = LocalDate.now() // 当前日期
val t = LocalTime.now() // 当前时间
val dt = LocalDateTime.now() // 当前日期和时间
val dtUtc = LocalDateTime.now(ZoneOffset.UTC) // UTC时间：2020-06-30T03:32:41.313

Instant时间戳

val timestamp = Instant.now()
println("时间戳(秒)： ${timestamp.epochSecond}")  // 时间戳，秒
println("时间戳(毫秒)： ${timestamp.toEpochMilli()}")  // 时间戳，毫秒
println("时间戳(毫秒)： ${System.currentTimeMillis()}")  // 使用 System 获取时间戳，毫秒

Kotlin下的5种单例模式

饿汉式
懒汉式
线程安全的懒汉式
双重校验锁式
静态内部类式

饿汉式实现

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance=new SingletonDemo();
    private SingletonDemo(){

    }
    public static SingletonDemo getInstance(){
        return instance;
    }
}
//Kotlin实现
object SingletonDemo

懒汉式

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){}
    public static SingletonDemo getInstance(){
        if(instance==null){
            instance=new SingletonDemo();
        }
        return instance;
    }
}
//Kotlin实现
class SingletonDemo private constructor() {
    companion object {
        private var instance: SingletonDemo? = null
            get() {
                if (field == null) {
                    field = SingletonDemo()
                }
                return field
            }
        fun get(): SingletonDemo{
        //细心的小伙伴肯定发现了，这里不用getInstance作为为方法名，是因为在伴生对象声明时，内部已有getInstance方法，所以只能取其他名字
         return instance!!
        }
    }
}

线程安全的懒汉式

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){}
    public static synchronized SingletonDemo getInstance(){//使用同步锁
        if(instance==null){
            instance=new SingletonDemo();
        }
        return instance;
    }
}
//Kotlin实现
class SingletonDemo private constructor() {
    companion object {
        private var instance: SingletonDemo? = null
            get() {
                if (field == null) {
                    field = SingletonDemo()
                }
                return field
            }
        @Synchronized
        fun get(): SingletonDemo{
            return instance!!
        }
    }

}

双重校验锁式

//Java实现
public class SingletonDemo {
    private volatile static SingletonDemo instance;
    private SingletonDemo(){} 
    public static SingletonDemo getInstance(){
        if(instance==null){
            synchronized (SingletonDemo.class){
                if(instance==null){
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }
}
//kotlin实现 延迟属性 Lazy
class SingletonDemo private constructor() {
    companion object {
        val instance: SingletonDemo by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
        SingletonDemo() }
    }
}

?:操作符，如果 ?: 左侧表达式非空，就返回其左侧表达式，否则返回右侧表达式