kotlin中使用关键字class来声明类,跟java一样
class KotlinTest{
}
构造函数
在 Kotlin 中的一个类可以有一个主构造函数以及一个或多个次构造函数。
主构造函数是类头的一部分：它跟在类名（与可选的类型参数）后,用constructor修饰。
class Person constructor(firstName: String) { ... }
如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字。
class Person(firstName: String) { ... }
如果类里面没有其他的函数操作,花括号也可以省略
class Person(firstName: String)
次构造函数可以在类中进行声明,并用constructor修饰
class Person {
constructor(parent: Person) {
parent.children.add(this)
}
}
如果类有一个主构造函数，每个次构造函数需要委托给主构造函数， 可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用 this 关键字即可：
class Person(val name: String) {
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
}
}
初始化块
类的初始化代码可以当道init代码块中
class Person constructor(firstName: String){
var userName: String? = null
init{
userName = firstName
}
}
注意：初始化块中的代码实际上会成为主构造函数的一部分。委托给主构造函数会作为次构造函数的第一条语句，因此所有初始化块中的代码都会在次构造函数体之前执行。即使该类没有主构造函数，这种委托仍会隐式发生，并且仍会执行初始化块
constructor(name: String,age: Int) : this(name){
println("此构造函数")
userAge = age
}
init {
println("init")
this.userName = name
}
输出为：
08-30 14:54:04.247 19690-19690/com.chuan.jun I/System.out: init
08-30 14:54:04.251 19690-19690/com.chuan.jun I/System.out: 此构造函数
可以看到init 先于次构造函数执行,也就是说,将参数的初始化尽量放到init里面,并且可以在此构造函数中进行调用,反过来则不行,init尽量做一些不涉及此构造函数中的参数的初始化的操作,
创建类的实例
kotlin中没有new关键字,如果想要创建类实例,直接调用类的构造函数即可
var kotlinTest: KotlinTest = KotlinTest("firstName")
var kotlinTest2: KotlinTest = KotlinTest("firstName","age")
内部类和嵌套类
class KotlinTest{
var userName: String? = null // 声明一个成员变量
class Person{ // 声明一个嵌套类 嵌套类不会持有外部类的引用,所以不能调用到外部的属性或是函数
fun p(){
}
}
inner class User{// 通过inner关键字声明一个内部类 内部类默认持有外部类的引用,因此可以调用外部类的属性/函数或是嵌套类
fun u(){
printly("$userName")
var p: Person = Person()
}
}
}
继承
在kotlin中所有类都有一个共同的超类Any,继承通过:操作符来声明
open class Parent
class Child：Parent{
}
kotlin中类上的 open 标注与 Java 中 final 相反，它允许其他类从这个类继承。默认情况下，在 Kotlin 中所有的类都是 final
如果派生类有一个主构造函数，其基类型可以（并且必须） 用基类的主构造函数参数就地初始化。
如果类没有主构造函数，那么每个次构造函数必须使用 super 关键字初始化其基类型，或委托给另一个构造函数做到这一点。 注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数：
class MyView : View {
constructor(ctx: Context) : super(ctx)
constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}
伴生对象
类内部的对象声明可以用 companion 关键字标记，这样它就与外部类关联在一起
class MyClass {
companion object Factory {
fun create(): MyClass = MyClass()
}
}
val instance = MyClass.create() // 访问到对象的内部元素
请伴生对象的成员看起来像其他语言的静态成员，但在运行时他们仍然是真实对象的实例成员
interface Factory<T> {
fun create(): T
}
class MyClass {
companion object : Factory<MyClass> {
override fun create(): MyClass = MyClass()
}
}
对象表达式和对象声明
我们需要创建一个对某个类做了轻微改动的类的对象，而不用为之显式声明新的子类。Java用匿名内部类处理这种情况。Kotlin中则用对象表达式和对象声明。
// 声明一个多方法接口
public interface JavaMoreMotherClickListener {
void onClick(String strInfo);
void onFinish(String finish);
}
如果有一个函数需要以此接口对象为参数进行调用
java 实例：
JavaTest javaTest = new JavaTest();
javaTest.setJavaMoreMotherClickListener(new JavaMoreMotherClickListener() {
@Override
public void onClick(String strInfo) {
}
@Override
public void onFinish(String finish) {
}
});
kotlin实例：
javaTest.setJavaMoreMotherClickListener(object : JavaMoreMotherClickListener{
override fun onClick(strInfo: String?) {
}
override fun onFinish(finish: String?) {
}
})
也可以声明为一个变量
var listener: JavaMoreMotherClickListener = object: JavaMoreMotherListener(){
override fun onClick(strInfo: String?) {
}
override fun onFinish(finish: String?) {
}
}
javaTest.setJavaMoreMotherClickListener(listener)
对象声明
官网说 对象声明使单例声明变得很容易,因为对象声明的初始化过程是线程安全的 但是本人还是没有找到具体的使用场景,知道的小伙伴可以留言
object MyListener{
fun test(){
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
MyListener.test()
}
使用很方便 直接类名.函数名调用即可
解构声明
根据一个对象(数据类)的主构造函数的入参 并将其解构成多个变量的语法叫做解构声明
// 通过data声明数据类
data class JieGouShengMing(var name: String,var age: Int)
var jgsm: JieGouShengMing = JieGouShengMing("chuan",1)
var (name,age) = jgsm // 解构数据类
println("name:$name age:$age")
输出为name:chuan age:1
这个数据类相当于一个集合类 里面包含有一些数据,然后通过解构 将这些数据单独的拎出来
