1.抽象类
抽象类用abstract关键字修饰，抽象类用abstract修饰的函数，就做抽象函数。抽象类中也可以有非抽象函数
abstract class AbstractClass {
abstract fun abstractFunction()
fun funtcion(){
}
}
2.数据类
在开发中我们经常用到的实体类，比如从服务器解析到的json数据变成一个实体类，我们可以用数据类。因为数据类有一下几个特点:
1.数据类默认提供了getter setter方法
2.数据类默认提供了copy方法
3.数据类默认为成员属性提供了toString方法
4.数据类默认提供了equals方法
数据类我们用data关键字修饰，并且数据类主构造函数中至少有一个参数，
package com.example.kotlin01
data class DataClassess(var x: Int, var y: Int) {
}
fun main() {
var classess1 = DataClassess(1,2)
var classess2 = DataClassess(3,4)
//1.数据类默认提供了getter setter方法
println("${classess1.x} and ${classess1.y}")
//2.数据类默认提供了copy方法
var classess3 = classess1.copy()
println("${classess3.x} and ${classess3.y}")
//3.数据类默认为成员属性提供了toString方法
println(classess2.toString())
//4.数据类默认提供了equals方法
println(classess2.equals(classess1))
println(classess3.equals(classess1))
}
3.密封类
密封类用sealed 修饰符进行修饰，密封类意义在于，它的子类必须和它自身在同一个文件中，在开发的时候我们为了减少BUG，有需要这样的需求。密封类的构造函数是私有的private ，不能直接创建密封类的实例
package com.example.kotlin01
sealed class SealedClaasess {
//它的子类必须和它自身在同一个文件中
class SealedClaasessChild : SealedClaasess() {
}
}
fun main() {
//密封类的构造函数是私有的private
//所以创建对象报错
var a = SealedClaasess()
//可以创建子类的实例
var b = SealedClaasess.SealedClaasessChild()
}
4.枚举类
枚举类用enum修饰，枚举类可以声明一些参数，实现接口，还有一些公共的参数
package com.example.kotlin01
enum class EmuClassess (val index:Int):OnChangedListener {
ONE(1) {
override fun onChanged() {
println("do one .....")
}
},TWO(2) {
override fun onChanged() {
println("do TWO .....")
}
},THREE(3) {
override fun onChanged() {
println("do THREE .....")
}
},FOUR(4) {
override fun onChanged() {
println("do FOUR .....")
}
},FIVE(5) {
override fun onChanged() {
println("do FIVE .....")
}
}
}
interface OnChangedListener {
fun onChanged()
}
fun main() {
val day = EmuClassess.ONE
//获取值
println(day.index)
//调用接口
day.onChanged()
//获取包含所有枚举值的数组
val value1 = EmuClassess.values()
value1.forEach {
println(it)
}
}
5.嵌套类
kotlin中的嵌套类指的是在某个类中再创建一个类，但是这个内部的类，不会持有外部类的引用，它其实相当与java中的静态内部类。如以下例子。创建Test这个嵌套类的实例，直接通过 InnerClassess.Test()即可。
package com.example.kotlin01
class InnerClassess {
class Test {
fun test(){
println("test.....")
}
}
}
fun main() {
InnerClassess.Test().test()
}
它其实等同与java中一下代码
package com.example.kotlin01;
public class MyTest {
public void myTest(){
}
public static class Test {
}
public static void main(String[] args) {
new MyTest.Test();
}
}
我们知道再java中，非静态的内部类持有外部类的引用，可以直接调用外部类的属性，方法。而静态的内部类不持有外部类的引用，不能直接访问外部类的属性，方法。再Kotlin中的嵌套类，其实就等同与java中静态的内部类。所以是不持有外部的引用的。
6.内部类
Kolint中的内部类就类似于Java中的非静态内部类，我们通过inner 修饰符修饰
package com.example.kotlin01
class InnerClassess {
private val bar = 1
fun foo1() {
}
inner class Test {
fun foo2() {
foo1()
var param = bar
}
}
}
我们知道在Java中竟然的内部类持有外部类的引用，可以直接访问外部类的成员，如以上在Test类中我们可以直接访问InnerClassess类中的foo1函数和bar属性
总结如下：
image.png
7.匿名内部类
和java一样，我们可以使用匿名内部类对接口的实现
interface OnclickListener{
fun click()
}
class View {
fun setClickListener(clickListener: OnclickListener) {
}
}
fun main() {
var view =View()
view.setClickListener(object : OnclickListener {
override fun click() {
}
})
}
网友评论