定义
1.Kotlin 中使用关键字 class 声明类
2.类声明由类名、类头（指定其类型参数、主构造函数等）以及由花括号包围的类体构成
3.类头与类体都是可选的； 如果一个类没有类体，可以省略花括号。
class A {}
class B
构造器
1.在 Kotlin 中的一个类可以有一个主构造函数以及一个或多个次构造函数
2.如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字
3.主构造函数不能包含任何的代码。初始化的代码可以放到以 init 关键字作为前缀的**初始化块（initializer blocks）**中
4.主构造的参数可以在初始化块中使用。它们也可以在类体内声明的属性初始化器中使用
5.主构造函数中声明的属性可以是可变的（var）或只读的（val)
6.初始化块按照它们出现在类体中的顺序执行，与属性初始化器交织在一起
7.在构造函数不具有注释符或者默认的可见性修饰符时，
constructor关键字可以省略8.默认的可见性修饰符时
public。可以省略不写
//表达式
class Person constructor(name: String) {}
// 可以省略 constructor
class Person (name: String) {}
// 类似下面两种情况的，都必须存在constructor关键字，并且在修饰符或者注释符后面。
class Test private Person(name: String){
}
class Test @Inject Person(name: String){
}
class Person (var name: String) {}
// 主构造器的顺序 从上到下
class Person (name: String) {
val lastName: String = "last name $name".also{print("11111")}
init {
print("2222")
}
init {
print("333333")
}
}
次构造函数
1.类也可以声明前缀有 constructor的次构造函数：
2.如果类有一个主构造函数，每个次构造函数需要委托给主构造函数， 可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用 this 关键字
3.初始化块中的代码实际上会成为主构造函数的一部分。委托给主构造函数会作为次构造函数的第一条语句，因此所有初始化块中的代码都会在次构造函数体之前执行。即使该类没有主构造函数，这种委托仍会隐式发生，并且仍会执行初始化块
4.如果一个非抽象类没有声明任何（主或次）构造函数，它会有一个生成的不带参数的主构造函数。构造函数的可见性是 public。如果你不希望你的类有一个公有构造函数，你需要声明一个带有非默认可见性的空的主构造函数
//表达式
class A {
init() {
print("11111")
}
constructor(){
print("22222")
}
}
class A (a: String) {
constructor(a: String, b: String): this(a){
}
}
实例
1.注意 Kotlin 并没有 new 关键字
2.要创建一个类的实例，我们就像普通函数一样调用构造函数
val a = A()
val a = A("name")
类成员
类可以包含：
- [构造函数与初始化块]
- [函数]
- [属性]
- [嵌套类与内部类]
- [对象声明]
class A(a: Int) {
init () {
}
constructor(){
}
//属性
val aa = "aa"
//函数
fun show(str: String): String {
return "2222"
}
// 内部类
}
继承
1.在 Kotlin 中所有类都有一个共同的超类
Any，这对于没有超类型声明的类是默认超类2.要声明一个显式的超类型，我们把类型放到类头的冒号之后
3.如果派生类有一个主构造函数，其基类型可以（并且必须） 用基类的主构造函数参数就地初始化
4.如果派生类没有主构造函数，那么每个次构造函数必须使用 super 关键字初始化其基类型，或委托给另一个构造函数做到这一点
5.定义继承类的关键字为：
open。不管是类、还是成员都需要使用open关键字
open class 类名{
...
open var/val 属性名 = 属性值
...
open fun 函数名()
...
}
class A // 从 Any 隐式继承
// open 关键字
open class Base(p: Int)
class Derived(p: Int) : Base(p)
// super 关键字
class MyView : View {
constructor(ctx: Context) : super(ctx)
constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}
覆盖方法和属性
1.我们之前提到过，Kotlin 力求清晰显式。与 Java 不同，Kotlin 对于可覆盖的成员（我们称之为开放）以及覆盖后的成员需要显式修饰符
2.函数上必须加上 override 修饰符
3.函数没有标注 open ，那么子类中不允许定义相同签名的函数
4.final 类（即没有 open 的类）的成员上不起作用
5.标记为 override 的成员本身是开放的
6.属性在超类中声明然后在派生类中重新声明的属性必须以 override 开头
7.你也可以用一个
var属性覆盖一个val属性，但反之则不行
// 方法覆盖
open class Base {
open fun v() { ... }
fun nv() { ... }
}
class Derived() : Base() {
override fun v() { ... }
}
// 属性覆盖
open class Foo {
open val x: Int get() { …… }
}
class Bar1 : Foo() {
override val x: Int = ……
}
super
1.派生类中的代码可以使用 super 关键字调用其超类的函数与属性访问器的实现
2.在一个内部类中访问外部类的超类，可以通过由外部类名限定的 super 关键字来实现：
super@Outer3.如果一个类从它的直接超类继承相同成员的多个实现， 它必须覆盖这个成员并提供其自己的实现（也许用继承来的其中之一）为了表示采用从哪个超类型继承的实现，我们使用由尖括号中超类型名限定的 super，如
super<Base>
open class Foo {
open fun f() { println("Foo.f()") }
open val x: Int get() = 1
}
class Bar : Foo() {
override fun f() {
super.f()
println("Bar.f()")
}
override val x: Int get() = super.x + 1
}
// 覆盖
open class A {
open fun f() { print("A") }
fun a() { print("a") }
}
interface B {
fun f() { print("B") } // 接口成员默认就是“open”的
fun b() { print("b") }
}
class C() : A(), B {
// 编译器要求覆盖 f()：
override fun f() {
super<A>.f() // 调用 A.f()
super<B>.f() // 调用 B.f()
}
}
抽象类
1.类以及其中的某些成员可以声明为 abstract。 抽象成员在本类中可以不用实现
2.抽象类，可以理解为类定义了一个模板。所有的子类都是根据这个模板是填充自己的代码
3.抽象可以分为抽象类、抽象函数、抽象属性
4.抽象类不能直接被实例化
5.其抽象了类的子类必须全部重写带
abstract修饰的属性和方法6.抽象成员只有定义，没有实现。都有
abstract修饰符修饰7.只能继承一个抽象类
open class Base {
open fun f() {}
}
abstract class Derived : Base() {
val a: String = "aaaa" // 属性
fun test() { // 函数
}
abstract var name : String // 抽象属性
override abstract fun f() // 覆写父类的方法
abstract class Name(){} // 嵌套抽象类
}
嵌套类
- 调用嵌套类的属性或方法的格式为：
外部类.嵌套类().嵌套类方法/属性。在调用的时候嵌套类是需要实例化的。- 嵌套类可以访问外部类的属性和成员
class A{ // 外部类
val name = 1
class B { // 嵌套类
fun init(){
println("执行了init方法")
}
}
}
内部类
1.声明一个内部类使用
inner关键字。2.调用内部类的属性或方法的格式为：
外部类().内部类().内部类方法/属性。在调用的时候外部类、内部类都是需要实例化的3.内部类可以访问外部类的属性和成员
class A{ // 外部类
val name = 1
inner class B{ // 嵌套内部类
val name = "B"
fun init(){
println("我是内部类")
}
}
}
