Kotlin编程之方法

Kotlin编程相关知识点介绍：

• Kotlin编程之使用Intellij IED和了解源文件（.kt）
• Kotlin编程之类的介绍和使用
• Kotlin编程之类的属性

---

本篇目录：

• 构造方法
• 非静态方法
• 静态方法
• 抽象方法和方法的实现

构造方法

---

用 constructor标记，在类中介绍这篇中已经详细介绍，这里省略。

非静态方法

---

用fun 标记方法。

package com.xingen.kotlin.day2017526

fun main(args: Array<String>) {
    var  instance= Test()
    println(instance.test1())
    println(instance.test2("有参数有返回值得方法"))
    println(instance.test3())
    instance.test4()
    println(instance.test5())
    println(instance.test6())
    println(instance.test7("可变参数1"))
    println(instance.test7("可变参数1","可变参数2"))
    println(instance.test8(2017526))
}
class  Test{

    /***
     *  方法的形式：
     *   fun 方法名 ( 参数名：参数类型 = 默认值 ,...) ：返回值类型{
     *        return 返回值
     *   }
     */
    fun test1() :String {
        return "无参数有返回值的方法"
    }
    fun test2(str:String) :String {
        return str
    }
    fun test3(str:String="方法参数的默认值"):String{
        return str
    }
    /**
     *  Unit修饰无返回值的方法。Unit也可以省略不写。
     */
    fun test4():Unit{
        println("无返回值的方法")
    }

    /**
     * 单表达式函数 ：
     *
     *  函数中只有单个表达式，可以省略大括号
     */
    fun  test5 ():String ="单个表达式的函数，大括号可以省略"
    fun  test6 ()="当能推断出返回值类型时候，返回值类型可以省略"

    /**
     * vararg标记可变长参数
     */
    fun <T> test7(vararg  ts:T):List<T>{
        val result=ArrayList<T>()
        for (t in ts){
            result.add(t)
        }
        return  result
    }
    /**
     *  方法包含方法
     */
    fun  test8(index :Int):Boolean{
        val  changIndex=index+1
        //定义一个内部方法
        fun test9(innerIndex:Int) :Boolean{
            return  innerIndex+1==changIndex
        }
        //获取内部定义的方法的返回值
       var  result=test9(index)

        return result
    }

}

输出结果：

无参数有返回值的方法
有参数有返回值得方法
方法参数的默认值
无返回值的方法
单个表达式的函数，大括号可以省略
当能推断出返回值类型时候，返回值类型可以省略
[可变参数1]
[可变参数1, 可变参数2]
true

和Java语言类似，在Kotlin编程中方法分为有参数有返回值，无参数有返回值，有参数无返回值，无参数无返回值这四种类型。

注意点：

• 无返回值，在java中方法用void,而在Kotlin中Unit表示，同事Unit还可以省略不写。

• 在Kotlin编程中，方法中参数可以设置默认值。

• 单函数表达式：当函数中只有单个表达式，大括号可以省略;当可以推断出返回值类型，返回值类型可以省略;

• 可变参数的函数：vararg 修饰的参数是可变参数

• 局部函数：在java语言中，方法不能定义在方法中。而在Kotlin编程，方法中可以包含方法。

静态方法：

---

Kotlin中没有Java中的静态方法。但是有三种实现的方式：

1. 使用包级别的函数，即源文件中包含函数:

fun main(args: Array<String>){
         Test().test()//对象调用方法
}
class  Test{
   fun test(){
        run()//静态方式调用包级别的方法
   }
}
 //包级别的方法
fun run(){
        println("Kotlin编程，包级别的方法静态调用")  
}

输入：

Kotlin编程，包级别的方法静态调用

顶层的函数，转成java 代码后会是一个顶层类中静态方法。

2. 在一个类中写一个声明对象作为成员:

package com.xingen.kotlin.day2017529
fun main(args: Array<String>) {

    TestListener.test()//类名.方法（）调用
}
/**
 * object关键字声明一个单例的对象
 *
 *  对象声明与对象表达式区别：
 *
 *    对象声明和变量声明一样，不能作为右值赋给等号左边。
 *
 *  调用方式：
 *    1. 类名.属性名
 *    2. 类名.方法（）
 */
object  TestListener:Test1Interface {
    override fun test() {
      println("object声明类对象")
    }
}

输出结果：

object声明类对象

在kotlin中object 表示单例类，转换出来也是对应着单例类中方法。

3. 最有效的方式：在类中声明一个伴生对象:

package my.test

fun main(args: Array<String>){
         Test.run()//静态方式调用
}
class  Test{
  //companion修饰的伴生对象，伴生对象名可以省略。  
  companion object{
  
    fun run(){
        println("Kotlin编程，伴生对象的方法静态调用")
    }
  }
}

输出结果：

Kotlin编程，伴生对象的方法静态调用

查看下转换后，伴生类中方法等于静态内部类中方法，该静态内部类Companion会有单例对象。

抽象方法和方法的实现

---

实现接口和抽象类中的方法，必需使用override修饰。在抽象类或者接口讲解，再详细介绍。