类定义
//定义空类
class Kotlin
//类名Kotlin_1
class Kotlin_1{
}
//带成员函数类
class Kotlin_2{
fun m1(){
prinlt("hello word")
}
}
类的属性
class Kotlin_3{
var a :String = "默认"
var a :Int= 0
}
//普通构造类实例 Kotlin 中没有 new 关键字
va l b = Kotlin_3()
//使用.调用该类的属性和public成员函数
b.a = "“你好么?”
Koltin 中的类可以有一个 主构造器,以及一个或多个次构造器,主构造器是类头部的一部分,位于类名称之后:
//如果构造器有注解,或者有可见度修饰符,这时constructor关键字是必须的,注解和修饰符要放在它之前。
class Person private constructor(firstName: String) {} //添加私有修饰
class Person constructor(firstName: String) {} //无修饰关键字 构成关键字可省略
如果主构造器没有任何注解,也没有任何可见度修饰符,那么constructor关键字可以省略。
class Person(firstName: String){}
getter 和 setter
如果属性类型可以从初始化语句或者类的成员函数中推断出来,那就可以省去类型,val不允许设置setter函数,因为它是只读的。
var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1 // 类型为 Int, 默认实现了 getter 和 setter
val simple: Int? // 类型为 Int ,默认实现 getter ,但必须在构造函数中初始化
val inferredType = 1 // 类型为 Int 类型,默认实现 getter
class Person{
var a : String = ""
// Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器
get() = field
set(i) {
field = if (i.length>10) "" else i
}
//默认实现getter val不支持setter
val b : String = ""
}
主构造器
主构造器中不能包含任何代码,初始化代码可以放在初始化代码段中,初始化代码段使用 init 关键字作为前缀
class Person constructor(firstName: String) {
init {
println("FirstName is $firstName")
}
}
class Runoob constructor(name: String) { // 类名为 Runoob
// 大括号内是类体构成
var url: String = "http://www.runoob.com"
var country: String = "CN"
var siteName = name
init {
println("初始化网站名: ${name}")
}
fun printTest() {
println("我是类的函数")
}
}
fun main(args: Array<String>) {
val runoob = Runoob("菜鸟教程")
println(runoob.siteName)
println(runoob.url)
println(runoob.country)
runoob.printTest()
}
//主构造
class Kotlin_1 constructor(arg:String){
var a = arg
init {
arg
val kt = Kotlin_0()
kt.b = "0012065332165465655665"
}
lateinit var t1 :String
private var t2 :Int = 0
//次构造
constructor(arg:String,a:Int) : this(arg) {
this.t1 = arg
this.t2 = a
}
}
//主构造 示例
val k= Kotlin_1("")
//次构造 示例
val k1= Kotlin_1("",0)
抽象类
open class Base {
open fun f() {}
}
abstract class Derived : Base() {
override abstract fun f()
}
嵌套类
class Outer { // 外部类
private val bar: Int = 1
class Nested { // 嵌套类
fun foo() = 2
}
}
fun main(args: Array<String>) {
val demo = Outer.Nested().foo() // 调用格式:外部类.嵌套类.嵌套类方法/属性
println(demo) // == 2
}
内部类
class Outer {
private val bar: Int = 1
var v = "成员属性"
/**嵌套内部类**/
inner class Inner {
fun foo() = bar // 访问外部类成员
fun innerTest() {
为了消除歧义,要访问来自外部作用域的 this,我们使用this@label,其中 @label 是一个 代指 this 来源的标签。
var o = this@Outer //获取外部类的成员变量
println("内部类可以引用外部类的成员,例如:" + o.v)
}
}
}
fun main(args: Array<String>) {
val demo = Outer().Inner().foo()
println(demo) // 1
val demo2 = Outer().Inner().innerTest()
println(demo2) // 内部类可以引用外部类的成员,例如:成员属性
}
接口类的使用
定义一个接口
interface Test {
fun doSomething(error : String)
}
class Kotlin_3 : Test{
init {
//初始化
ab("1",this)
ab("2",this)
ab("3",this)
}
/**
* 打印结果
*/
override fun doSomething(error: String) {
Log.v("=======测试======","error=$error")
}
/**
* 分支
*/
fun ab(v1:String ,a:Test){
when (v1){
"1" ->{ a .doSomething("你是 1 ")}
"2" ->{ a .doSomething("你是 2 ") }
else -> {
a .doSomething("你啥也不是 ")
}
}
}
}
类的修饰符
类的修饰符包括 classModifier 和_accessModifier_:
classModifier: 类属性修饰符,标示类本身特性。
abstract // 抽象类
final // 类不可继承,默认属性
enum // 枚举类
open // 类可继承,类默认是final的
annotation // 注解类
accessModifier: 访问权限修饰符
private // 仅在同一个文件中可见
protected // 同一个文件中或子类可见
public // 所有调用的地方都可见
internal // 同一个模块中可见