1、类定义
Kotlin类可以包含:构造函数和初始化代码块、函数、属性、内部类、对象声明。
创建类:
class Runoob{ //创建名为Runoob的类
}
定义空类:
class Empty
含有成员函数的类:
fun main(args: Array<String>) {
var s = Student()
s.introduce()
}
class Student{
fun introduce(){ println("I am a student") }
}
类的属性
类的属性可以用关键字var声明为可变的,否则使用只读关键字val声明为不可变。
例子:
class Student{
var name:String = ...
var address:String =...
var phone:String =...
}
kotlin中创建对象没有了new关键字,我们可以像调用普通函数一样调用类的构造方法;
例如:
val student = Student()
想要使用类中的属性,只要用名称引用它即可
例如:
student.name
getter和setter
属性声明的完整语法:
var <propertyName>[:<PropertyType>][=<property_initializer>]
[<getter>]
[<setter>]
如果属性类型可以从初始化语句中推断出来,那么类型就可以省略;
在kotlin中,声明一个类的成员变量时,默认实现了getter和setter方法;
用val修饰的属性不允许设置setter函数,因为它本身就是只读的;
例如:
var allByDefault:Int? //错误:需要一个初始化语句
var initialized = 1 //类型为Int,默认实现了getter和setter
val simple:Int? //类型为Int,默认实现了getter,但必须在构造函数中初始化
val inferredType = 1 //类型为Int,默认实现了getter
在kotlin的getter方法中不能使用当前属性的引用,set方法中不能对当前属性进行赋值;
例如:
var no:Int = 100
get() = no //这里如果使用当前属性的引用,会递归调用属性的get方法
set(value){
no = value //同理,如果在这给no赋值,会递归调用属性的set方法
}
为了防止这种情况的发生,kotlin引入了后端变量的概念,后端变量使用field表示;
例如:
class Student{
var number:Int = 1001
get() = getDate()+field
set(value){
field = getDate()+value
}
fun introduce(){ println("I am a student") }
//获取年份
private fun getDate():Int{
var date = Calendar.getInstance().get(Calendar.YEAR)
return date*10000
}
}
非空属性必须在定义的时候初始化,kotlin提供了一种可延迟初始化的方案,使用lateinit关键字描述属性:
public class MyTest{
lateinit var subject:TestSubject
fun setup(){
subject = TestSubject()
}
}
主构造器
主构造器不能包含任何代码,初始化代码可以放在初始化代码段中,初始化代码段使用init关键字作为前缀。
class Person constructor(firstName :String){
init{
println("FirstName is $firstName")
}
}
当然在这里主构造器的参数可在初始化的代码片段中使用,也可以在属性初始化的代码中使用;另
外一种简单的写法就是用主构造器来定义属性并初始化属性值。例如:
class Person(val firstName:String,val lastName:String){
//....
}
如果构造器有注解,或者有可见度修饰符,这时constructor关键字是必须的,注解和修饰符要放在它之前。
次构造函数
类也可以有二级构造函数,需要添加前缀 constructor
class Person{
constructor(parent:Person){
parent.children.add(this)
}
}
如果类有主构造函数,每个次构造函数都要,直接或间接通过另一个次构造函数代理主构造函数。在同一个类中代理另一个构造函数使用关键字this关键字:
class Person(val name:String){
constructor(name:String,age:Int):this(name){
//初始化...
}
}
如果一个非抽象类没有声明构造函数(主构造函数或次构造函数),它会会产生一个没有参数的构造
函数,构造函数时public的,如果你不想你的类有公有的构造函数,你需要声明一个空的主构造函
数:
class Single private constructor(){}
实例练习:
class WebSite constructor(name:String){
var url:String ="http://www.baidu.com"
var country:String = "CN"
var siteName = name
init{
println("初始化网站名:$name")
}
constructor(name:String,alexa:Int):this(name){
println("Alexa 排名 $alexa")
}
}
2、抽象类
抽象类和java一样使用abstract修饰,同样使用abstract修饰的成员方法不存在具体实现。
注意:无需对抽象类或抽象成员标注open注解。
open class Base {
open fun f(){}
}
abstract class Dervied:Base(){
abstract override fun f()
}
嵌套类
kotlin中可以嵌套的声明类,这里和java内部类不同,其他类要使用嵌套类时,只需要外部类的
类名引用来创建嵌套类的对象,如下:
class Outer{ //外部类
private val bar:Int = 1
class Nested{ //嵌套类
var ot:Outer = Outer()
fun foo() {
println(out.bar) //嵌套类想要引用外部类的变量,需要先创建外类的对象
}
}
}
fun main(args:Array<String>){
val demo = Outer.Nested().foo()
println(demo)
}
内部类
内部类使用inner关键字来表示。
内部类会带有一个对外部类的对象的引用,所以内部类可以访问外部类成员属性和成员函数。
class Outer{
private val bar:Int=1
var v = "成员属性"
inner class Inner{
fun foo() = bar
fun innerTest(){
var o = this@Outer
println("内部类可以引用外部类的成员,例如:"+o.v)
}
}
}
fun main(args: Array<String>) {
val demo = Outer().Inner().foo()
println(demo)
val demo2 = Outer().Inner().innerTest()
println(demo2)
}
匿名内部类
class Demo{
fun setInterface(test:TestInterface){
test.test()
}
}
interface TestInterface{
fun test()
}
fun main(args: Array<String>) {
var demo = Demo()
demo.setInterface(object :TestInterface{
override fun test() {
println("匿名内部类的方法,哈哈哈")
}
})
}
这里匿名内部类和java中的有区别,object:TestInterFace中的object是kotlin的关键字;
类的修饰符总结
和java一样,类的修饰符分为两种classModifier和accessModifier:
classModifier:类属性修饰符,用来标识类本身特性。
abstract //抽象类
final //类不可继承,默认属性
enum //枚举类
open //可继承类,类默认是final的
annotation //注解类
accessModifier:访问权限修饰符
private //仅在同一个文件中可见
protected //同一个文件中或子类中可见
public //所有调用的地方都可见
internal //同一个模块中可见
网友评论