学习kotlin第七天_类与继承、属性与字段

傷城~ 2022-06-15 10:17 226阅读 0赞

不行，按这个速度，等我学完黄花菜都凉了，我记得当初培训的时候一个周就搞定了java，这类似的语言不能耽搁太久呀。

坑1、类声明由类名、类头和花括号组成

**class** Person **constructor**(firstName: String) \{   
\}

坑2、如果主构造函数没有注解和可见性修饰符，可以省略constructor关键字，如果没有类体，可以省略花括号

坑3、主构造函数中不包含任何代码，用init关键字声明一段代码块用于初始化。init代码块位于类体中，主构造参数可以给init代码块使用，也可以给类体中声明属性初始化时使用。

坑4、次构造函数也用constructor声明。

**class** Person \{   
    **constructor**(parent: Person) \{   
        parent.children.add(**this**)  
    \}  
\}

次构造函数如果需要委托给同一个类的另一个构造函数，可以通过this实现。

**class** Person(**val name**: String) \{   
    **constructor**(name: String, parent: Person) : **this**(name) \{   
        parent.children.add(**this**)  
    \}  
\}

哪位亲能帮我解释一下啥子叫委托？谢谢！

坑5、非抽象类在没声明构造函数的情况下会生成一个无参可见构造函数。如果不希望它存在，可声明一个私有的主构造函数。

**class** DontCreateMe **private constructor** () \{   
\}

坑6、创建类的实例只需要直接调用构造函数即可，没有new关键字。

**val** *invoice* = Invoice()  
**val** *customer* = Customer(**"hello"**)

坑7、和java类似，kotlin的类中可以包括构造函数、初始化模块、函数、属性、嵌套类和内部类、对象声明。

我理解的嵌套类和内部类的区别就是嵌套类不能访问“外部类”成员。对象声明使用object关键字，类似于变量声明，它不是一个表达式，不能在赋值语句的右边。对象声明不能在函数中。（先混个脸熟，后面再详细了解...真不明白这文档是按什么顺序编的）

坑8、kotlin中有一个共同的超类Any。Any和java中的object不能划等号，Any类中除了equals 、hashCode、toString没有任何成员，如果需要用到java.lang.Object的其它成员，得用到扩展函数。

坑9、类的继承的声明使用“:”并且可以按需要传入参数。

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

open关键字表示允许其它类从该类继承。

如果没有主构造函数，每个次构造函数都必须使用super关键字进行初始化

**open class** Base \{   
    **constructor**(i: Int)  
    **constructor**(i: Int, s: String)  
\}  
**class** MyView : Base \{   
    **constructor**(i: Int) : **super**(i)  
    **constructor**(i: Int, s: String) : **super**(i, s)  
\}

坑10、如果父类的函数未标注open，该函数不能被继承，子类从父类继承的方法必须用override标注，否则报错

‘v' hides member of supertype 'Base' and needs 'override' modifie

可通过super关键字调用父类方法。若子类为open类型，可用final关键字防止该方法被“孙子类”重写。  
**open class** Base \{   
    **open fun** v() \{   
        *println*(**"base\_v"**)  
    \}  
    **fun** nv() \{   
        *println*(**"nv"**)  
    \}  
\}  
**open class** Derived() : Base() \{   
    **final override fun** v() \{   
        **super**.nv()  
        *println*(**"Derived\_v"**)  
    \}  
\}  
**fun** main(args: Array<String>) \{   
    **val** dev = Derived();  
    dev.v()  
\}

坑11、属性覆盖和函数的覆盖类似，必须以override开头，可以由具有初始化的或者具有getter方法的属性覆盖。var类型可以覆盖val类型。

**open class** Foo \{   
    **open val x**: Int **get** () \{   
        **return** 5  
    \}  
\}  
**class** Bar1 : Foo() \{   
    **override var x**: Int =3  
\}

坑12、super<父类名或接口名>可用于区分该方法继承自哪个类或接口。若不指定则报错

Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super<Foo>’

**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()  
    *\}  
\}

坑13、抽象类用abstract声明，抽象成员只在本类中声明而不实现。抽象类和抽象方法默认为open。此外抽象成员可以覆盖非抽象开放成员。

**open class** Base \{   
    **open fun** f() \{   
    \}  
\}  
**abstract class** Derived : Base() \{   
    **override abstract fun** f()  
\}

坑14、kotlin中没有静态方法，推荐使用包级函数，也可以声明一个伴生对象，然后使用类名作为限定符进行调用。。。啥子是包级函数嘛？。。。啥子是伴生对象嘛？。。。

坑15、之前学了kotlin局部变量可以先声明再赋值，但类属性必须赋值，可根据需要声明为var类型或val类型。类似java，kotlin类属性的调用通过“类对象.属性名”调用。

**class** Address \{   
    **val name**: String = **"China"  
    var city**: String = **"GuiYang"**  
\}  
  
**fun** main(args: Array<String>) \{   
    **val** address = Address();  
    *println*(address.**name**)  
    *println*(address.**city**)  
\}

坑16、声明属性时，如果类型可以通过初始器或者getter返回值推断，那么可以省略，如val name = "China"。val只读类型没有setter。  
**val** *list*= *listOf*(0,1,2)  
**val** *isThree* **get**() = com.tshouyi.hellokotlin.*list*.**size**== 3 *// 具有类型 Boolean*

坑17、改变访问器的可见性或者对其注解，不需要改变实现则不定义其实现。

**var** *setterVisibility*: String = **"abc"  
    private set** *// 此 setter 是私有的并且有默认实现*  
**var** *setterWithAnnotation*: Any? = **null  
    **@Inject **set** *// 用 Inject 注解此 setter。*Inject.jar*自己去下载。*

*每天都在不断的吐槽这文档有多么坑，但又舍不得放弃，这不，又遇上了连坑...我都没法用自己的话复述接下来这几个概念，幕后字段？幕后属性？编译期常量？惰性初始化属性？覆盖属性？委托属性？。。。只能反复读三遍这一段文档混个脸熟。遇到这一串坑，没心情了。*