Kotlin类相关

kotlin主构造函数代码块和静态代码块

class Person(var name: String, var age: Int) {

    fun walk() {
        println("Kotlin Person walk...")
    }
    //有时候我们想在构造函数中做一些操作，可以在init代码块中进行
    init {
        println("这是init 代码块")
        println("构造函数中的name=$name,age=$age")
    }
    //kotlin代码
    companion object {   //kotlin的静态代码块
        init{
            println("这是静态代码块的init")
        }
    }
}

fun main() {
    val person = Person("kotlin",3)
//    println(person.name + person.age)
    person.walk()
}
//输出
这是静态代码块的init
这是init 代码块
构造函数中的name=kotlin,age=3
Kotlin Person walk...

在安卓自定义View的时候我们有多个构造函数重载

class TestView(private var context: String, private var attributeSet: String?, private var attr: Int) {
    constructor(context: String) : this(context, null, 0)
    constructor(context: String, attributeSet: String?) : this(context, attributeSet, 0)

    init {
        println("context是$context,attributeSet=$attributeSet,attr$attr")
        println("这里做初始化工作...")
    }
}

fun main() {
    val view1 = TestView("Context1")
    val view2 = TestView("Context2","AttributeSet2")
    val view3 = TestView("Context3","AttributeSet3",10086)
}
//输出
context是Context1,attributeSet=null,attr0
这里做初始化工作...
context是Context2,attributeSet=AttributeSet2,attr0
这里做初始化工作...
context是Context3,attributeSet=AttributeSet3,attr10086
这里做初始化工作...

多个init块，执行顺序是代码顺序

class Cat(name: String){
    //类体中也可以访问构造函数的参数
    val catName:String = "catName:$name"
    //初始化代码块
    init {
        // 在这里面做一些需要在主构造函数中做的初始化操作
        println("第一个初始化代码块,name:$name")
    }

    init {
        println("第二个初始化代码块,name:$name")
    }

    init {
        println("第三个初始化代码块,name:$name")
    }
}

// 使用如下：
fun main(args: Array<String>) {
  var  cat: Cat = Cat("喵喵")
  println(cat.catName)//打印属性
}
//输出
第一个初始化代码块,name:喵喵
第二个初始化代码块,name:喵喵
第三个初始化代码块,name:喵喵
catName:喵喵

数据类

• java中实现一个数据类

public class UserBean {
    private String name;
    private int age;
    private long height;

    public UserBean(String name, int age, long height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public long getHeight() {
        return height;
    }

    public void setHeight(long height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "UserBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }

    public static void main(String[] args) {
        UserBean user = new UserBean("大雄", 12, 150);
        System.out.println("用户" + user.getName() +
                ",年龄" + user.getAge() +
                ",身高" + user.getHeight());
        System.out.println("用户信息" + user.toString());
    }
}
//输出
用户大雄,年龄12,身高150
用户信息UserBean{name='大雄', age=12, height=150}

• 实现一个简单的数据类java的代码量很大，而kotlin只需要几行代码就能实现同样的数据类。kotlin数据类只需要加一个data关键字 还有copy功能

data class UserBean(var name: String, var age: Int, var height: Long)
fun main() {
    var user = UserBean("小叮当",100,50)
    println("用户${user.name},年龄${user.age},身高${user.height}")
    println("用户信息${user.toString()}")
    user = user.copy(height = 60)
    println("用户信息${user.toString()}")
}
//输出
用户小叮当,年龄100,身高50
用户信息UserBean(name=小叮当, age=100, height=50)
用户信息UserBean(name=小叮当, age=100, height=60)

枚举

• kotlin的枚举和java基本一致，只是kotlin中需要在enum后加class关键字

enum class Direction {
    WEST,
    EAST,
    NORTH,
    SOUTH
}

fun main() {
    val dr = null
    when(dr) {
        Direction.EAST -> println("东边")
        Direction.WEST -> println("西边")
        Direction.NORTH -> println("北边")
        Direction.SOUTH -> println("南边")
        else -> print("未知方向")
    }
}

//枚举常量可以有构造函数和自有属性、方法，自定义方法需放在;后
enum class Season(var enumName: String,var range: String){
    Spring("春季","1-3"),
    Summer("夏季","4-6"),
    Fall("秋季","7-9"),
    Winter("冬季","10-12");//终于见到kotlin中的；号了

    fun printSeason(){
        print("name:$enumName,range:$range")
    }
}

fun main() {
    val season = Season.Spring
    season.printSeason()
}

密封类

密闭类用 sealed 修饰符 ，密闭类的字类必须与密闭类在同一文件中（子类也可以嵌套在密闭类的内部）

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
//定义在类内部
sealed class Expr{
    data class Const(val number: Double) : Expr()
    data class Sum(val e1: Expr, val e2: Expr) : Expr()
    object NotANumber : Expr()
}

有几点需要注意：

1、一个密闭类是自身抽象的，它不能直接实例化并可以有抽象（abstract）成员

2、密闭类不允许有非-private 构造函数（其构造函数默认为 private）

3、扩展密闭类子类的类（间接继承者）可以放在任何位置，而无需在同一个文件中。

密闭类算是枚举类的扩展，用法和枚举类相似，经常配合when表达式使用，使用例子如下：

fun eval(expr: Expr): Double = when(expr) {
    is Expr.Const -> expr.number
    is Expr.Sum -> eval(expr.e1) + eval(expr.e2)
    Expr.NotANumber -> Double.NaN
    // 不再需要 `else` 子句，因为我们已经覆盖了所有的情况
}

fun main(args: Array<String>) {
    val const = eval(Expr.Const(12.0))
    val sum = eval(Expr.Sum(Expr.Const(10.0),Expr.Const(12.0)))

    println("const:$const")
    println("sum:$sum")
}   

// 执行结果：
const:12.0
sum:22.0 

嵌套类(相当于java静态内部类)

class Outer{
    val attr = 0
    // 嵌套类
    class Nested{
        fun inMethod(){
            // 不能访问外部类的属性
            println("内部类")
        }
    }
}

fun main(args: Array<String>) {
    // 调用嵌套类方法
    Outer.Nested().inMethod()
}

内部类

• Kotlin中，内部类用inner关键字，声明，跟Java 一样，内部类持有一个外部类的对象引用，可以访问外部类的属性和方法。

class Outer{
    private val attr = 10
    inner class Inner{
        fun method(){
            println("内部类可以访问外部类属性：$attr")
        }
    }
}

fun main(args: Array<String>) {
    // 调用内部类方法,看出区别了吗
    Outer().Inner().method()
}

匿名内部类

• 来看一下Java的匿名内部类：

mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // onClick
            }
        });

• 在kotlin中，匿名内部类用对象表达式创建，给View设置点击事件的kotlin代码如下：

 mButton?.setOnClickListener(object: View.OnClickListener{
            override fun onClick(v: View?) {
                //onClick
            }
        })