Kotlin基础——接口和类

news/2025/2/12 4:04:01/

接口

  • 使用 : 表示继承关系，只能继承一个类，但可以实现多个接口
  • override修饰符表示重写
  • 可以有默认方法，若父类的默认方法冲突，则需要子类重写，使用super<XXX>.xxx()调用某一父类方法
interface Focusable {fun focus()fun show() = println("Focusable")
}class Button : Clickable, Focusable {override fun click() {TODO("Not yet implemented")}override fun focus() {TODO("Not yet implemented")}override fun show() {super<Clickable>.show()super<Focusable>.show()}
}

接口中可以声明域，每个子类都要初始化接口中的域

interface User {val name: String
}class Person(override val name: String) : Userclass Man(val email: String) : User {override val name: Stringget() = email.substringBefore("@")
}class WonMan() : User {override val name: String = "A"
}

接口中也可以使用getter和setter，前提是不引用变量

interface User {val email:Stringval name: Stringget() = email.substringBefore('@')
}

类

bean类

只有数据没有其他代码的对象通常叫做值对象，如JavaBean

public class Person {private String name;private final int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}
}

使用过程如下

Person person = new Person("java", 8);person.setName("kotlin");
System.out.println(person.getName());
System.out.println(person.getAge());

将上述Java复制到代码.kt文件，会触发自动转换（.kt不要求类名和文件名一致，可将多个类放到同一文件，且文件名随意）

在这里插入图片描述

转换后的代码如下，name为var变量（默认带有getter和setter），而age为val变量（只有getter）

class Person(var name: String,val age: Int
)

使用方法如下

val person = Person("java", 8);person.name = "kotlin"
println(person.name)
println(person.age)

如果一个属性可以根据其他属性计算，可使用自定义getter

class Rectangle(val height: Int, val width: Int) {val isSquare: Booleanget() {return height == width}
}

类的重写

类和方法默认都是final的，否则需要使用open修饰符

open class Button {fun click() {}open fun focus() {}
}open class MyButton : Button() {override fun focus() {super.focus()}
}

抽象类

抽象方法默认为open，其他的可有可无

abstract class Button {abstract fun click()open fun focus() {}fun press() {}
}open class MyButton : Button() {override fun click() {TODO("Not yet implemented")}
}

可见性

Kotlin没有包的概念，internal为模块可见性

在这里插入图片描述

  • private类在Java中会被编译成protect
  • internal类或域在Java中会被编译成public

嵌套类

在一个类中声明另一个类

  • 在Java中，未用static声明的类为内部类（含有外部类的隐式引用），加上static的类为嵌套类（不含有外部类的隐式引用）
  • 而Kotlin相反，未用inner声明的类为嵌套类（不含有外部类的隐式引用），加上inner的类为内部类（含有外部类的隐式引用）
  • 嵌套类不能访问外部类的实例，外部类不能访问嵌套类中的private域

在这里插入图片描述

如果需要使用内部类存储序列化信息，需要声明为static转为嵌套类，否则将无法序列化

public class Button {private boolean isClickable;public ButtonState getCurrentState() {return new ButtonState(this.isClickable);}public void restoreState(ButtonState state) {this.isClickable = state.canClick;}public static class ButtonState implements Serializable {private boolean canClick;public ButtonState(boolean isClickable) {this.canClick = isClickable;}}
}

而在Kotlin中正好相反，默认为加上static的嵌套类，如果需要成为内部类则应加上inner修饰符，使用this@Outer访问外部类实例

class Button {private var isClickable = falseval currentState: ButtonStateget() = ButtonState(isClickable)fun restoreState(state: ButtonState) {isClickable = state.canClick}class ButtonState(val canClick: Boolean) : Serializableinner class TestState(val canClick: Boolean) {fun getOuterReference(): Button = this@Button}
}

受限的类继承结构

在如下结构和判断中，若新增了类，但却没有新增分支，会导致其调用走到else

interface Expr
class Num(val value: Int) : Expr
class Sum(val left: Expr, val right: Expr) : Exprfun eval(e: Expr): Int =when (e) {is Num -> {e.value}is Sum -> {eval(e.left) + eval(e.right)}else -> {throw IllegalArgumentException("")}}

通过sealed修饰父类，将子类嵌套在父类，可避免额外的else分支，当新增子类时，when表达式会提示编译失败

sealed class Expr {class Num(val value: Int) : Expr()class Sum(val left: Expr, val right: Expr) : Expr()
}fun eval(e: Expr): Int =when (e) {is Expr.Num -> {e.value}is Expr.Sum -> {eval(e.left) + eval(e.right)}}

主构造函数

class+类名+[修饰符]+constructor()表示主构造函数，init表示初始化语句块

