02kotlin构造函数与接口
kotlin构造函数与接口
1.构造函数
1.constructor
constructor，有private等修饰时，需要
/**
* 主构造函数
* 一个类对象中，属性如果时val修饰，只生成
*/
class Person constructor(firstName: String) { /*……*/ }
/**
* 简化写法，如果没有private或者注解修饰则可以省略constructor关键字
*/
class Person2(firstName: String) {}
class Person3 private constructor(firstName: String) {
var firstName: String = firstName
}
2.主构造函数
所谓的主构造函数，就是头上的Person4
注意，init一定会执行
/**
* 主构造函数不能包含任何的代码。初始化的代码可以放到以 init 关键字作为前缀的初始化块（initializer
* 在实例初始化期间，初始化块按照它们出现在类体中的顺序执行，与属性初始化器交织在一起：
*/
class Person4(firstName: String, age: Int) {
var firstName: String
var age: Int
init {
this.firstName = firstName
this.age = age
}
}
简化写法
/**
* 请注意，主构造的参数可以在初始化块中使用。它们也可以在类体内声明的属性初始化器中使用
*/
class Person5 private constructor(firstName: String) {
var firstName: String = firstName
}
更简洁写法
/**
* 更简洁的写法
*/
class Person6 private constructor(val firstName: String, var age: Int) {}
2.次构造函数
/**
* 如果类中有主构造函数和次构造函数，则次构造函数一定要实现主构造函数
*/
class School2(val firstName: String, var age: Int) {
var studentNum: Int = 0
constructor(firstName: String, age: Int, studentNum: Int) : this(firstName, age) {
this.studentNum = studentNum
}
}
/**
* 多个次构造函数时，也可以实现同类中其他次构造函数，间接地实现主构造函数
*/
class School3(val firstName: String, var age: Int) {
var studentNum: Int = 0
var name: String? = null
constructor(firstName: String, age: Int, studentNum: Int) : this(firstName, age) {
this.studentNum = studentNum
}
constructor(firstName: String, age: Int, studentNum: Int, name: String) : this(firstName, age, studentNum) {
this.name = name;
}
}
3.继承
kotlin中，如果表达一个类或者函数可以被继承，需要open关键字
如果向禁止继承的超类，在被继承函数，可以用final
1.方式1
open class Base(p: Int)
/**
* 继承
* 需声明一个显式的超类型，请在类头中把超类型放到冒号之后
*/
class Derived(p: Int) : Base(p)
2.方式2
/**
* 默认情况下，Kotlin 类是最终（final）的：它们不能被继承。 要使一个类可继承，请用 open 关键字标记它。
* 函数也一样，默认也是final标记地
*/
open class BaseTeacher(name: String) {
open fun teach(lesson: String) {
}
fun eat(thing: String) {
}
}
/**
* 继承 二者必须实现一个
* 1.没有构造方法时,继承需要class()形式
* 2当父类有成员时，子类可以通过constructor来实现，但必须super去实现父类地构造函数
*/
class MathTeacher : BaseTeacher {//类似接口，但不是接口
var name: String? = null
constructor(name: String) : super(name) {
this.name = name
}
override fun teach(lesson: String) {
super.teach(lesson)
}
}
3.禁止二次覆盖
/**
* 如果想禁止二次被覆盖，可以在前面加上final关键字
*/
class Circle() : Shape() {
final override fun draw() { /*……*/
}
}
4.属性覆盖
kotlin中，属性覆盖也需要用open
1.覆盖属性
open class Shape2 {
open val vertexCount: Int = 0
open val height: Int = 2
open val width: Int = 3
open var length: Int = 5;
}
/**
* 可以用一个 var 属性覆盖一个 val 属性，但反之则不行。
* 这是允许的，因为一个 val 属性本质上声明了一个 get 方法，
* 而将其覆盖为 var 只是在子类中额外声明一个 set 方法。
* java中没有属性继承的方式,但实际,也是覆盖了
*/
class Rectangle : Shape2() {
override val vertexCount = 4
override val height: Int
get() = super.height
// override val height:Int = 4 // 可以覆盖
override var width: Int = 10
// override val length:Int = 2 // 不能将var变成val
}
2.获取父类属性
/**
* 派生类中的代码可以使用 super 关键字调用其超类的函数与属性访问器的实现：
*/
open class Rectangle2 {
open fun draw() {
println("Drawing a rectangle")
}
val borderColor: String get() = "black"
}
class FilledRectangle : Rectangle2() {
override fun draw() {
super.draw()
println("Filling the rectangle")
}
val fillColor: String get() = super.borderColor
}
5.内部类访问外部类
package day2Class
/**
* 内部类与java本质时一样的,public final class Filler,非静态类
* 一个内部类中访问外部类的超类，可以通过由外部类名限定的 super 关键字来实现
*/
class FilledRectangle2 : Rectangle2() {
override fun draw() {
println("你好")
}
inner class Filler {
fun fill() {
println("Filling")
}
fun drawAndFill() {
super@FilledRectangle2.draw() // 调用 Rectangle 的 draw() 实现而不是FilledRectangle2的draw方法
fill()
draw()//调用FilledRectangle2的draw
println("Drawn a filled rectangle with color ${super@FilledRectangle2.borderColor}") // 使用 Rectangle 所实现的 borderColor 的 get()
}
}
}
fun main(args: Array<String>) {
var filler2: FilledRectangle2.Filler = FilledRectangle2().Filler()
println(filler2.drawAndFill())
}
6.覆盖规则
package day2Class
/**
* 可以同时继承 Rectangle 与 Polygon， 但是二者都有各自的 draw() 实现，
* 所以我们必须在 Square 中覆盖 draw()， 并提供其自身的实现以消除歧义。
*/
open class Rectangle3 {
open fun draw() { /* …… */
}
}
interface Polygon3 {
fun draw() { /* …… */
} // 接口成员默认就是“open”的
}
class Square() : Rectangle3(), Polygon3 {
// 编译器要求覆盖 draw()：
override fun draw() {
super<Rectangle3>.draw() // 调用 Rectangle.draw()
super<Polygon3>.draw() // 调用 Polygon.draw()
}
}
7.抽象类
继承抽象方法时,不需要open和override关键字
package day2Class
open class Polygon4 {
open fun draw() {}
}
/**
* 抽象
*/
abstract class Rectangle4 : Polygon4() {
abstract override fun draw()
}
/**
* 继承抽象方法时,不需要open和override关键字
*/
class Rectangle5 : Rectangle4() {
override fun draw() {
TODO("Not yet implemented")
}
}
abstract class Rectangle10 {
abstract fun draw()
}
fun main(args: Array<String>) {
//匿名类对象
var r: Rectangle10 = object : Rectangle10() {
override fun draw() {
TODO("Not yet implemented")
}
}
}
8.属性声明
1.var和val
/**
* var字段,默认会提供setter和getter方法
* val字段,默认会提供getter方法
*/
class Address {
var name: String = "Holmes, Sherlock"
var street: String = "Baker"
var city: String = "London"
var state: String? = null // 允许空
var zip: String = "123456"
}
注意下面：
/**
* data关键字,默认
* 所有属性的 getters （对于 var 定义的还有 setters）
* equals()
* hashCode()
* toString()
* copy()
* 所有属性的 component1()、 component2()……等等
*
* 注意,不要去实现已经实现的方法,copy hashCode equals
*/
data class Address2(var name: String, var age: Int) {
// fun copy(name: String, age: Int) {
//
// }
}
2.属性幕后字段field
field就是counter.
/**
* 幕后字段 field
* getter和setter方法
* field 关键字,代表当前属性的counter的值,只能使用在幕后字段中, 其他地方不能使用
*/
class Rule {
var counter = 0 // 注意：这个初始器直接为幕后字段赋值
set(value:Int) {
if (value >= 0) field = value
}
get() {
return if (field >= 0) field + 1 else 1
}
}
9.延迟初始化
1.lateinit
lateinit，是延迟初始化属性，第一次使用之前需要赋值
/**
* 使用注意
* 在var之前添加lateinit，然后选择你想要的时候，初始化，但是有以下需要注意的地方：
* lateinit只能修饰变量var，不能修饰常量val
* lateinit不能对可空类型使用
* lateinit不能对java基本类型使用，例如：Double、Int、Long等
* 在调用lateinit修饰的变量时，如果变量还没有初始化，则会抛出未初始化异常，报错
*/
class Late {
lateinit var a1: String
fun test() {
if (!this::a1.isInitialized) {
a1 = "test1"
}
// 初始化
println(a1)
}
}
2.lazy 延迟初始化
lazy是延迟初始化，懒加载而且单例
val a2: String by lazy {
println("开始初始化")
// 初始化的值
"sss"
}
10.接口
1.接口可以有非抽象函数
/**
* 接口中属性要么是抽象的，要么提供访问器的实现
* JDK1.8中,接口中无需全部是抽象函数,java中可以写上具体属性数据,或者方法,添加关键字default,
* 说白了,接口和抽象类型几乎等价,甚至有的语言去掉了接口的概念,统一抽象类
*
*/
interface MyInterface2 {
val prop: Int // 抽象的
val propertyWithImplementation: String
get() = "foo"
fun foo() {
print(prop)
}
}
class Child2 : MyInterface2 {
override val prop: Int = 29
}
2.接口属性被覆盖
接口提供属性时，从而既提供基类型成员的实现也声明新的函数与属性
/**
* 个接口可以从其他接口派生，从而既提供基类型成员的实现也声明新的函数与属性
* 实现接口时,就无需实现,默认会添加接口中的属性
* 当作抽象类去理解更容易
*/
interface Person12 : Named {
val firstName: String
val lastName: String
override val name: String get() = "$firstName $lastName"
}
data class Employee(
// 不必实现“name”
override val firstName: String,
override val lastName: String,
val position: Int
) : Person12
fun main(args: Array<String>) {
var employee: Employee = Employee("1", "2", 3)
println(employee.name)
}
11.SAM函数式编程
SAM函数编程，简单就是接口如同函数一样，省略，java1.8之后lamada匿名接口
package day2Class
import org.omg.CORBA.Object
/**
* 只有一个抽象方法的接口称为函数式接口或 SAM（单一抽象方法）接口。
* 函数式接口可以有多个非抽象成员，但只能有一个抽象成员。
* 可以用 fun 修饰符在 Kotlin 中声明一个函数式接口，1.4新特性，
* SAM函数编程
*/
interface KRunnable {
fun invoke()
}
fun interface MyRun {
fun run()
}
fun interface MyRun2 {
fun run(a: Int)
}
fun runAction(a: MyRun) = a.run()
fun runAction2(k: () -> Unit) = k
fun runAction3(a: Int, b: MyRun2) = b.run(a)
fun String.runAction4(n: (String) -> Unit) = n(this)
interface IntPredicate {
fun accept(i: Int): Boolean
}
fun setIntPredicate(a: IntPredicate) {
}
fun main(args: Array<String>) {
/**
* 匿名内部类接口
*/
val isEven: IntPredicate = object : IntPredicate {
override fun accept(i: Int): Boolean {
return i % 2 == 0
}
}
/**
* 通过 lambda 表达式创建一个实例
* 1.4新特性，当前编译器不知道什么原因不能使用（已更新到1，4-21）
*/
var isEven2 = object : IntPredicate {
override fun accept(i: Int): Boolean {
return i % 2 == 0
}
}
runAction(object : MyRun {
override fun run() {
println("你好")
}
})
runAction {
//实现接口方法
println("你好")
}
runAction2 {
}
runAction3(2) { x ->
println(x.plus(2))
}
var str = "xxxx"
str.runAction4 {
println(it)
}
}
12.可见性修饰符
/**
* 如果你不指定任何可见性修饰符，默认为 public，这意味着你的声明将随处可见；
如果你声明为 private，它只会在声明它的文件内可见；
如果你声明为 internal，它会在相同模块内随处可见；
protected 不适用于顶层声明。
*/
13.静态方法
在class外的都是静态属性，等价于java中添加static
package day2Class
fun method() {//java static fun method(){}
}
fun method2() {
}
fun method3() {
}
实现接口方法
println(“你好”)
}
runAction2 {
}
runAction3(2) { x ->
println(x.plus(2))
}
var str = "xxxx"
str.runAction4 {
println(it)
}
}
### 12.可见性修饰符
```kotlin
/**
* 如果你不指定任何可见性修饰符，默认为 public，这意味着你的声明将随处可见；
如果你声明为 private，它只会在声明它的文件内可见；
如果你声明为 internal，它会在相同模块内随处可见；
protected 不适用于顶层声明。
*/
13.静态方法
在class外的都是静态属性，等价于java中添加static
package day2Class
fun method() {//java static fun method(){}
}
fun method2() {
}
fun method3() {
}