kotlin类和接口

一.类的声明

与java一样，在kotlin中，类的声明也是使用class关键字，如果是声明empty类，kotlin和java没有区别，如果需要定义类的其他成员，还是有很大的区别，eg:

class MyClass{
}

class MyClass(){
     fun verify(){
        println("verify")
    }
}

二.类的属性

1.类的属性可以用关键字 var 声明为可变的，否则使用只读关键字 val 声明为不可变,eg:

class testClass(){

    var name:String="jon"
    var url:String="http:baidu.com"
    var city:String="shenzhen"
    
}

fun site(){
        val site=testClass()//kotlin中调用类没有new关键字
        print("name="+site.name+" url="+site.url)//可以直接使用.引用
    }

 2.getter和setter

getter和setter都是可选，如果属性类型可以从初始化语句或者类的成员函数中推断出来，那就可以省去类型，val不允许设置setter函数，因为它是只读的 eg：

var default: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var init = 1    // 类型为 Int, 默认实现了 getter 和 setter
val first: Int?       // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化
val type = 1   // 类型为 Int 类型,默认实现 getter

class User{

    //只读属性
    val name:String="jon"
    get() = field.toUpperCase()

    //读写属性
    var age:Int=100
     get() = field //后端变量
     set(value) {
         if (value<100){ //如果传入的值小于100返回该值
             field=value
         }else{
             field=-1 //如果传入的值大于等于100返回-1
         }
     }

    var weight:Float=120.0f
      private set

}

3.field关键字声明

Kotlin 中类不能有字段,提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器,eg:

 var age:Int=100
     get() = field //后端变量
     set(value) {
         if (value<100){ //如果传入的值小于100返回该值
             field=value
         }else{
             field=-1 //如果传入的值大于等于100返回-1
         }
     }

三.类的构造器

构造器是创建类实例必须的语法元素，在kotlin中，类允许定义一个主构造器和多个第二构造器，主构造器是类头的一部分，紧跟着类名的后面，构造参数可以自定义，eg:

class User constructor(name:String){//主构造器constructor可以省略
    init {
        println("name is $name")
    }
}

class User (name:String){

    //主构造器的实现部分
    init {
        println("name is $name")
    }

    //第二构造器，通过this直接调用了主构造器
    constructor(age:Int):this("jon"){
        println("age is $age")
    }

    //第二构造器，通过this直接调用了主构造器
    constructor(interest:String,name:String):this("jon"){
        println("$name interest is $interest")
    }

    constructor():this(18){
        println("welcome")
    }
}

四.修饰符

1.访问权限修饰符

1).private //仅仅在类的内部可以访问
2).protected //类似private,但在子类中也可以访问
3).internal //任何在模块内部类都可以访问
4).public //任何类都可以访问

2.类属性修饰符，标示类本身特性

1).abstract    // 抽象类  
2).final       // 类不可继承，默认属性
3).enum        // 枚举类
4).open        // 类可继承，类默认是final的
5).annotation  // 注解类

五.嵌套类

1.普通嵌套类

open class Outer{ //open声明，表明此类是可以继承的
    private val  bar:Int=1
    class Nested{ //嵌套类
        fun show()=5
    }
}

 val outer=Outer.Nested().show()
    println("outer is:$outer")

2 .嵌套类还可以使用inner关键字声明，变成内部类，这样可以使用外部类的实例使用嵌套类

open class Outer{ //open声明，表明此类是可以继承的
    private val  bar:Int=1
    inner class Nested{ //内部类
        fun show()=5
    }
}

val outer=Outer().Nested().show()
    println("outer is:$outer")

六.类的继承

与java不同，kotlin中类的继承使用冒号(:),而java中使用extends,需要注意的是，冒号后面需要调用父类的构造器，kotlin和java一样，都是单继承的，一个kotlin只能有一个父类。kotlin默认的class是final的，也就是说，默认的kotlin不可以继承，需要在类前面添加open关键字才允许继承class,eg:

open class Person(name:String){
    constructor(name: String,age:Int):this(name){
        println("second base constructor init")
    }
}

class Student: Person{
    constructor(name: String,age: Int,num:String,score:Int):super(name,age){
        println("-------extend second base constructor init---------")
        println("学生名： ${name}")
        println("年龄： ${age}")
        println("学生号： ${num}")
        println("成绩： ${score}")
    }

}

七.接口

kotlin和java一样，接口都是使用interface关键字声明，一个类可实现多个接口，实现方法和类继承相同，接口中的属性和方法都是open的，eg:

fun process(obj: MyClass){
    obj.verify()
    if (obj is MyInterface){
        obj.closeData()
    }
}

interface  MyInterface{
    fun closeData(){
        println("closeData")
    }
}

process(object :MyClass("jon"),MyInterface{
        override fun verify() {
            println("object verify")
        }
    })

八.抽象类

抽象是面向对象编程的特征之一，类本身，或类中的部分成员，都可以声明为abstract的,抽象成员在类中不存在具体的实现，另外需注意，无需对抽象类或抽象成员标注open注解，eg:

open class Base{
    open fun f(){

    }
}

abstract class BaseExtend :Base(){
    override abstract fun f()
}