Kotlin 类、对象和继承 接口

1. 类

   Kotlin 中使用关键字 class 声明类。

       class MainActivity : AppCompatActivity() {
        //关键字 var 声明为可变的成员变量
        var name: String = '章三'
        var age: String = '19'
        //关键字val 声明为不可变的成员变量
         val TAG: String = 'MainActivity'
       
          override fun onCreate(savedInstanceState: Bundle?) {
              super.onCreate(savedInstanceState)
              setContentView(R.layout.activity_main)
              test()
          }
          
          //在类中定义成员函数：
          fun test() {
              var arrayLists = arrayOf("15", "68", "79", "09", "6")
              for ((index,value) in arrayLists.withIndex()) {
                  Log.e("arrayLists", "index => $index \t value => $value")
              }
          }
      }
   

   创建Test1

       class Test1 {
        var name: String = "张三"
        fun test() {
    
        }
     }
   

   引用

     var testName = Test1()
     Log.e("testName", "itestName " + testName.name)
   

   输出结果：

   testName: itestName 张三
   

   Kotlin set/get方法的使用

    class Test1 {
   
       //name用private私有修饰，外界其他地方不准访问，隐藏细节
       private var name: String = "张三"
   
       fun getName() : String{
           return name
       }
   
       fun setName(name:String) {
           this.name = name
       }
       //二级构造函数，需要加前缀 constructor
       constructor(val name: String)
   
       //初始化代码段使用 init 关键字作为前缀
       init {
           println("FirstName is $name")
       }
   
       fun test(val firstName: String) {
            setName(firstName) 
       }
   }
   

2. 抽象类 (java的继承 extends， kotlin中(冐号)：代替。Student : Base()

    package com.click.kotlindome
   
    open class Base {
       open fun go() {}
   
       open fun loading() {}
   
    }
   
   abstract class Student : Base() {
       override fun go() {
           super.go()
       }
   
       override fun loading() {
           super.loading()
       }
   }
   

3. 嵌套类

     class Test1 {
   
        //name用private私有修饰，外界其他地方不准访问，隐藏细节
        private var name: String = "张三"
    
        fun getName() : String{
            return name
        }
    
        fun setName(name:String) {
            this.name = name
        }
    
        constructor()
    
        //初始化代码段使用 init 关键字作为前缀
        init {
            println("FirstName is $name")
        }
    
        fun test() {
    
        }
    
        class Text2{
    
            fun go(name :String){
                
            }
        }
     }
   
     override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            var testName = Test1()
            // 调用格式：外部类.嵌套类.嵌套类方法/属性
            var name = Test1.Text2().go("ZHANSGAN")
            Log.e("testName", "itestName " + testName.getName())
            Log.e("testName", "name " + name)
        }
   

4. 内部类(内部类使用 inner 关键字来表示,内部类会带有一个对外部类的对象的引用，可以访问外部类成员属性和成员函数)

       class Test1 {
    
    	    //name用private私有修饰，外界其他地方不准访问，隐藏细节
    	    private var name: String = "张三"
    	
    	    fun getName() : String{
    	        return name
    	    }
    	
    	    fun setName(name:String) {
    	        this.name = name
    	    }
    	
    	    constructor()
    	
    	    //初始化代码段使用 init 关键字作为前缀
    	    init {
    	        println("FirstName is $name")
    	    }
    	
    	    fun test() {
    	
    	    }
    	    //内部类使用 inner 关键字来表示
    	    inner class Text2{
    	        //// 访问外部类成员
    	        fun fristName() = name;
    	
    	        fun go(name :String){
    	
    	        }
    	        fun innerTest() {
    	            var o = this@Test1 //获取外部类的成员变量
    	            Log.e("testName", "内部类可以引用外部类的成员，例如：" + o.getName())
    	        }
    	    }
    	}
   
   
    class MainActivity : AppCompatActivity() {
   
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            var testName = Test1()
            var name = Test1().Text2().fristName()
            var name1 = Test1().Text2().innerTest()
            Log.e("testName", "itestName " + testName.getName())
            Log.e("testName", "name " + name)
            Log.e("testName", "name1 " + name1)
        }
   
   }
   

5. 类的修饰符分为：访问权限修饰符和类属性修饰符

     accessModifier：访问权限修饰符
    ```
    private    // 仅在同一个文件中可见
    protected  // 同一个文件中或子类可见
    public     // 所有调用的地方都可见
    internal   // 同一个模块中可见
    ```
    classModifier: 类属性修饰符
    ```
    abstract    // 抽象类  
    final       // 类不可继承，默认属性
    enum        // 枚举类
    open        // 类可继承，类默认是final的
    annotation  // 注解类
    ```
   

6. 接口(java的实现接口 implements， kotlin中(冐号)：代替。Student : NameCallBack ,NameCallBack1 实现多个实用逗号隔开)

       import android.util.Log
    
    	interface NameCallBack {
    	    fun setName(name: String)
    	    fun go() {
    	        Log.e("NameCallBack", "NameCallBack")
    	    }
    	}
   
       abstract class Student : Base(), NameCallBack {
        override fun go() {
    
        }
    
        override fun loading() {
            super.loading()
        }
    
        override fun setName(name: String) {
            TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
        }
    
    
    }