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()
}

你可能感兴趣的:(kotin,大数据)