Kotlin学习(六) --其他特殊的类

Kotlin的特殊的类

把之前学的kotlin知识总结一下哈，区别于java kotlin有很多特殊的类，主要就是根据安卓开发设计的感觉。

数据类

这个数据类就很关键了，可以节约好多开发的时间，尤其是在解析json数据时候，自己创建的类的时候，用数据类就很方便。
格式：data class 类名(var param1 ：数据类型,…){}
关键字：data
举个例子：在java中一个数据类如下

public class Person {

    private String name;
    private String surname;
    private String id;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (name != null ? !name.equals(person.name) : person.name != null) return false;
        if (surname != null ? !surname.equals(person.surname) : person.surname != null)
            return false;
        return id != null ? id.equals(person.id) : person.id == null;

    }

    @Override public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (surname != null ? surname.hashCode() : 0);
        result = 31 * result + (id != null ? id.hashCode() : 0);
        return result;
    }

    @Override public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", surname='" + surname + ''' +
                ", id='" + id + ''' +
                '}';
    }
}

但在kotlin里面我们可能只需要一行。。。。emmmmmm

data class Person(var name: String, var surname: String, var id: String)

其中我们就可以发现省了好多的代码，，查资料我发现kotlin的数据类帮我们做了好多的事
当我们声明一个数据类时，编辑器自动为这个类做了一些事情，不然它怎么又比Java简洁呢。它会根据主构造函数中所定义的所有属性自动生成下列方法：
1生成equals()函数与hasCode()函数
2生成toString()函数，由类名（参数1 = 值1，参数2 = 值2，….）构成
3由所定义的属性自动生成component1()、component2()、…、componentN()函数，其对应于属性的声明顺序。
4copy()函数。

copy函数的用法

在数据类的特殊copy函数就是可以局部修改部分属性，但是保持其他不变
就像下面的例子

val mUser = User("笑笑","16")
println(mUser)
val mNewUser = mUser.copy(name = "小笑笑")
println(mNewUser)

输出结果是：
User(name=笑笑, pwd=16)
User(name=小笑笑, pwd=16)

解构声明

Kotlin中定义一个数据类，则系统会默认自动根据参数的个数生成component1() … componentN()函数。其…,componentN()函数就是用于解构声明的 个人理解就是可以是单独把数据类对象的个别变量的值得出来 看下下面的例子

val mUser = User("笑笑,"17")
val (name,pwd) = mUser
println("name = $name\tpwd = $pwd")

输出结果：
name = 笑笑 pwd = 17

抽象类

这个和java里面的抽象类差不多一样的
关键字：abstract
abstract可以修饰类 也可以修饰抽象类里面的变量和方法
举例子

abstract class Lanauage{
    val TAG = this.javaClass.simpleName  // 自身的属性

    // 自身的函数
    fun test() : Unit{
        // exp
    }
    abstract var name : String           // 抽象属性
    abstract fun init()                  // 抽象方法
}

class TestAbstarctA : Lanauage(){

    override var name: String
        get() = "Kotlin"
        set(value) {}

    override fun init() {
        println("我是$name")
    }
}

class TestAbstarctB : Lanauage(){
    override var name: String
        get() = "Java"
        set(value) {}

    override fun init() {
        println("我是$name")
    }
}

fun main(args: Array<String>) {

    // val lanauage = Lanauage() 是错误的，因为抽象类不能直接被实例化

    val mTestAbstarctA = TestAbstarctA()
    val mTestAbstarctB = TestAbstarctB()

    println(mTestAbstarctA.name)
    mTestAbstarctA.init()

    println(mTestAbstarctB.name)
    mTestAbstarctB.init()
}

输出结果：
Kotlin
我是Kotlin
Java
我是Java

抽象类本身具有普通类特性，以及组成部分。不过值得注意的是，抽象类不能直接被实例化
其抽象了类的子类必须全部重写带abstract修饰的属性和方法。
抽象成员只有定义，没有实现。都有abstract修饰符修饰。
抽象类是为其子类定义了一个模板。不同是类实现不同的功能
抽象类中可以定义内部抽象类。
只能继承一个抽象类。
若要实现抽象类的实例化，需要依靠子类采用向上转型的方式处理。
抽象类可以继承自一个继承类，即抽象类可以作为子类。

内部类

在安卓开发中内部类和匿名内部类都是很常见的
关键字：inner
格式：inner class 类名(参数){}

class Other{            // 外部类
    val numOther = 1

    inner class InnerClass{     // 嵌套内部类
        val name = "InnerClass"
        fun init(){
            println("我是内部类")
        }
    }
}

fun main(args: Array<String>) {
   Other().InnerClass().init()  
}

输出结果：我是内部类

注意：调用内部类的属性或方法的格式为：外部类().内部类().内部类方法/属性。在调用的时候嵌套类是需要实例化的。
内部类不能使用外部类的属性和成员

在这里注意内部类和嵌套类的区别
1 嵌套类没有关键字/所谓的嵌套类：即指一个类可以嵌套在其他类中。
2嵌套类可以直接创建实例，方式是包装类.嵌套类
val nested : Outter.Nested()
3内部类不能直接创建实例，需要通过外部类调用
val outter = Outter()
outter.Inner().execute()
4 嵌套类的调用方法 外部类.内部类().内部类方法/属性
ps就是没带括号啊啊啊啊啊

匿名内部类

这个安卓开发经常用在开发中，匿名内部类随处可见。比如说Button的OnClickListener，ListView的单击、长按事件等都用到了匿名内部类。 一般的使用方式为定义一个接口，在接口中定义一个方法。

class Other{

    lateinit private var listener : OnClickListener

    fun setOnClickListener(listener: OnClickListener){
        this.listener = listener
    }

    fun testListener(){
        listener.onItemClick("我是匿名内部类的测试方法")
    }
}    

interface OnClickListener{
    fun onItemClick(str : String)
}

fun main(args: Array<String>){
    // 测试匿名内部类
    val other = Other()
    other.setOnClickListener(object : OnClickListener{
        override fun onItemClick(str: String) {
            // todo
            println(str)
        }
    })
    other.testListener()
}

接口中的属性使用

在接口中申明属性。接口中的属性要么是抽象的，要么提供访问器的实现。接口属性不可以有后备字段。而且访问器不可以引用它们。接口里面都是抽象的方法必须靠继承类来实例化它的方法
关键字：interface
格式：interface 接口名{
…
}

fun main(args: Array<String>) {

   // 类的初始化
   var demo = Demo1()

   demo.fun1()
}

/**
 * 我定义的接口
 */
interface Demo1Interface{

    // 定义的方法
    fun fun1()
}

/**
 * 接口的实现类
 */
class Demo1 : Demo1Interface{
    override fun fun1() {
        println("我是接口中的fun1方法")
    }
}

总结

这几天就看了几个kotlin类的相关知识，，，还有密封类什么的看不太懂