Kotlin基础语法篇

自从实习结束后直到现在将近一年多的时间再也没有用过kotlin,

在今年五月份I/O大会上,Google再次明确了Kotlin在Android开发中的地位,并毫无悬念的将这个“后生晚辈”定为官方“首选”语言,这使得Kotlin不得不被“传统java

开发者”重视,他们是时候改拥抱变化了,所以我们项目主要技术负责人现在勉强接受大家使用Kotlin开发意愿(实在不容易~)。

对荒废了一年的语言现在重新拾起感觉又熟悉又陌生,但内心还是很兴奋的,最近准备系统地整理一下Kotlin相关内容, 希望能在短时间内重新掌握,今天主要重新梳理一下Kotlin基础语法。

Kotlin语言介绍

Kotlin 是 JetBrains 在 2010 年推出的基于 JVM 的新编程语言,是一种新的静态类型编程语言。开发者称,设计它的目的是避免 Java 语言编程中的一些难题。比如:在 Kotlin 中类型系统控制了空指针引用,可以有效避免 Java 中常见的NullPointException。

相比于 Java,Kotlin 有着更好的语法结构,安全性和开发工具支持。

Kotlin 中没有基础类型,数组是定长的,泛型是安全的,即便运行时也是安全的。此外,该语言支持闭包,还可通过内联进行优化。不过,它不支持检查异常(Checked Exceptions),许多语言设计者认为这是它的瑕疵。不论如何,重要的是 Java 和 Kotlin 之间的互操作性:Kotlin 可以调用 Java,反之亦可。

Kotlin基于JVM的字节码结构(与java同属静态语言),Kotlin 应用程序的运行速度与 Java 类似。,但随着 Kotlin 对内联函数的支持,使用 lambda 表达式的代码通常比用 Java 写的代码运行得更快。

Kotlin 可与 Java 进行 100% 的互操作,允许在 Kotlin 应用程序中使用所有现有的 Android 库 ,这包括注解处理,Google官方也说过未来Android支持库优先支持Kotlin语言;

Kotlin属于跨平台编译语言,除了可以进行原声开发外很好的支持Java服务端程序开发、Android应用程序开发以及JavaScript开发;

Kotlin安装与配置这里省略(网上很多教程,AndroidStudio3.x版本默认已支持Kotlin插件)

基础数据类型


Kotlin 的基本数据类型包括 Byte、Short、Int、Float、Long、Double 、Boolean,

在java中基本数据类型一共有八种分别包括整形:byte、short、int、long,浮点型:float、double , 字符型 char

以及布尔型 boolean,不同于 Java 的是,Kotlin 字符不属于数值类型,是一个独立的数据类型,

大家可以看出Kotlin的基本数据类型和java不一样,Kotlin 中其实没有基础数据类型,只有封装的对象类型,你每定义的一个变量,其实

Kotlin 帮你封装了一个对象,这样可以保证不会出现空指针,

对应Java中八大基本数据类型的对象类型、java在使用基础数据类型时候可以通过装箱操作封装成对象;

字符

和 Java 不一样,Kotlin 中的 Char 不能直接和数字操作(可以通过显示转换char.toInt()),Char 必需是单引号 ' 包含起来的。比如普通字符 '0','a',字符字面值用单引号括起来: '1'。 特殊字符可以用反斜杠转义。 支持这几个转义序列:\t、 \b、\n、\r、\'、\"、\\ 和 \$。

当需要可空引用时,像数字、字符会被装箱。装箱操作不会保留同一性。

布尔

       布尔用 Boolean 类型表示,它有两个值:true 和 false。当需要可空引用布尔会被装箱。

数组

      数组用Array类实现,具有size属性、get、setf方法,由于使用 [] 重载了 get 和 set 方法,所以我们可以通过下标很方便的获取或者设置数组对应位置的值。java中素组具有length属性以及使用[]通过下标方式访问属性;

数组的创建两种方式:一种是使用函数arrayOf();另外一种是使用工厂函数。如下所示,我们分别是两种方式创建了两个数组:

fun main(args: Array<String>) {

    //[1,2,3]

    val a = arrayOf(1, 2, 3)

    //读取数组内容

    println(a[0])    // 输出结果:1

    println(b[1])    // 输出结果:2

}

