Kt学习笔记（四）类成员

kt类中成员：属性、函数、嵌套类

一、属性的基本用法

语法:

    var/val <propertyName> [:<propertyType>] [=<property_initializer>]
        [<getter>]
        [<setter>]

  在属性语法中，只有var/val和propertyName（属性名） 是必需的，其他都是可选的，kt属性最简单的形式就是在类中定义一个变量或者一个常量，如果要引入属性，就像引用变量一样

class CustomerTest
{
    var name : String  = "Bill"
    val age : Int  = 20
    var flag : Boolean = true

    fun description(){
        println("name: ${name} age:${age} flag:${flag}")
    }

}

二、属性的getter和setter形式

•  由于kt在语法上支持属性，因此并不需要为每个属性单独定义getter和setter方法，不过仍然需要在属性中使用getter和setter形式.

•  如果属性是只读的， 需要将属性声明为val，并只添加一个getter形式

•  如果属性是读写的， 需要用var声明属性， 并添加getter和setter形式，如果getter和setter只有一行代码， 直接用等号(=)分隔getter和代码即可

•  如果包含多行代码，需要使用{…}处理

class GetAndSetTest
{
    //只读属性
    val name : String
    get() = "Bill"

    var v : Int = 20
    //读写属性
    var value : Int
    get() =  v
    set(value)
    {
        println("value 属性被设置")
        v = value
    }
}

三、保存属性值的字段

• filed标识符，在属性的getter和setter中，可以将filed当作成员变量使用， 通过filed读写属性值

class Customer3
{
    val name : String
    get() = "Bill"

    var value : Int = 0
    get() = field   //从field中读取属性值
    set(value)
    {
        println("value 属性被设置")
        field = value  //将属性值写入field中
    }
}

四、函数

• 在Kt中， 函数可以定义在类外部定义，为全局函数；也可以在类内部定义，是类成员函数
• 函数支持默认参数值
• 带默认值的参数必须是最后几个参数，也就是说：如果某个参数带默认值，那么该参数后面的所有参数必须都有默认值

4.1 普通函数写法

class testFunction
{
    //schema 参数有默认值
    fun printTestFun(url : String ,schema : String = "https")
    {
        println("${schema} : // ${url}")
    }
}


class testPerson
{
    fun process(value:Int,name:String = "Tom",age : Int = 30,salary:Float = 4000F)
    {
        println("valus:${value} ,name:${name} ,age:${age} ,salarry:${salary}")
    }
}

  Kt允许使用命名参数传递参数值，所谓命名参数， 就是在调用函数时指定函数的形参名，这样可以直接为指定的参数传值

 testPerson().process(30,"Jerry",20,12000F)
    testPerson().process(30,salary = 15000F)

4.2 可变参数

class animal(name: String)
{

    private var mName : String  = name

    fun getName():String
    {
        return mName
    }
    /**
     * Kt的单行表达式
     * 函数体只有一行代码，可以直接在函数声明后面加等号(=)后面直接跟上代码，这种表达方式可以省略函数返回值类型
     */
    fun getName1() : String  = mName
    fun getName2() = mName
}

class animals
{
    //animals为可变参数  可传入任意多个 animal对象
    fun addAnimanls(vararg animanls: animal) : List<animal>
    {
        val  result = ArrayList<animal>()
        for (animanl in animanls)
            result.add(animanl)
        return result
    }
}

运行结果：

 var animals = animals().addAnimanls(animal("Dog"),animal("Cat"))
    for (animal in  animals)
    {
        println(animal.getName())
    }

4.3 本地函数

class animals
{
    //animals为可变参数  可传入任意多个 animal对象
    fun addAnimanls(vararg animanls: animal) : List<animal>
    {
        val  result = ArrayList<animal>()
        for (animanl in animanls)
            result.add(animanl)
        return result
    }

    fun addAnimal(name : String)
    {
        //process 函数的作用域就是addAnimal函数体
        fun process(age : Int)
        {
            println("age:${age}")
        }
        process(40)
        println("name:${name} : age:${process(50)}")
    }
}

4.4 嵌套类

嵌套类： 在类中定义的类

 */
class Outer
{
    private val bar : Int = 1

    //嵌套类
    class Nested
    {
        fun foo() = 2
    }
}

var  demo1 = Outer.Nested().foo()

  嵌套类还可以使用inner关键字声明 这样可以通过外部类（包含嵌套类的类）实例来使用嵌套类

class Outer
{
    private val bar : Int = 1

    //嵌套类
    class Nested
    {
        fun foo() = 2
    }

    //嵌套类还可以使用inner关键字声明  这样可以通过外部类（包含嵌套类的类）实例来使用嵌套类
    inner class Inner
    {
        fun foo() = bar
    }
}
var  demo1 = Outer.Nested().foo()

val demo2 = Outer().Inner().foo()