class User private constructor(name: String) {val name: Stringinit {this.name = name}
}

若主构造函数没有注解或可见性修饰符，上述还可以省略为

class User(name: String) {val name: String = name
}

如果参数用相应的构造方法参数来初始化，还可以简化为

class User(val name: String)

也可以加上默认参数，若所有构造方法参数都有默认值，会生成一个额外的不带参数的构造方法来使用所有的默认值

class User(val name: String = "A")

若类有父类，可在继承列表中调用父类构造函数初始化父类，如下传入Person的参数name会被用于构造User

open class User(val name: String)class Person(name: String) : User(name) {}

从构造函数

当需要多个构造函数时，可使用从构造函数

open class User {private val name: Stringprivate var age: Int = 0constructor(name: String) {this.name = name}constructor(name: String, age: Int) {this.name = namethis.age = age}
}

可使用this和super调用自身及父类的构造从构造函数，若类没有主构造函数，那么每个从构造函数必须初始化父类

open class User {private val name: Stringprivate var age: Int = 0constructor(name: String) {this.name = name}constructor(name: String, age: Int) {this.name = namethis.age = age}
}class Person : User {constructor(name: String) : this(name, 18) {}constructor(name: String, age: Int) : super(name, age) {}
}

通过setter/getter访问域的值

在setter中可以通过标识符field读写域的值，getter中只能读

