Kotlin中的匿名对象对应的是Java中的匿名内部类。
Kotlin中的数据类方便我们去保存数据。
接下来本文将和大家说一下，对象表达式和对象声明及数据类相关定义的语法糖。

对象表达式和对象声明

我们需要创建一个对某个类做了轻微改动的类的对象，而不用为之显式声明新的子类。Java用匿名内部类处理这种情况。Kotlin中则用对象表达式和对象声明。

1. 对象表达式是在使用他们的地方立即执行（及初始化）的
2. 对象声明是在第一次被访问到时延迟初始化的
3. 伴生对象的初始化是在相应的类被加载（解析）时，与Java静态初始化器的语义相匹配

对象表达式

先写一个Java中的匿名内部类，好和Kotlin中对象表达式作比较

//声明一个抽象类
abstract class Person {
    public abstract void play();
}

//定义一个普通的变量
int i = 1;
//声明一个匿名内部类
Person p = new Person() {
    public void play() {
        System.out.println("play:" + i);//i不可修改
    }
};

//调用
p.play();//play:1

与上面Java的匿名内部类对应Kotlin中的匿名对象。和Java一样匿名对象中也可以访问同一作用域的变量，但是Kotlin更灵活，因为它有可变变量，不仅可以访问还可以修改。如上Java的不能直接修改变量，如下当Kotlin变量定义为var可以，val不可以。

abstract class Person {
    abstract fun play()
}

//定义可变变量
var i: Int = 1
//对象表达式
val a:Person=object : Person() {
    override fun play() {
        i++//可以修改
        println("play:" + i)
    }
}

//调用
a.play() //play:2

接下来看Kotlin比Java更灵活。定义一个接口和抽象类，一个匿名对象搞定，而Java需要定义两个匿名内部类。

abstract class Person {
    abstract fun play()
}

interface Move {
    fun walk()
}

//对象表达式
val a: Any = object : Person(), Move {
    override fun walk() {
        println("walk")
    }

    override fun play() {
        println("play")
    }
}

//调用
if (a is Person) {
    a.play()
}
if (a is Move) {
    a.walk()
}
//play 
//walk

如果只是简单的需要一个对象，那么可以如下简写。

val b = object {
    var x: Int = 1
    var y: Int = 2
}

//调用
println(b.x + b.y)//3

匿名对象可以作为函数或属性的返回类型，该函数或属性的实际类型会是匿名对象声明的超类型，如果没有声明任何超类型，就会是Any，这时在匿名对象中添加的成员将无法访问。

// 私有函数，其返回类型是匿名对象类型
private fun f() = object {
    val x: String = "x"
}

// 公有函数，其返回类型是 Any
fun publicF() = object {
    val x: String = "x"
}

//调用
val x1 = f().x        //可以解析
val x2 = publicF()  //不能解析引用的x

对象声明

对象声明是用object关键词标记。调用对象中的方法直接使用名称.调用即可。

//对象声明
object Data {
    fun r() {
    }
}

//调用
Data.r()

对象声明不能在局部作用域（即直接嵌套在函数内部），但是可以嵌套到其他对象声明或非内部类中。

伴生对象

类内部的对象声明可以用companion关键词标记，这样称之为伴生对象。伴生对象中的成员可通过只使用类名作为限定符来调用。

class F {
    companion object Walk {
        fun create() {
            println("walk")
        }
    }
}

//调用
F.create()
//or
F.Walk.create()
//walk

也可以省略伴生对象的名称。

class F {
    companion object {
        fun create() {
            println("walk")
        }
    }
}

//调用
F.create()
//or
F.Companion.create()
// walk

还可以实现接口。

class F1 {
    companion object : Walk {
        override fun create(){
            println("walk")
        }
    }
}

interface Walk {
    fun create()
}

//调用
F.create()
//or
F.Walk.create()
//walk

数据类

当我们需要创建一些只保存数据的类，这样就要用到Kotlin中数据类，用关键词data标记。</br>
声明数据类必须满足以下条件：

1. 主构造函数需要至少有一个参数；
2. 主构造函数的所有参数需要标记为 val 或 var；
3. 数据类不能是抽象、开放、密封或者内部的；
4. （在1.1之前）数据类只能实现接口。

val p = User("Whyte", 18)
//调用
println(p.name + " is " + p.age)//Whyte is 18

//也可以这样调用
val (name, age) = p
println(name + " is " + age)

println(p)//User(name=Whyte, age=18)

编译器自动从主构造函数中声明的所有属性生成以下成员：

1. equals()／hashCode()
2. toString() 格式是 如上代码输出 "User(name=Whyte, age=18)"
3. componentN() 函数 按声明顺序对应于所有属性
4. copy() 函数

如果在类中或继承自这个类显式实现了这些函数时，则不会生成该函数。

如果生成的类需要含有一个无参的构造函数，则所有的属性必须指定默认值

复制

需要复制一个对象改变它的一些属性，但其余部分保持不变。copy()函数就是为此而生

val newP = p.copy(age = 19)
println(newP.name + " is " + newP.age)
//Whyte is 19