面向对象
面向对象的含义大家应该并不陌生，通过将事物抽象成对象，大大简化了程序的开发难度。我们常用的Java、Python、C++都属于面向对象的编程语言。Kotlin和java很相似，也是一种面向对象的语言。作为Kotlin中最重要的一部分，我们可以通过了解Kotlin的OOP进而了解这门语言，本文将从类、属性、接口、对象等多个方面介绍Kotlin的面向对象的特性。
类
和大部分语言类似，Kotlin使用class作为类的关键字，当我们声明一个类时，需要通过class加类名的方式实现：
|
1
2
3
|
class ClassDemo{
}
|
在声明一个类的时候，至少需要包含class关键字以及后面的类名，同时也可以根据需要增加类头（用来声明一些参数）和类体（花括号{}中包含的内容，可省略）。
构造函数
与java不同的是，虽然都可以包含多个构造函数，但java中的各个构造函数都是平级的，而Kotlin中却分为了两级（主构造函数和二级构造函数），主构造函数是包含在类头中的，需要在init方法中实现额外的操作，而二级构造函数可以在函数体中实现所有操作
|
1
2
3
4
5
6
|
//主构造函数，constructor和init都可省略
class ClassDemo constructor(type:String){
init{
System.out.println(type)
}
}
|
在主构造函数中传入的参数可以在类体中为属性赋值，也可以直接在主构造函数中声明
|
1
2
3
|
class ClassDemo(type:String, var prop2: String = type){
var prop1 = type
}
|
二级构造函数必须包含constructor
|
1
2
3
4
5
|
class ClassDemo{
constructor(type:String){
System.out.println(type)
}
}
|
对于有主构造函数的类而言，每个二级构造函数都要，或直接或间接通过另一个二级构造函数代理主构造函数。在同一个类中代理另一个构造函数使用 this 关键字：
|
1
2
3
4
5
6
|
//包含主构造函数的二级构造函数
class ClassDemo(type:String){
constructor(type:String, param:String):this(type){
System.out.println(type + param)
}
}
|
无论有没有声明主构造函数，Kotlin都会提供一个构造函数的方法，有时可能不希望将某个类的构造函数暴露出来（比如实现单例模式时），那么就需要对主构造函数进行处理
|
1
2
3
|
class ClassDemo private constructor(){
}
|
当我们想创建实例时，可以直接调用对应的构造函数进行创建
|
1
2
|
var demo = ClassDemo("hello world")
val demo = ClassDemo("hello","world")
|
我们注意到，在Kotlin中无论是声明属性还是创建实例，会有两种方式，var和val，val类似于java中的final，通过它声明的内容是无法变化的，而var和val相反，声明的内容既可以读取也可以修改。
继承
在Kotlin中，所有的类会默认继承Any这个父类，但Any并不完全等同于java中的Object类，因为它只有equals(),hashCode()和toString()这三个方法。当我们想定义一个父类时，需要使用open关键字
|
1
2
3
|
open class Base{
}
|
然后在子类中使用冒号“：”进行继承
|
1
2
3
|
class SubClass : Base(){
}
|
如果父类有构造函数，那么必须在子类的主构造函数中进行继承，没有的话则可以选择主构造函数或二级构造函数
|
1
2
3
4
5
6
7
8
9
|
//父类
open class Base(type:String){
}
//子类
class SubClass(type:String) : Base(type){
}
|
重写
Kotlin中的重写和java中也有所不同，因为Kotlin提倡所有的操作都是明确的，因此需要将希望重写的方法设为open
|
1
|
open fun funDemo() {}
|
然后通过override标记实现重写
|
1
2
3
|
override fun funDemo() {
super.funDemo()
}
|
override重写的函数也是open的，如果希望它不被重写（前提是这个类可以被继承），可以在前面增加final标签
|
1
2
3
4
5
6
7
8
9
|
open class SubClass : Base{
constructor(type:String) : super(type){
}
final override fun funDemo() {
super.funDemo()
}
}
|
当一个类同时继承且实现了多个接口时，如果重写的方法在父类和接口中都有定义，那么可以通过super<>的方式进行继承
|
1
2
3
4
5
6
7
8
9
10
11
12
|
//接口
interface InterfaceDemo{
fun funDemo(){}
}
//继承Base并且实现InterfaceDemo
class SubClass : Base(),InterfaceDemo{
final override fun funDemo() {
super<Base>.funDemo()
super<InterfaceDemo>.funDemo()
}
}
|
密封类
密封类用于代表严格的类结构，值只能是有限集合中的某中类型，不可以是任何其它类型。这就相当于一个枚举类的扩展：枚举值集合的类型是严格限制的，但每个枚举常量只有一个实例，而密封类的子类可以有包含不同状态的多个实例。声明密封类需要在 class 前加一个 sealed 修饰符。密封类可以有子类但必须全部嵌套在密封类声明内部。
|
1
2
3
4
5
6
|
//密封类
sealed class Expr {
class Const(val number: Double) : Expr()
class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
}
|
和Kotlin中的类相关的用法就介绍到这里，文中的完整代码见github，在Kotlin中的面向对象（二）中将会介绍属性、接口等面向对象过程中同样常见的内容。
文章代码下载：helloKotlin-master.rar
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！
原文链接：http://blog.csdn.net/steveyg/article/details/72676481