Kotlin知识——类

基础语法

构建一个简单的 Person 类，示例如下：

calss Person(val name: String， var isMarried: Boolean)

此时 Person 类有一个可读属性 name 和一个可写属性 isMarried，在声明属性的时候会自动为其创建访问器（只读属性有一个 getter，可写属性有 getter 和 setter）
当然也可以自定义访问器，示例如下：

calss Rectangle(val height: Int, val width: Int) {
	val isSquare: Boolean
		get() {
			return height == width
		}
}

也可以修改访问器的可见性，示例如下：

class LengthCounter{
	//此时不能在类的外部修改这个属性
	var counter: Int = 0
		private set
	
	fun addWord(word: String){
		counter += word.length
	}
}

构造函数

主构造方法

• 定义一个包含主构造方法的类的示例如下：

calss Person(val name: String， var isMarried: Boolean)

• 括号中的即为主构造方法，当然也可以为参数设置默认值，示例如下;

calss Person(val name: String， var isMarried: Boolean = false)

• 也可以把主构造方法设置为私有，示例如下：

calss Secretive private constructor() {}

• 主构造方法中不能包含代码语句，因此初始化代码可以放到 init 初始化块中，示例如下：

calss Person(var name: String?){
	init{
		//初始化块中可以使用主构造方法中的参数（name）
		print("my name is $name")
	}
}

注：如果同时包含 init 初始化块和从构造函数，init 初始化块会优于从构造函数执行

从构造方法

calss View{
	constructor(ctx: Context){...}
	
	constructor(ctx: Context, attr: AttributeSet){...}
}

数据类

通过为类添加 data 修饰符可以将其声明为数据类，数据类会自动为我们重写以下所有标准 Java 方法：

• equals 用来比较实例
• hashCode 用来作为例如 HashMap 这种基于哈希容器的键
• toString 用来为类生成按声明顺序排列的所有字段的字符串表达形式
  构造数据类的示例如下：

data calss Person(val name: String， var isMarried: Boolean)

类委托

通过使用 by 关键字可以实现类委托机制：创建一个新类，实现与原始类一样的接口并将原来的类的实例作为一个字段保存，与原始类拥有相同行为的方法不用被修改，只需要转发到原始类的实例。示例如下：
不使用委托机制时，构建一个 Collection 的接口的装饰器，不修改任何行为：

class DelegatingCollection<T>: Collection<T>{
	private val innerList = arrayListOf<T>()

	override val size: Int get() = innerList.size
	override fun empty(): Boolean = innerList.empty()
	override fun contains(element: T): Boolean = innerList.contains(element)
	override fun iterator(): Iterator<T> = innerList.iterator()
	override fun containsAll(elements: Collection<T>): Boolean = innerList.containsAll(elements)
}

在使用类委托机制时其代码如下：

class DelegatingCollection<T>(
	innerList: Collection<T> = ArrayList<T>()
): Collection<T> by innerList {}

创建实例

Kotlin 中调用构造方法不需要 new 关键字，创建一个类的示例如下：

calss Person(val name: String， var isMarried: Boolean)
val person = Person("Bob", true)

类中的访问修饰符

修饰符	相关成员	评注
final（默认）	不能被重写	类中成员默认使用
open	可以被重写	需要明确的表明
abstract	必须被重写	只能在抽象类中使用；抽象成员不能持有
override	重写父类或接口中的成员	如果没有使用 final 表明，重写的成员默认是开放的

注：当一个类允许被继承，或者一个方法允许被重写时都需要显示地用 open 修饰符修饰。

可见性修饰符

修饰符	类成员	顶层声明
public（默认）	所有地方可见	所有地方可见
internal	模块中可见	模块中可见
protected	子类中可见	——
private	类中可见	文件中可见

注：internal 修饰符在字节码中会变成 public。

内部类

类 A 在另一个类 B 中声明	在 Java 中	在 Kotlin 中
嵌套类（不储存外部类的引用）	static class A	class A
内部类（储存外部类的引用）	class A	inner class A

Kotlin 中内部类引用外部类实例需要使用 this@Outer，示例如下：

class Outer{
	inner class Inner{
		fun getOuterReference(): Outer = this@Outer
	}
}

枚举类

• 声明一个简单的枚举类：

enum class Color {
	RED, GREEN, BLUE
}

• 声明一个带属性值的枚举类：

enum class Color(val r: Int, val g: Int, val b: Int) {
	RED(255, 0, 0), GREEN(0, 255, 0), BLUE(0, 0, 255);

	//定义一个方法
	fun rgb() = (r * 256 + g) * 256 + b
}

• 使用 when 来选择正确的枚举值

fun getColor(color: Color) = 
	when (color) {
		Color.RED -> "Richard"
		Color.GREEN -> "Gave"
		Color.BLUE -> "Battle"
	}

注：when 是一个有返回值的表达式。

抽象类

声明一个抽象类的示例如下：

abstract class Animated{
	//抽象函数，必须被子类重写
	abstract fun animate()

	//用 open 修饰可以被重写
	open fun stopAnimating(){}

	//没有被 open 修饰，不可用于重写
	fun animateTwice(){}
}

单例类

使用 object 关键字可以在定义一个类的同事创建一个实例，示例如下：

object Single{
	...
}