Kotlin 类和对象

类定义

//定义空类
class  Kotlin

//类名Kotlin_1
class Kotlin_1{
    }
    
//带成员函数类
class Kotlin_2{
         fun m1(){
         prinlt("hello word")
         }    
     }

类的属性

class Kotlin_3{
          var a :String = "默认"
          var a :Int= 0
     }

//普通构造类实例    Kotlin 中没有 new 关键字
va l b = Kotlin_3()
//使用.调用该类的属性和public成员函数
b.a = "“你好么?”


Koltin 中的类可以有一个 主构造器，以及一个或多个次构造器，主构造器是类头部的一部分，位于类名称之后: 

//如果构造器有注解，或者有可见度修饰符，这时constructor关键字是必须的，注解和修饰符要放在它之前。
class Person private constructor(firstName: String) {}  //添加私有修饰
class Person constructor(firstName: String) {}              //无修饰关键字  构成关键字可省略
如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略。
class Person(firstName: String){}

getter 和 setter

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

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1    // 类型为 Int, 默认实现了 getter 和 setter

val simple: Int?       // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化
val inferredType = 1   // 类型为 Int 类型,默认实现 getter



class Person{
         
            var a : String = ""
           // Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器
            get() = field
            set(i) {
                field = if (i.length>10) "" else i
            }
            
            //默认实现getter  val不支持setter
            val b : String = ""
}

主构造器

主构造器中不能包含任何代码，初始化代码可以放在初始化代码段中，初始化代码段使用 init 关键字作为前缀

class Person constructor(firstName: String) {
    init {
        println("FirstName is $firstName")
    }
}




class Runoob  constructor(name: String) {  // 类名为 Runoob
    // 大括号内是类体构成
    var url: String = "http://www.runoob.com"
    var country: String = "CN"
    var siteName = name

    init {
        println("初始化网站名: ${name}")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

fun main(args: Array<String>) {
    val runoob =  Runoob("菜鸟教程")
    println(runoob.siteName)
    println(runoob.url)
    println(runoob.country)
    runoob.printTest()
}




    //主构造
    class Kotlin_1  constructor(arg:String){

        var a = arg

        init {
            arg
            val kt = Kotlin_0()
            kt.b = "0012065332165465655665"
        }
        
        
        lateinit var t1 :String
        private var t2 :Int = 0
       //次构造
        constructor(arg:String,a:Int) : this(arg) {
            this.t1 = arg  
            this.t2 = a
        }
    }

  //主构造  示例
   val k= Kotlin_1("")
   //次构造 示例 
   val k1= Kotlin_1("",0)
 

抽象类

open class Base {
    open fun f() {}
}

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

嵌套类

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

fun main(args: Array<String>) {
    val demo = Outer.Nested().foo() // 调用格式：外部类.嵌套类.嵌套类方法/属性
    println(demo)    // == 2
}

内部类

class Outer {
    private val bar: Int = 1
    var v = "成员属性"
    /**嵌套内部类**/
    inner class Inner {
        fun foo() = bar  // 访问外部类成员
        fun innerTest() {
             为了消除歧义，要访问来自外部作用域的 this，我们使用this@label，其中 @label 是一个 代指 this 来源的标签。
            var o = this@Outer //获取外部类的成员变量
            println("内部类可以引用外部类的成员，例如：" + o.v)
        }
    }
}


fun main(args: Array<String>) {
    val demo = Outer().Inner().foo()
    println(demo) //   1
    val demo2 = Outer().Inner().innerTest()   
    println(demo2)   // 内部类可以引用外部类的成员，例如：成员属性
}

接口类的使用

定义一个接口
interface Test {
   fun doSomething(error : String)
}

class Kotlin_3 : Test{

         init {
             //初始化
             ab("1",this)
             ab("2",this)
             ab("3",this)
         }

         /**
          *  打印结果
          */
         override fun doSomething(error: String) {
             Log.v("=======测试======","error=$error")
         }

         /**
          *  分支
          */
         fun ab(v1:String ,a:Test){
             when (v1){
                 "1" ->{ a .doSomething("你是 1 ")}
                 "2" ->{ a .doSomething("你是 2 ") }
                 else -> {
                     a .doSomething("你啥也不是 ")
                 }
             }
         }
     }

类的修饰符

类的修饰符包括 classModifier 和_accessModifier_:

    classModifier: 类属性修饰符，标示类本身特性。

    abstract    // 抽象类  
    final       // 类不可继承，默认属性
    enum        // 枚举类
    open        // 类可继承，类默认是final的
    annotation  // 注解类

    accessModifier: 访问权限修饰符

    private    // 仅在同一个文件中可见
    protected  // 同一个文件中或子类可见
    public     // 所有调用的地方都可见
    internal   // 同一个模块中可见