Kotlin出来有几个年头了,不温不火,google粑粑在今年I/O大会上宣布Kotlin成为Android的官方语言(可能是谷歌和甲骨文Java神仙打架后,做出的调整),算是在android开发的老司机和新司机的脑子里都留下了印象。
( 受面向对象语言的荼毒比较深,我还是比较喜欢先看一下它的Class和Object)
class Hello{
}
这申明熟悉的感觉,没毛病。
根据官方文档指出一个class能够有一个primary constructor以及多个secondary constructors (面向对象的一个特征出来了),基本的一个class的构造方法,也就是primary constructo 一个constructor关键字
class Hello constructor(test: String){
}
不过根据官方文档还说明一点:如果primary constructor没有任何的注释说明或者有用的修饰,那么constructor可以省略
class Hello (test:String){}
另外基本的构造方法不能包含任何胆码,我们能够通过init关键字来进行初始化(挺人性化的设计)
class Hello(test:String){
init{
logger.info("Hello init with value ${test}")
}
}
小提示: 构造方法的变量能够在init初始化的中,也能够通过申明变量引用
class Customer(name: String) {
val customerKey = name
}
同时也能这么玩
class Person(val firstName: String, val lastName: String, var age: Int) {
// ...
}
(var和val的区别说变量时再区别,构造方法里变量申明也可以用 val)
上面说的都是没有那些有用的修饰符或者有用的修饰符,如果有那么constructor 就不可以省略,把Visibility Modifiers 搁到constructor之前就可以
class Customer public @Inject constructor(name: String) { ... }
那么被官方成为Secondary Constructors 就是大家熟悉的这样
class Person {
constructor(parent: Person) {
parent.children.add(this)
}
}
如果一个class有一个primary constructor,那么每一个secondary constructor需要一个this关键字引用这个变量
class Person(val name: String) {
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
}
}
如果你的定义一个class 没有构造方法,那么你的constructor就是public ,如果想要定义个私有的构造方法就用private(和Java的一样)
class DontCreateMe private constructor () {
}
kotlin没有new这个关键字,实例化一个类
val hello = Hello()
val custom = Customer("hello world");
class MyView : View {
constructor(ctx: Context) : super(ctx)
constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}
看一下下面的(open关键字,需要继承复写方法用),老司机们看例子,就不用介绍了还是一个override关键字
open class Base {
open fun v() {}
fun nv() {}
}
class Derived() : Base() {
override fun v() {}
}
open class Foo {
open val x: Int get { ... }
}
class Bar1 : Foo() {
override val x: Int = ...
}
如果进制复写一个方法,那么就引用一个final 关键字
open class AnotherDerived() : Base() {
final override fun v() {}
}
还是 abstract
open class Base {
open fun f() {}
}
abstract class Derived : Base() {
override abstract fun f()
}
(又是val和var的区别)
interface Foo {
val count: Int
}
class Bar1(override val count: Int) : Foo
class Bar2 : Foo {
override var count: Int = 0
}
复写规则:
看例子,比口述强,一个super关键字
open class A {
open fun f() { print("A") }
fun a() { print("a") }
}
interface B {
fun f() { print("B") } // interface members are 'open' by default
fun b() { print("b") }
}
class C() : A(), B {
// The compiler requires f() to be overridden:
override fun f() {
super.f() // call to A.f()
super.f() // call to B.f()
}
}