val x: IntArray = intArrayOf(1, 2, 3

除了类Array,还有ByteArray, ShortArray, IntArray,LongArray等用来表示各个类型的数组,省去了装箱操作,因此效率更高,其用法同Array一样:

字符串

和java一样,String属于不可变的,Kotlin可以通过[]很方便访问对应下标字符,java中通过chatAt方法或者subString等方式获取对应字符,Kotlin中String支持遍历形式访问其中的字符,这一点很使用;

for (c in str) {

    println(c)

}

另外Kotlin 支持三个引号 """ 扩起来的字符串,支持多行字符串,比如:

fun main(args: Array<String>) {

    val text = """多行字符串 多行字符串"""

    println(text)  // 输出

}

String 可以通过 trim(),trimEnd(),trimStart(),trimMargin() 等方法来删除多余的空白。

类型转换

java中可以通过隐式类型转换,数值大的类型可以转换成数据小的类型,但是这样往往会丢失精度,在kotlin中由于不同的表示方式,较小类型并不是较大类型的子类型,较小的类型不能隐式转换为较大的类型。

这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋给一个 Int 变量,

val b: Byte = 1 // OK, 字面值是静态检测的

val i: Int = b.toInt() // OK

每种数据类型都有下面的这些方法,可以转化为其它的类型:

toByte(): Byte

toShort(): Short

toInt(): Int

toLong(): Long

toFloat(): Float

toDouble(): Double

toChar(): Char

2. 变量、常量声明

定义只读变量使用关键字val定义,只能为其赋值一次,

val a: Int = 1  // 立即赋值 (非空属性必须在定义时候初始化,)

val b = 2  // 自动推断出 `Int` 类型  (非空属性必须在定义时候初始化,)

可重新赋值的变量使用var关键字:

var x = 5 // 自动推断出 `Int` 类型 (非空属性必须在定义时候初始化,)

x += 1

Kotlin语法支持类型自动推断,在声明变量或者常量的时候可以不用指定其类型,编译器在编译时候会为我们指定其类型;

非空属性必须在定义的时候初始化,kotlin提供了一种可以延迟初始化的方案,使用 lateinit 关键字描述属性:

var count:Int?=null //可空属性可以在后面赋值

count=5

lateinit var name : String 非空属性使用延迟初始化

函数定义

函数定义使用fun关键字,参数格式为 参数:类型 ,最后函数返回值类型,如下

fun sum( a:Int, b:Int):Int{return a+b}

亦可以函数表达式声明函数

fun sum( a:Int, b:Int)=  a+b  // 自动类型推断或者 fun sum(a:Int,b:Int):Int=a+b 

无返回值的函数定义(类似Java中的void):

fun printSum(a: Int, b: Int): Unit {

    print(a + b)

}

Unit返回类型可以省略:

public fun printSum(a: Int, b: Int) {

    print(a + b)

}

3. 可变长参数函数

可变长参数用vararg关键字进行修饰:

fun print(vararg v:Int){ 

        for(a in v){ 

            println("$a")

        }

}

4. 字符串模板

$ 表示一个变量名或者变量值

$varName 表示变量值

${varName.fun()} 表示变量的方法返回值:

var a = 1

// 模板中的简单名称:

val s1 = "a is $a"

a = 2

// 模板中的任意表达式:

val s2 = "${s1.replace("is", "was")}, but now is $a"

// 运行结果:a was 1, but now is 2

5. 条件表达式

看一个常用if表达式:

fun value(a:Int, b :Int):Int {

  if(a>b) {

    return a+b 

  }else{ 

    return a-b   

  }

}

通过条件表达式可以:

fun value(a:Int,b:Int)=if(a>b) a+b else a-b

6. NULL检查机制

Kotlin的空安全设计对于声明可为空的参数,在使用时要进行空判断处理,有两种处理方式,字段后加!!像Java一样抛出空异常,另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理

//类型后面加?表示可为空

var age: String? = "23"

//抛出空指针异常

val ages = age!!.toInt()

//不做处理返回 null

val ages1 = age?.toInt()

//age为空返回-1

val ages2 = age?.toInt() ?: -1

当一个引用可能为 null 值时, 对应的类型声明必须明确地标记为可为 null。

Kotlin 的NULL机制旨在消除来自代码空引用的危险,这在java语言中属于最常见的陷阱之一,也就是访问空引用的成员会导致空引用异常。经常会抛出NullPointerException或简称NPE。

在Kotlin中经常会有一些链式调用用法,安全调用在链式调用中很有用,如:person?.class?.countName 如果调用链中任何一个属性值出现null情况,调用链会直接返回null,

后面属性不会出现NPE异常。

如果相对非null值执行某个操作,可以结合let操作符一起使用:

val listWithNulls: List<String?> = listOf("Kotlin", null)     

for (item in listWithNulls) {

          item?.let { 

          println(it) // 输出 Kotlin 并忽略 null 

    }

}

同样安全调用也可以出现在赋值的左侧,如果调用链中的任何一个接收者为空都会跳过赋值,而右侧的表达式根本不会求值:

person?.class?.mathTeacher = TeachManager.getTeacher()

7. Elvis 操作符

当我们有一个可空的引用r时,我们可以说“如果r非空,我使用它;否则使用某个非空的值x”:

val l: Int = if (b != null) b.length else -1

或者

fun value(a:Int,b:Int)=if(a>b) a+b else a-b

//条件表达式用法

除了完整的 if-表达式,这还可以通过 Elvis 操作符表达,写作?:

val l = b?.length ?: -1

如果?:左侧表达式非空,elvis 操作符就返回其左侧表达式,否则返回右侧表达式。请注意,当且仅当左侧为空时,才会对右侧表达式求值。

这种Elvis用法类似java语言中三元操作符;

public int value(int a,int b){return a>b?a+b :a-b}

等同于:

fun value(a:Int,b:Int)=if(a>b) a+b else a-b

val l = b?.length ?: -1

等同于:

final int l= b!=null? b.length : -1

8. 类型检测及类型转换

如果对象不是目标类型,那么常规类型转换可能会导致ClassCastException,

val aInt: Int? = a as Int

为了避免类型转成异常,另一个选择是使用安全的类型转换,如果尝试转换不成功则返回 null:

val aInt: Int? = a as? Int

或者

val sInt :Int?= if(a is Int) a as Int else null

或者

val sInt :Int?= if(a is Int) a else null

is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字), 如果一个不可变的局部变量或属性已经判断出为某类型,那么检测后的分支中可以直接当作该类型使用,无需显式转换:

fun getStringLength(obj: Any): Int? {

  if (obj is String) {

    // 做过类型判断以后,obj会被系统自动转换为String类型

    return obj.length

  }

  // 这里的obj仍然是Any类型的引用

  return null

}

或者

fun getStringLength(obj: Any): Int? {

  if (obj !is String)

    return null

  // 在这个分支中, `obj` 的类型会被自动转换为 `String`

  return obj.length

}

9. 可空类型的集合

如果你有一个可空类型元素的集合,并且想要过滤掉空元素,你可以使用filterNotNull来实现:

val listOf = listOf<Int?>(1, 2, null, 4)

val intList: List<Int> = listOf.filterNotNull()

10. 区间

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。

使用 in 运算符来检测某个数字是否在指定区间内:

for (i in 1..4) print(i) // 输出“1234”

for (i in 4..1) print(i) // 什么都不输出

if (i in 1..10) { // 等同于 1 <= i && i <= 10

    println(i)

}

// 使用 step 指定步长

for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”

// 使用 until 函数排除结束元素

for (i in 1 until 10) {  // i in [1, 10) 排除了 10

    println(i)

}

val list = listOf("a", "b", "c")

if (-1 !in 0..list.lastIndex) {

    println("-1 is out of range")

}

if (list.size !in list.indices) {

    println("list size is out of valid list indices range, too")

}

11. 使用 for 循环

for 循环可以对任何提供迭代器(iterator)的对象进行遍历,语法如下:

同样,kotlin的for循环中使用的也是in操作符,

val items = listOf("dog", "cat", "pig")

for (item in items) {

println(item)

}

或者通过索引

val items = listOf("apple", "banana", "kiwifruit")

for (index in items.indices) {

    println("item at $index is ${items[index]}")

}

val array=arrayOf("a","b","c")

for (i in array.indices) {

    print(array[i])

}

12. 使用 when 表达式

when 将它的参数和所有的分支条件顺序比较,直到某个分支满足条件,

when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式,符合条件的分支的值就是整个表达式的值,如果当做语句使用, 则忽略个别分支的值。

when 类似java语言的 switch 操作符。其最简单的形式如下:

fun describe(obj: Any): String =

when (obj) {

1          -> "One"

"Hello"    -> "Greeting"

is Long    -> "Long"

!is String -> "Not a string"

else      -> "Unknown"

}

在Kotlin中Any类是所有类的超类,类似java中的Object;

在 when 中,else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。如果很多分支需要用相同的方式处理,则可以把多个分支条件放在一起,用逗号分隔。

when 也可以用来取代 if-else if链。 如果不提供参数,所有的分支条件都是简单的布尔表达式,而当一个分支的条件为真时则执行该分支:

when {

    x.isOdd() -> print("x is odd")

    x.isEven() -> print("x is even")

    else -> print("x is funny")

}

13. 使用 lambda 表达式来过滤(filter)与映射(map)集合

val fruits = listOf("banana", "avocado", "apple", "kiwifruit")

fruits.filter { it.startsWith("a") }

.sortedBy { it }

.map { it.toUpperCase() }

.forEach { println(it) }

结果:APPLE AVOCADO

14. 类以及构造器

类的修饰符包括 classModifier 和_accessModifier_:

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

abstract    // 抽象类 

final      // 类不可继承,默认属性

enum        // 枚举类

open        // 类可继承,类默认是final的

annotation  // 注解类

accessModifier: 访问权限修饰符

private    // 仅在同一个文件中可见

protected  // 同一个文件中或子类可见

public    // 所有调用的地方都可见

internal  // 同一个模块中可见

主构造器(主构造函数)

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

class Person constructor(firstName: String) {}

如果主构造器没有任何注解,也没有任何可见度修饰符,那么constructor关键字可以省略。

class Person(firstName: String) {

}

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

class Person constructor(firstName: String) {

    init {

      firstName="Scus"  //主构造器的参数可以在初始化代码段中使用

    }

}

另外可以通过主构造器来定义属性并初始化属性值(可以是var或val):

class People(val firstName: String, val lastName: String) {

    //...

}

如果一个非抽象类没有声明构造函数(主构造函数或次构造函数),它会产生一个没有参数的构造函数。构造函数是 public 。如果你不想你的类有公共的构造函数,你就得声明一个空的主构造函数:

class DontCreateMe private constructor () {

}

次构造函数

类也可以有二级构造函数,需要加前缀 constructor:

class Person(val name: String) {

    constructor (name: String, age:Int) : this(name) {

        // 初始化...

    }

}

抽象类

抽象是面向对象编程的特征之一,类本身,或类中的部分成员,都可以声明为abstract的。抽象成员在类中不存在具体的实现

注意:无需对抽象类或抽象成员标注open注解。

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

    }

}

匿名内部类

使用对象表达式来创建匿名内部类:

    test.setInterFace(object : TestInterFace {

        override fun test() {

            println("对象表达式创建匿名内部类的实例")

        }

    })

内部类

内部类使用 inner 关键字来表示。

内部类会带有一个对外部类的对象的引用,所以内部类可以访问外部类成员属性和成员函数。

class Outer {

    private val bar: Int = 1

    var v = "成员属性"

    /**嵌套内部类**/

    inner class Inner {

        fun foo() = bar  // 访问外部类成员

        fun innerTest() {

            var o = this@Outer //获取外部类的成员变量

            println("内部类可以引用外部类的成员,例如:" + o.v)

        }

    }

}

数据类

Kotlin 可以创建一个只包含数据的类,关键字为 data:

data class User(val name: String, val age: Int)

密封类

密封类用来表示受限的类继承结构:当一个值为有限几种的类型, 而不能有任何其他类型时。在某种意义上,他们是枚举类的扩展:枚举类型的值集合 也是受限的,但每个枚举常量只存在一个实例,而密封类 的一个子类可以有可包含状态的多个实例。

声明一个密封类,使用 sealed 修饰类,密封类可以有子类,但是所有的子类都必须要内嵌在密封类中。

sealed class Expr

data class Const(val number: Double) : Expr()

data class Sum(val e1: Expr, val e2: Expr) : Expr()

object NotANumber : Expr()

fun eval(expr: Expr): Double = when (expr) {

    is Const -> expr.number

    is Sum -> eval(expr.e1) + eval(expr.e2)

    NotANumber -> Double.NaN

}

15. 接口

Kotlin 接口与 Java 8 类似,使用 interface 关键字定义接口,允许方法有默认实现:

interface MyInterface {

    fun bar() // 未实现   

    fun foo() {//已实现     

        println("foo") 

    }

}

一个类或者对象可以实现一个或多个接口。

class Child : MyInterface {

    override fun bar() {

        // 方法体

    }

    override fun fool() {

        // 方法体

    }

}

接口中的属性只能是抽象的,不允许初始化值,接口不会保存属性值,实现接口时,必须重写属性:

interface MyInterface{

    var name:String //name 属性, 抽象的

}

class MyImpl:MyInterface{

    override var name: String = "runoob" //重写属性

}

16. Kotlin 继承

kotlin 中所有类都继承该 Any 类,它是所有类的超类,对于没有超类型声明的类是默认超类:

如果一个类要被继承,可以使用 open 关键字进行修饰。

open class Base(p: Int)          // 定义基类

class Derived(p: Int) : Base(p)

注意:Any 不是 java.lang.Object。

如果子类有主构造函数, 则基类必须在主构造函数中立即初始化。

open class Person(var name : String, var age : Int){// 基类

}

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

}

如果子类没有主构造函数,则必须在每一个二级构造函数中用 super 关键字初始化基类,或者在代理另一个构造函数。初始化基类时,可以调用基类的不同构造方法。

class Student : Person {

    constructor(ctx: Context) : super(ctx) {

    }

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {

    }

}

在基类中,使用fun声明函数时,此函数默认为final修饰,不能被子类重写。如果允许子类重写该函数,那么就要手动添加 open 修饰它,。

17.对象声明

Kotlin 使用 object 关键字来声明一个对象。

Kotlin 中我们可以方便的通过对象声明来获得一个单例。

object DataProviderManager {

    fun registerDataProvider(provider: DataProvider) {

        // ……

    }

    val allDataProviders: Collection<DataProvider>

        get() = // ……

}

引用该对象,我们直接使用其名称即可:

DataProviderManager.registerDataProvider(……)

当然你也可以定义一个变量来获取获取这个对象,当你定义两个不同的变量来获取这个对象时,你会发现你并不能得到两个不同的变量,也就是说通过这种方式,我们获得一个单例:如

object Site {

    var url:String = ""

    val name: String = "菜鸟教程"

}

fun main(args: Array<String>) {

    var s1 =  Site

    var s2 = Site

    s1.url = "www.runoob.com"

    println(s1.url)

    println(s2.url)

}

// 输出结果都为"www.runnoob.com"

18.伴生对象

类内部的对象声明可以用 companion 关键字标记,这样它就与外部类关联在一起,我们就可以直接通过外部类访问到对象的内部元素。

class MyClass {

    companion object Factory {

        fun create(): MyClass = MyClass()

    }

}

val instance = MyClass.create()  // 访问到对象的内部元素

我们可以省略掉该对象的对象名,然后使用 Companion 替代需要声明的对象名:

class MyClass {

    companion object {

    }

}

注意:一个类里面只能声明一个内部关联对象,即关键字 companion 只能使用一次。

伴生对象的成员看起来像java的静态成员,但在运行时他们仍然是真实对象的实例成员。

©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 194,911评论 5 460
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 82,014评论 2 371
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 142,129评论 0 320
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 52,283评论 1 264
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 61,159评论 4 357
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 46,161评论 1 272
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 36,565评论 3 382
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 35,251评论 0 253
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 39,531评论 1 292
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,619评论 2 310
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,383评论 1 326
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 32,255评论 3 313
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 37,624评论 3 299
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,916评论 0 17
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,199评论 1 250
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 41,553评论 2 342
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 40,756评论 2 335

推荐阅读更多精彩内容