class User(val name: String) {var address: String = "unspecified"set(value: String) {println("""|Address was changed for $name:|"$field" -> "$name"""".trimMargin())field = value}
}

如上，在更新address值时

val user = User("Tom")
user.address = "A Street"

额外打印一些信息

Address was changed for Tom:
"unspecified" -> "Tom"

修改getter/setter可见性

如下，使用内部计数字符个数，不能对其setter

class lengthCounter {var counter: Int = 0private setfun addWord(word: String) {counter += word.length}
}

data类

data修饰符将会为类自动生成通用方法的实现，如toString()、equals()和hashCode()，会将主构造函数中申明的属性纳入考虑

data class Person(val name: String, val age: Int)

Kotlin还为data类新增了copy()，用于返回相同的对象，且互不影响

val A = Person("A", 18)
val B = A.copy();
println(A)
println(B)

通过by实现类委托

在新增对象功能时，原有功能通常会被委托给原对象，这样会出现大量样板代码

class MyCollection<T> : Collection<T> {private val innerList = arrayListOf<T>()override val size: Intget() = innerList.sizeoverride fun contains(element: T): Boolean {return innerList.contains(element)}override fun containsAll(elements: Collection<T>): Boolean {return innerList.containsAll(elements)}override fun isEmpty(): Boolean {return innerList.isEmpty()}override fun iterator(): Iterator<T> {return innerList.iterator()}
}

可通过 by 将接口的实现委托到另一个对象，编译器会自动实现上面的方法，也可自行重写方法

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

object关键字

定义一个类并同上创建一个实例

使用对象声明创建单例

一个对象声明不允许有构造方法，在定义时即被创建，不需要再调用构造方法

object Person {val name: String = ""fun printName() {}
}

可使用对象.属性/方法来访问

Person.name = "A"
Person.printName()

当实现一个接口但不包含任何状态时，通常使用对象声明，如实现一个比较器

object CaseInsensitiveFileComparator : Comparator<File> {override fun compare(p0: File, p1: File): Int {return p0.path.compareTo(p1.path, true)}
}

在使用时可直接传递到接收Comparator的函数

println(CaseInsensitiveFileComparator.compare(File("/User"), File("/user")))val files = listOf(File("/Z"), File("/a"))
println(files.sortedWith(CaseInsensitiveFileComparator))

在Java中被编译成通过静态字段持有单例，则通过如下调用

CaseInsensitiveFileComparator.INSTANCE.compare(File("/User"), File("/user"));

伴生对象代替静态方法和字段

创建工厂方法

class User {val name: Stringconstructor(email: String) {name = email.substringBefore('@')}constructor(id: Int) {name = id.toString()}
}

使用companion定义伴生对象，将上面改成工厂方法实现

class User private constructor(val name: String) {companion object {fun newUserByEmail(email: String) = User(email.substringBefore('@'))fun newUserById(id: Int) = User(id.toString())}
}

在使用时，可通过类名称访问对象的方法和属性

val user1 = User.newUserByEmail("xxx@gmail.com")
val user2 = User.newUserById(123)

伴生对象在Java中通过如下方式调用，若存在名字，则代替Companion

User.Companion.newUserById(123)

实现接口

伴生对象也可实现接口

interface Factory<T> {fun newUserByEmail(email: String): Tfun newUserById(id: Int): T
}class User(val name: String) {companion object : Factory<User> {override fun newUserByEmail(email: String) = User(email.substringBefore('@'))override fun newUserById(id: Int) = User(id.toString())}
}

对于如下方法

fun <T> createUser(factory: Factory<T>) {}

可直接将伴生对象所在类名字当作实现了该接口的对象实例来使用

createUser(User)

扩展函数

当需要定义通过类调用的方法时，可以通过伴生对象函数来实现

class User(val name: String) {companion object {}
}fun User.Companion.printName() {}

使用如下

User.printName()

对象表达式创建匿名对象

object声明匿名对象代替Java的匿名内部类

interface OnClickListener {fun onclick()
}fun setOnClickListener(listener: OnClickListener) {}

对于上面常用的监听事件，可传入声明匿名对象

setOnClickListener(object : OnClickListener {override fun onclick() {}
})

若需要命名则提取出来，匿名对象可以实现多个接口

val listener = object : OnClickListener {override fun onclick() {}
}
setOnClickListener(listener)

http://www.ppmy.cn/news/1212672.html

相关文章

深入理解Java中的OutOfMemoryError（OOM）异常

深入理解Java中的OutOfMemoryError（OOM）异常

导言&#xff1a; 在Java开发中&#xff0c;我们经常会遇到程序抛出OutOfMemoryError异常的情况&#xff0c;这意味着程序在运行时无法继续分配所需的内存。这篇博客将深入探讨Java中的OOM异常&#xff0c;包括异常的种类、常见的引起OOM的原因以及如何诊断和处理这些问题。 1…
阅读更多...
css sprite 的优缺点，使用方法和示例

css sprite 的优缺点，使用方法和示例

CSS Sprite是一种网页图片应用处理方式。 CSS Sprite的原理是将一个网页或者一个模块所用到的零碎的icon整合拼接到一张大图里&#xff0c;再把这张大图作为背景图放入到网页中&#xff0c;当访问该页面时&#xff0c;加载的图片就不会像以前那样一幅一幅地慢慢显示出来了。 …
阅读更多...
Angular 使用教程——基本语法和双向数据绑定

Angular 使用教程——基本语法和双向数据绑定

Angular 是一个应用设计框架与开发平台&#xff0c;旨在创建高效而精致的单页面应用 Angular 是一个基于 TypeScript 构建的开发平台。它包括&#xff1a;一个基于组件的框架&#xff0c;用于构建可伸缩的 Web 应用&#xff0c;一组完美集成的库&#xff0c;涵盖各种功能&…
阅读更多...
LeetCode110. Balanced Binary Tree

LeetCode110. Balanced Binary Tree

文章目录 一、题目二、题解 一、题目 Given a binary tree, determine if it is height-balanced . Example 1: Input: root [3,9,20,null,null,15,7] Output: true Example 2: Input: root [1,2,2,3,3,null,null,4,4] Output: false Example 3: Input: root [] Output…
阅读更多...
AI：80-基于深度学习的医学图像分割与病变识别

AI：80-基于深度学习的医学图像分割与病变识别

🚀 本文选自专栏：人工智能领域200例教程专栏 从基础到实践，深入学习。无论你是初学者还是经验丰富的老手，对于本专栏案例和项目实践都有参考学习意义。 ✨✨✨ 每一个案例都附带有在本地跑过的代码，详细讲解供大家学习，希望可以帮到大家。欢迎订阅支持，正在不断更新中，…
阅读更多...
代码随想录算法训练营第四十九天|121. 买卖股票的最佳时机、122. 买卖股票的最佳时机 II

代码随想录算法训练营第四十九天|121. 买卖股票的最佳时机、122. 买卖股票的最佳时机 II

第九章 动态规划part10 121. 买卖股票的最佳时机 给定一个数组 prices &#xff0c;它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票&#xff0c;并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最…
阅读更多...
数据可视化PCA与t-SNE

数据可视化PCA与t-SNE

PCA&#xff08;主成分分析&#xff09;和t-SNE&#xff08;t分布随机近邻嵌入&#xff09;都是降维技术&#xff0c;可以用于数据的可视化和特征提取。 降维&#xff1a;把数据或特征的维数降低&#xff0c;其基本作用包括&#xff1a; 提高样本密度&#xff0c;以及使基于欧…
阅读更多...
链表的逆置

链表的逆置

方法1&#xff1a; 依次将指针反向&#xff0c;最后令头指针指向尾元素。 逆置过程如下&#xff1a; 当q指针为空时&#xff0c;循环结束。 //试写一算法&#xff0c;对单链表实现就地逆置&#xff0c; void Reverse1(List plist)//太复杂,不用掌握 {assert(plist ! NULL);i…
阅读更多...
最新文章

Copyright @ 2022~2023