Android Kotlin（1）之《类》
大家好！这是我第三篇文章，之前说Toast例子先欠着哈，等我发完Kotlin系列后继续更新，最后有我的源码，欢迎关注和下载，源码也会逐渐完善。这也是我学习Kotlin后写的第一篇文章，在网上查找很多资料和自己也实验很多，后续我会陆续发布相应Kotlin其他文章，欢迎大家多多支持，我就不介绍相关环境搭建了，这个环境搭建还是很简单的，Android studio有插件支持的，只需要配置好Gradle就好，我就直接正对Kotlin进入使用介绍，第一个要介绍的就是《类》。当然我写的也许不全面，你也可以提出遗漏的，我们大家一起补充完善。
类和继承
1、类（Class）
java类文件：XXX.java
Kotlin类文件：XXX.kt
Kotlin 中使用关键字 class 声明类
class ClassGoKotlin {
}
类声明由类名、类头（指定其类型参数、主构造函数等）和由大括号包围的类体构成。类头和类体都是可选的； 如果一个类没有类体，可以省略花括号。
class ClassGoKotlin
与java区别：都是Class申明，只是java默认是有public，当然java也可以省去public，但是java不可以像Kotlin去掉类的“{}”大括号，主要区别在于构造函数和初始化，如下：
构造函数
在 Kotlin 中的一个类可以有一个主构造函数和一个或多个次构造函数。主构造函数是类头的一部分：它跟在类名（和可选的类型参数）后。
class ClassGoKotlin constructor(param1 : String){
}
如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字。
class ClassGoKotlin(param1 : String) {
}
主构造函数特性：
1、主构造函数不能包含任何的代码，初始化在init关键字里作为前缀的初始化模块里，例如：
class ClassGoKotlin(param0 : String) {
var param1 : String? = param0.toUpperCase()
init {
//主构造函数初始化
this.param1 = param0.toUpperCase()
}
2、主构造函数可以声明属性以及初始化属性，在主构造函数参数前家var或者val就是声明属性，在参数后面可以附上默认的初始值，例如：
class ClassGoKotlin(var param0 : String, var param00 : String = "赋默认初始值") {
var param1 : String? = param0.toUpperCase()
init {
//主构造函数初始化
this.param1 = param0.toUpperCase()
}
特别说明：赋有默认值的参数，在调用该类的时候可以不填写该参数，不填写该参数，Kotlin会自动按照默认参数执行
3、如果构造函数有注解或可见性修饰符，这个 constructor 关键字是必需的，并且这些修饰符在它前面，如果没有注解或者可见性修饰符，主构造函数constructor 可以省略，例如：
class Customer public @Inject ClassGoKotlin(name: String) { …… }
4、唯一性，一个类里只有一个主构造函数，
次构造函数特性：
1、次构造函数必须有constructor前缀声明
2、如果类有一个主构造函数，每个次构造函数需要委托给主构造函数。委托到同一个类的另一个构造函数用 this 关键字即可，例如：
class ClassGoKotlin(param0 : String,var param00 : String = "赋默认初始值") {
var param1 : String? = param0.toUpperCase()
init {
//主构造函数初始化
this.param1 = param0.toUpperCase()
}
//每个次构造函数需要委托给主构造函数
constructor(param1: String,classGoKotlin: ClassGoKotlin) : this(param1){
this.param1 = param1.toUpperCase()
}
}
3、可以直接委托或者通过别的次构造函数间接委托，例如：
//每个次构造函数需要委托给主构造函数
constructor(param1: String,classGoKotlin: ClassGoKotlin) : this(param1){
this.param1 = param1.toUpperCase()
}
//每个次构造函数也可以委托给其他次造函数
constructor(param1: String, param2 : String , classGoKotlin: ClassGoKotlin) : this(param1,classGoKotlin) {
this.param2 = param2
}
特别说明：如果一个非抽象类没有声明任何（主或次）构造函数，它会有一个生成的不带参数的主构造函数。如果你不想你的类有一个公有的构造函数，你可以声明一个私有的主函数
class ClassGoKotlin private constructor () {
}
与java区别：java是不允许在Class这行里添加参数，java类默认是default(默认访问模式，只允许在同一个包中进行访问)，Kotlin默认是public(公有的)；java里不存在主次构造函数，但是委托还是有的，也是this实现的在代码里实现，例如：
//java
public class ClassGoJava{
public ClassGoJava(){
}
public ClassGoJava(String param1){
this();
}
public ClassGoJava(String param1, String param2){
this(param1);
}
}
创建类实例
直接上例子：
class ClassGoKotlin(param0 : String,var param00 : String = "赋默认初始值") {
var param1 : String? = param0.toUpperCase()
var param2 : String? = null
var param3 : String? = null
init {
//主构造函数初始化
this.param1 = param0.toUpperCase()
}
//每个次构造函数需要委托给主构造函数
constructor(param1: String,classGoKotlin: ClassGoKotlin) : this(param1){
this.param1 = param1.toUpperCase()
}
//每个次构造函数也可以委托给其他次造函数
constructor(param1: String, param2 : String , classGoKotlin: ClassGoKotlin) : this(param1,classGoKotlin) {
this.param2 = param2
}
constructor(param1: String, param2 : String ,param3 : String , classGoKotlin: ClassGoKotlin) : this(param1,param2,classGoKotlin){
this.param2 = param2
}
constructor(param1: String, param2 : String ,param3 : String ,param4 : String, classGoKotlin: ClassGoKotlin) : this(param1,param2,param3,classGoKotlin){
this.param3 = param3
}
}
创建：
var classGoKotlin0 = ClassGoKotlin("0")
var classGoKotlin00 = ClassGoKotlin("0","可有可以无参数，看需求")
var classGoKotlin1 = ClassGoKotlin("1", "2","4",ClassGoKotlin("0"))
var classGoKotlin2 = ClassGoKotlin("1", "2","3","4",ClassGoKotlin("0"))
var classGoKotlin3 = ClassGoKotlin("1", "2","3","4",ClassGoKotlin("1","2",ClassGoKotlin("0")))
...等等，灵活使用，建议还是不要太复杂，前三个就好，委托多了容易乱
与java区别：Kotlin没有new关键字，比Java更加简洁
2、继承
在 Kotlin 中所有类都有一个共同的超类 Any，这对于没有超类型声明的类是默认超类：
class Example // 从 Any 隐式继承
被继承的类前必须要加open关键字，才被允许继承。如果该类有一个主构造函数，其基类型可以（并且必须） 用（基类型的）主构造函数参数就地初始化例如：
open class ClassGoKotlin(param0 : String,var param00 : String = "赋默认初始值") {}
class ClassGoKotlinEx : ClassGoKotlin(""){}
如果类没有主构造函数，那么每个次构造函数必须使用 super 关键字初始化其基类型，或委托给另一个构造函数做到这一点。 注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数：
class ClassGoKotlinEx : ClassGoKotlin{
//必须至少要有一个次构造函数，否则要在上面继承的时候就ClassGoKotlin("必须实现")
constructor(param0 : String) : super(param0){
//这个就是ClassGoKotlinEx("")，因为没有主构造函数，这个就类似主构造函数
}
constructor() : super("这里固定好值"){
//这个就是ClassGoKotlinEx("")，因为没有主构造函数，这个就类似主构造函数
}
//这样就可以传递参数到继承的类里了
constructor(param1 : String, classGoKotlinEx: ClassGoKotlinEx) : super(param1) {
//经过我实际测试，这个次构造函数必须基于上面的构造函数才可以实现，否则ClassGoKotlinEx("", ClassGoKotlinEx());这样是不能调用的
}
//这个和上面第二个实际上是一样的，没有区别，可以删除
constructor(classGoKotlinEx: ClassGoKotlinEx) : this(){
}
}
使用上面的基础类：
//传入自定义数据
var a = ClassGoKotlinEx("测试", ClassGoKotlinEx());
//不传入数据，使用ClassGoKotlinEx类里设好的固定数据
var b = ClassGoKotlinEx();
覆盖方法
Kotlin类覆盖继承类的方法，这里要求必须清晰，所有被继承的类如果需要被覆写，需要加上open关键字标识，就和需要继承的类需要加上open；所有被重写的方法需要override关键字标识，这样我们就非常的清晰那些类可以基础，那些方法可以覆盖，增强的可可读性，比java可读性强，例如：
//被继承类里声明方法
fun v(){}
open fun nv(){}
//继承类里覆盖方法
override fun nv(){}
Kotlin中，如果你想已经继承类的覆盖发放不在被再次覆盖的话，你只需要在覆盖方法前加final关键字即可，例如：
final override fun nv(){}
覆盖属性
和覆盖方法一样。
特别注意的是：
可以用一个 var 属性覆盖一个 val 属性，但反之则不行。这是允许的，因为一个 val 属性本质上声明了一个 getter 方法，而将其覆盖为 var 只是在子类中额外声明一个 setter 方法。
你可以在主构造函数中使用 override 关键字作为属性声明的一部分
覆盖规则
在 Kotlin 中，实现继承由下述规则规定：如果一个类从它的直接超类继承相同成员的多个实现， 它必须覆盖这个成员并提供其自己的实现（也许用继承来的其中之一）。 为了表示采用从哪个超类型继承的实现，我们使用由尖括号中超类型名限定的 super，如 super<Base>：
//类继承，方法覆盖规则
open class A {
open fun f() {}
fun a() {}
}
interface B {
fun f() {} // 接口成员默认就是“open”的
fun b() {}
}
class C() : A(), B {
// 编译器要求覆盖 f()：
override fun f() {
super<A>.f() // 调用 A.f()
super<B>.f() // 调用 B.f()
}
}
同时继承 A 和 B 没问题，并且 a() 和 b() 也没问题因为 C 只继承了每个函数的一个实现。 但是 f() 由 C 继承了两个实现，所以我们必须在 C 中覆盖 f() 并且提供我们自己的实现来消除歧义。
抽象类
类和其中的某些成员可以声明为 abstract。 抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用 open 标注一个抽象类或者函数——因为这不言而喻。+
我们可以用一个抽象成员覆盖一个非抽象的开放成员
//抽象类
open class Base {
open fun f() {}
}
abstract class Derived : Base() {
override abstract fun f()
}
同伴对象（Companion Object）
Koltin没有静态方法（static method），可以使用同伴对象代替，就实现了类似java静态方法的功能，只是这里同伴对象关键字大括号内所有方法都是同伴对象，类似java静态方法，例如：
//同伴对象（Companion Object）
companion object {
//companion object静态方法集合关键字
fun Test1(): String? {
return ""
}
}
封闭类
封闭类用来表示对类阶层的限制，可以限定一个值只允许是某些指定的类型之一，而不允许是其他类型。
要声明一个封闭类，需要将 sealed 修饰符放在类名之前，封闭类可以有子类，但所有的子类声明明都必须嵌套在封闭类的声明部分之内。
sealed class Expr {
class Const(val number: Double) : Expr()
class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
}
从封闭类的子类再继承的子类（间接继承者）可以放在任何地方，不必在封闭类的声明部分之内。
好了，第一期就到这了，谢谢大家的观赏，敬请期待下一期《函数和Lambda表达式》
源码下载
这里源码会随着后面发布的Kotlin逐渐完善
