//顶层声明的Int数组求和函数
public fun getSum(args:Array<Int>):Int{
    var sum=0
    for (i in args){
        sum+=i
    }
    return sum
} //public可省略,不同的文件内可访问

private fun sub_arr(args1: Array<Int>, args2: Array<Int>): Array<Int> {
// private修饰的顶层函数，只能在本文件内访问
// 该函数实现了数组对应元素相减，一般要求两数组，若不等长，则长-短
    var res: Array<Int>
    if (args1.size>args2.size){
        res=args1
        for (i in args2.indices){
            res[i]=args1[i]-args2[i]
        }
    }else{
        res=args2
        for (i in args1.indices){
            res[i]=args2[i]-args1[i]
        }
    }
    return res
}

internal fun no_return(args:Int=5){
//无返回值且有默认参数
    println(args)
}

fun main(args:Array<String>){
// 顶层声明的main函数，可见性修饰词默认为public，返回值为Unit类型
// 参数为String数组，参数名为args
    var arr1= arrayOf(1,3,5,7,9)
    var arr2= arrayOf(2,4,6,8)
    val sum=getSum(arr1)
    println(sum)// 25
    for (i in sub_arr(arr2,arr1)){
        print("$i ")// -1 -1 -1 -1 9
    }
    println()
    no_return() //5 
    no_return(8) //8
}

可见性修饰符?链接

public

? ? public 修饰符是Kotlin中默认的修饰符，可省略不写，在顶层、类、局部中均可以使用，可见性最大，一般是在父区域下的所有子区域均可见

internal

? ? ?internal是Kotlin特有的，是模块内可见，可以在顶层，类中使用

? ? ?Kotlin的模块是指一套编译在一起的Kotlin源文件：可以是一个IntelliJ IDEA模块;一个Maven项目;一个Gradle源集合;一组调用Ant任务编译的文件

protected

? ?protected修饰符和之前语言中遇到的类似，只能在类中使用，一般是在本类及继承类可访问

private

? ? ?private修饰符也和之前语言中的一致，可以在顶层、类内使用，一般是在本类内或者本文件内可访问

总结

顶层处只能使用除protected外的3个修饰符

类内4个修饰符均可以使用

块内局部声明只能用public修饰变量

// learn.kt
package kotlin_learn

private fun f() {  } // 在 learn.kt 内可见

public var a: Int = 5 // 变量a在其他文件内也可见（可以通过导入包使其可访问）
private var b:Int = 0   // 变量b只在learn.kt 内可见
    
internal val c= 6    // 变量c在相同模块内可见

open class A{
    private val a = 1 //在当前类内可见
    protected open val b = 2 //在当前类及其继承类内可见
    internal val c = 3 //在当前类及相同模块类内可见
    val d = 4  // 默认 public ，随类A的可见性
    
    protected class Nested { //内部类且为protected
        public val e: Int = 5 //属性e访问权限随Nested类可见性
    }
}

class Subclass : A() { //继承A
    // a 不可见
    // b、c、d 可见
    // Nested 和 e 可见

    override val b = 5  // 重写了b
}

class B(o:A) {  //并非继承的关系，主构造器，B只能访问A的public和interna属性、方法
    // o.a、o.b 不可见
    // o.c 和 o.d 可见（相同模块）
    // A.Nested 不可见，Nested::e 也不可见
}

函数的返回值

? Kotlin中函数的返回值类型粗略可分两种 Unit和有返回值类型

? 一般函数若无返回值，则函数声明可不写返回值和return语句（return语句若写，可直接写return）

? 当函数有具体的返回值时，则需要在声明处写明返回值的类型，写法是"：返回值类型"

且当返回值为可空类型时，返回值类型处也须写可空类型
fun printArr(array: Array<Int?>){
    for (i in array){
        print("$i ")
    }
    println()
    return //return可省略
}
fun getSum(array: Array<Int?>):Int?{
    var a=0
    var sign=true
    for (i in array){
        if (i!=null){
            a+=i
            sign=false
        }
    }
    return if (sign) null else a //三元表达式
}
fun main(args:Array<String>){
    var arr:Array<Int?> = arrayOf(1,3,5,7,9)
    printArr(arr) // 1 3 5 7 9
    println(getSum(arr))// 25
    arr= arrayOf(null)
    printArr(arr)// null
    println(getSum(arr)) // null
}

函数的参数

? ?函数声明时，一般参数的声明是以 参变量名: 参变量类型 的格式

声明时的默认参数

? ?默认参数的含义不再赘述，这里主要讲默认参数的使用

? ?使用一般仍需遵循从右往左设置以方便位置传参的逻辑

? ?使用格式：参变量名: 参变量类型 = 值
internal fun no_return(args:Int=5){
//无返回值且有默认参数
    println(args)
}

使用时的关键字传参

? ?关键字传参，即在调用函数时，函数的() 内，须以 参变量名 = 值或变量 的形式传递参数

? ?使用这种传参方式，则不须遵从默认参数从右往左的设置顺序
fun add_arr(addition:Int=1,array: Array<Int?>):Array<Int?>{

    for (i in array.indices){
        array[i] = array[i]?.plus(addition)
    }
    return array
}
fun printArr(array: Array<Int?>){
    for (i in array){
        print("$i ")
    }
    println()
    return //return可省略
}
fun main(args:Array<String>){
    var arr:Array<Int?> = arrayOf(1,3,5,7,9)
    add_arr(array = arr)
    printArr(arr)
    add_arr(-2,arr)
    printArr(arr)
}

可变参数

? 当函数中需要用的某参变量的长度不固定时，则可以使用可变修饰符 vararg 修饰，被 vararg修饰的参变量相当于一个数组，数组的长度由传参确定

? 声明格式：可见性修饰符 fun 函数名 (参数名:类型, vararg 参数名: 类型)

? 一般来说，函数参数声明最后放可变参数，以便更好地符合位置传参的逻辑，但当使用关键字传参时，可变参数的声明位置可任意
fun myPrint(vararg args:Int){
    for (i in args){
        print("$i ")
    }
    println()
}

fun main(args:Array<String>){
    myPrint(1,2,3,4,5)
    myPrint(args = IntArray(3) { index -> (index * 3) }) 
    //lambda 函数的使用，这种数组声明在之前的Kotlin数据类型博客中介绍过
}