object,类似Java中的静态
三种使用方式:
对应Java中的单例类,只会在内存中实例化一次
object Const {
init {
println("init")
}
fun getConfig(): String {
return "config"
}
}
fun main() {
println(Const.getConfig())
println(Const.getConfig())
}
结果:
init
config
config
Java中的匿名类
java写法如下:
static class Man {
void doSomthing() {
}
}
public static void main(String[] args) {
Man my = new Man() {
@Override
void doSomthing() {
super.doSomthing();
}
};
}
kotlin写法:
open class Man {
open fun doSomthing() = ""
}
fun main() {
var superMan = object : Man() {
override fun doSomthing(): String {
return "super Man protected earth"
}
}
println(superMan.doSomthing())
}
如果你想要某个对象和一个类实例化绑定在一起,可以考虑伴生对象,使用 companion object 可以在一个类里定义一个伴生对象,一个类只能有一个伴生对象,
伴生对象也是静态的,只会在类实例化或调用伴生对象中的内容(对象和函数)时实例化一次
class Const {
init {
println("init Const")
}
companion object {
init {
println("init companion object")
}
fun getConfig(): String {
return "config"
}
}
}
fun main() {
val const = Const()
println(Const.getConfig())
println(Const.getConfig())
}
结果:
init companion object
init Const
config
config
和Java中的内部类类似,如果一个类只对另一个类有用,那么使用内部类是合理的
class Man {
class BatMan {
fun introduce() = "i'm Batman"
}
class IronMan {
fun introduce() = "i'm Ironman"
}
}
fun main() {
println(Man.BatMan().introduce())
}
数据类是用来存储数据的类,它会自动实现toString、hashCode、equals的个性化实现
class NormalClz(var x: Int, var y: Int) {
}
data class DataClz(var x: Int, var y: Int) {
var z: Int = 40
}
fun main() {
val normal = NormalClz(10, 10)
println(normal)
val data = DataClz(10, 10)
println(data)
}
结果:
com.aruba.mykotlinapplication.NormalClz@5e481248
DataClz(x=10, y=10)
注意:数据类自动实现的个性化只对主构造函数里的定义的参数起作用
数据类还提供了copy函数,用来复制一个对象
data class DataClz(var x: Int, var y: Int) {
var z: Int = 40
override fun toString(): String {
return "DataClz : $x $y $z"
}
constructor(_x: Int) : this(_x, 20) {
//copy函数不会赋值
this.z = 20
}
}
fun main() {
val data = DataClz(10, 10)
println(data.copy(20))
}
结果:
DataClz : 20 10 40
注意:copy函数不会复制次构造函数中的赋值
前面我们已经使用过解构语法了,如果想要在自己定义的类中使用,需要operate关键字,
并声明component1、component2...组件函数,函数名不能擅自改动
class NormalClz(var x: Int, var y: Int) {
operator fun component1() = x
operator fun component2() = y
}
fun main() {
val normal = NormalClz(20, 30)
val (x, y) = normal
println("$x $y")
}
数据类会自动为所有在主构造函数内定义的属性进行解构声明
data class DataClz(var x: Int, var y: Int) {
}
fun main() {
val data = DataClz(20, 30)
val (x, y) = data
println("$x $y")
}
之前使用集合是我们可以直接使用 "+" 、"-" 等来添加和删除元素
和c++一样,kotlin也支持运算符重载,只需要重载下面的函数就可以实现了:
用来定义常量集合的一种特殊类
enum class Position {
east,
west,
south,
north
}
也可以定义函数
enum class Position(
val data: DataClz
) {
east(DataClz(1, 0)),
west(DataClz(-1, 0)),
south(DataClz(0, -1)),
north(DataClz(0, 1));
fun updatePosition(upData: DataClz) =
DataClz(
this.data.x + upData.x,
upData.y + data.y
)
}
fun main() {
println(Position.east.data)
println(Position.east.updatePosition(DataClz(10, 10)))
}
可以用来表示一种子类型的闭集,枚举类就是一种简单的代数数据类型(ADT)
enum class Position {
east,
west,
south,
north
}
class Treasure(var position: Position) {
fun find() = when (position) {
Position.east -> "不在东边"
Position.west -> "不在西边"
Position.south -> "不在南边"
Position.north -> "你在北边找到了宝藏"
}
}
fun main() {
println(Treasure(Position.north).find())
}
结果:
你在北边找到了宝藏
对于更复杂的ADT,可以使用密封类,使用sealed修饰类,来实现更加复杂的定义,密封类可以更灵活的控制某个子类型
子类型必须和它定义在同一个文件里
sealed class Position {
//使用object,防止重复创建
object east : Position()
object west : Position()
object south : Position()
class north(var item: String) : Position()
}
class Treasure(var position: Position) {
fun find() = when (position) {
is Position.east -> "不在东边"
is Position.west -> "不在西边"
is Position.south -> "不在南边"
is Position.north -> "你在北边找到了:${(position as Position.north).item}"
}
}
fun main() {
println(Treasure(Position.west).find())
println(Treasure(Position.north("肥皂")).find())
}
结果:
不在西边
你在北边找到了:肥皂
和Java差不多,用interface定义,实现接口的方法必须有override修饰符
interface Callback {
fun callback()
}
class Impl() : Callback {
override fun callback() {
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
}
}
接口也可以定义函数实现和getter函数
interface Callback {
val number: Int
get() = (0..500).shuffled().first()
fun callback() = "haha"
}
class Impl() : Callback {
override fun callback(): String {
return super.callback()
}
}
和Java一样,可以用abstract修饰类和方法
abstract class AbstractClass {
abstract fun callback(): String
}
class ImplClz() : AbstractClass() {
override fun callback(): String {
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
}
}