Kotlin基础概念(一)

一、类和对象（Classes and Objects）:

    1、Kotlin定义类的关键字还是class跟Java一个样： 

class MyKolin{

}

    2.构造方法（Constructors）：

      *构造方法可以有主构造方法和其他的构造方法,参数的定义为

       参数名：参数类型：

class person constructor(fristName:String){
    
}
//或者省略掉constructor
class person (fristName:String){
    init{ 
        logger.info("这是在构造方法中初始化的代码
          块")
    }
    //也可以定义一些初始化参数
    val customerKey=name.toUpperCase()
}

       *如果构造方法有注解或是显示的修饰，constructor关键字必须出现在构造函数中且出现在修饰符之后：

class Cutsomer public @Inject constructor (name:String){
}

       *val和var的区别：var是为可变的数据类型，val为只读类型

class Person(val firstName: String, val lastName: String, var age: Int) {
// ...
}

      3.类的实例化（Creating instance of classes）,在Kotlin中创建实例没有new这个关键字这是与Java中不同的区别:

val invoice=Invoice
val customer=Customer("EverBrilliant")

      4.类的成员:类中可包含构造方法（Constructors）和初始化代码块（initializer blocks）、方法（Functions）、成员变量属性（Properties）、内嵌类与内部类（Nested and Inner Classes）、对象声明（Object Declaration）。

二、继承（Inheritance）：

    1.所有的Kotlin类都有一个共同的超类Any,在类中没有继承的父类声明时默认的超类都是Any。Any不同于Java中的Object，在它里面没有任何的成员方法。

为了明确声明超类，把类型放在冒号后面：

open class Base(p:Int)
class Derived(p:Int):Base(p)

    open关键字是注解于类之前与Java中final是相对的，它允许其他类继承这个类，只有在open修饰下才能被继承或是重写。

    2.方法重载（Overriding Methods）:在方法重载中不像Java中方法重载，Kotlin明确的注解(override)在方法重载时：

open class Base{
   open fun v(){}
   fun nv(){}       //没有open是不可被重写的
}
class Derived():Base(){
    override fun v(){}
}

open class AnotherDerived():Base(){
   final override fun v(){}         //在此之后不可被重写
}

    3.属性重载：与方法重载相类似。

interface Foo{
   val count :Int
}
class Bar1(override val count :Int):Foo
class Bar2:Foo{
     override var count:Int =0
}

    4.重载的规则：在Kotlin中实现继承的规则为如果类从直接父类继承实现同一成员，必须重载这个成员并提供实现。为了标记这个方法是从哪里继承实现的我们使用super鉴定从哪个类型名以扩符号来标记：

open class A{
   open fun f(){print("A")}
   fun a(){print("a")}
}
interface B{
   fun f() {print("B")}   //接口的成员默认是open
   fun b(){print("b")}
}
class C():A(),B{
   override fun f(){
    super<A>.f()    //调用A.f()
    super<B>.f()    //调用B.f()
   }
}

    5.抽象类（Abstract classes）:

open class Base{
     open fun f(){}
}
abstract class Derstract :Base(){
     override abstract fun f()
}

   6.Companion Object:

在Kotlin不像Java中类是没有静态方法，推荐包级函数去代替。

三、属性和方法（Properties and fileds）:

   1.属性的声明： 不定的类型用使用var关键字或者只读的使用val关键字：

class Adress{
   var name:String=……   //属性的定义
   val street：String=
}
//属性的使用
fun copyAdress (adress:Adress):Adress{
  val result=Adress()    //创建对象Kotlin中没new
  result.name=address.name   //使用属性
}

   2.声明属性的全语法：

//var 属性名：[属性类型][=初始化值][get方法][set方法]
var <propertyName>[:<PropertyType>] [=<property_initializer>]
[<getter>]
[<setter>]

    3.在全语法中只读（read-only）属性声明不同于可变属性：*用val去修饰 *不允许有set方法。
   4.备用属性（Backing Properties）:隐式对属性值初始化声明避免了空指针。

private var _table:Map<String,Int>?=null
public val table:Map<String,Int>
   get(){
      if(_table==null){
         _table=HashMap()    //参数类型是自动推导
      }
      return _table?:thrw AssertionError("set to null by another thread")
    }

不管是备用变量或者备用属性，都是Kotlin对于空指针的一种解决方案，可以避免函数访问私有属性而破坏它的结构 。  

   5.编译时常量(Compile-Time Constants):在编译时就可以知道具体的属性值可以用const修饰，也可以当做注解时使用：

const val SUBSYSTEM_DEPRECATED:String="This subsystem is deprecated"
@Deprecated (SUBSYSTEM_DEPRECATED) fun foo(){
 ……
}

   6.延时初始化属性（Late-Initialized Properties）:

在Kotlin中，声明为具有非空类型的属性必须在构造函数中初始化，但是往往不希望在构造函数中初始化，例如在通过依赖注入或单元测试的设置方法来初始化属性的时候，不能在构造器中提供一个非空的初始化语句，为了处理这种情况，就要在属性上加lateinit关键字来延迟初始化