kotlin语法（中）

一.类与对象

Kotlin 类可以包含：构造函数和初始化代码块、函数、属性、内部类、对象声明。　

　　1.1 无构造器的类

//定义一个类
class BaseDataType {
    // 属性定义
    val byteValue:Byte = 127
    //get与set,  field只在get和set中使用
    var lastName: String = "zhang"
        get() = field.uppercase()  // 将变量赋值后转换为大写
        private set(value) {
            field=value+"_set"
        }

    //函数定义
    fun display(){
        println("Byte Value: $byteValue")
        //创建类实例,没有 new 关键字,与python一样
        val selfobj=BaseDataType()
        selfobj.byteValue;
    }
}

　　1.2 有构建器的类

//定义一个主构造的类
class  BaseDataType constructor(name: String) {
   //定义二级构造
    constructor(name: String, age:Int):this(name) {
       println("初始化网站名: ${name},创建了:${age}年")
    }
    val siteName=name
    //初始化
    init {
        println("初始化网站名: ${name}")
    }
}
    val bdt:BaseDataType=BaseDataType("菜鸟教程")
    //输出：初始化网站名: 菜鸟教程
    val bdt2:BaseDataType=BaseDataType("cnblogs", age = 20)
    //输出：初始化网站名: cnblogs
    //输出：初始化网站名: cnblogs,创建了:20年

　　1.3 抽象类

　　　　类本身，或类中的部分成员，都可以声明为abstract的。抽象成员在类中不存在具体的实现。

abstract  class HumanBase{
    //定义抽象函数，返回字符串
    abstract  fun  sayHello():String
    fun A(){
        println("我是父类函数")
    }
}
class  ChineseHuman:HumanBase() {
    //重写父类的抽象函数
    override fun  sayHello():String{
        return "kotlin 您好"
    }
}    
    val ch=ChineseHuman()
     //输出： kotlin 您好
    println(ch.sayHello())
    //调用父类的函数，输出：我是父类函数
    ch.A();

　　1.4重写抽象类中的函数

　　　　　在Kotlin中，默认情况下，类中成员是不开放的（即不能被其他类继承或重写），要开放使用open关键字。

　　　　　注意：无需对抽象类或抽象成员标注open，它们是开放的。

abstract  class HumanBase{
    //定义抽象函数，返回字符串
    abstract  fun  sayHello():String
    open fun A(){
        println("我是父类函数")
    }
}
class  ChineseHuman:HumanBase() {
    //重写父类的抽象函数
    override fun  sayHello():String{
        return "kotlin 您好"
    }
     override fun A(){
        //调用父类的函数
        super.A()
        println("我是子类函数")
    }
}
    // 输出：我是父类函数
    // 输出：我是子类函数
    val ch=ChineseHuman()
    ch.A();

 　　1.5 嵌套类

class Outer {
    private val bar: Int = 1
    // 嵌套类
    class Nested {
        fun foo() = 2
    }
}

 // 调用格式：外部类.嵌套类.嵌套类方法/属性
    val demo = Outer.Nested().foo()
    //输出：2
    println(demo)

　　1.6 类的修饰符

　　　　类属性修饰符：abstract--抽象类、final--类不可继承，默认属性、enum--枚举类、open--类可继承，类默认是final的，annotation--注解类

　　　　访问权限修饰符：private、protected、public、internal与C#的差不多。

二.继承

　　2.1 Any超类

　　　　Kotlin 中所有类都继承 Any 类，它是所有类的超类， 类似于java中的object类，但注意Any不是 java.lang.Object
　　　　Any提供了三个函数：equals()、hashCode()、toString()

　　2.1 open
　　　　如果一个类要被继承，可以使用 open 关键字进行修饰

open class Base(p: Int)  // 定义基类
class Derived(p: Int) : Base(p) //子类继承

　　2.3 override

　　　　在子类中使用 override 来重写基类中open修饰的函数。在1.4中有代码示例

　　　　override 还可以重写属性，如下所示：

open class Foo {
    open val x: Int get { …… }
}

class Bar1 : Foo() {
    override val x: Int = ……
}　

　　2.4 super

　　　上面1.4中也使用到了supper,没有使用supper泛型，如果子类实现了多个继承，可以使用supper泛型，如下所示：

//如果是普通基数（不是抽象类或接口类）需要子类继承，则必须在class前加open
open class A {
    open fun f () { print("A") }
    fun a() { print("a") }
}

//接口的成员变量默认是 open 的,与c#\java不一样，接口中可以有函数体
interface B {
    fun f() { print("B") }
    fun b() { print("b") }
}

//继承
class C() : A() , B{
    override fun f() {
        //super 泛型去选择性地调用父类的实现
        super<A>.f()//调用 A.f() 输出A
        super<B>.f()//调用 B.f() 输出B
    }
}

三.接口

　　3.1 接口格式

　　　　使用 interface 关键字定义接口，允许方法有默认实现(这点与java、c#不同)，一个类可以实现多个接口

　　　　接口中的方法和属性不需要使用open关键字，接口中的方法和属性是开放的

interface MyInterface {
    fun bar()    // 未实现
    fun foo() {  //已实现
      // 可选的方法体
      println("foo")
    }
}

　　3.2 接口中的属性

　　　　接口中的属性只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性。

　　　　定义属于使用var 可修改的变量，如下所示：

interface MyInterface{
    var name:String //name 属性, 抽象的
}
class MyImpl:MyInterface{
    override var name: String = "runoob" //重写属性
}

　　3.2 接口中函数重写

interface A {
    fun foo() { print("A") }   // 已实现
    fun bar()                  // 未实现，没有方法体，是抽象的
}

class C : A {
    override fun bar() { print("bar") }   // 重写
}

 四. kotlin扩展

　　　kotlin可以对一个类的属性和方法进行扩展，且不需要继承或使用 Decorator (装饰者)模式。

　　　扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响。　　

　　　4.1 扩展函数

class User(var name:String)

//扩展函数
fun User.Print(){
    println("用户名 $name")
}
//输出：用户名 hello world
 var user = User("hello world")
 user.Print()

五.kotlin数据类和密封类

　　Kotlin 可以创建一个只包含数据的类，关键字为 data

　　5.1 数据类

//定义一个数据类
data class User(val name: String, val age: Int)

//使用数据类
fun main(args: Array<String>) {
    val jack = User(name = "Jack", age = 1)
    val olderJack = jack.copy(age = 2)
    //输出：User(name=Jack, age=1)
    println(jack)
   //输出：User(name=Jack, age=2)
    println(olderJack)
}

　　5.2  密封类

　　声明一个密封类，使用 sealed 修饰类。sealed 不能修饰 interface ,abstract class(会报 warning,但是不会出现编译错误)

　　与C#一样