- Var与Val
var和val均为Kotlin开发中的关键字定义变量，两者虽然长得很像但是作用大不相同。
var为可变变量，即可以通过重新赋值来改变其内容的变量，与java中传统的声明变量方式基本一致。
val为只读变量，可以将它理解为java变量常用修饰符中的final，在初始化的时候需要赋值，且不能被修改。
总Var是可变变量
总Val只读变量例如(final) 不可更改
- Kotlin – open, final, abstract
在Kotlin中，所有的类默认都是final的。如果你需要允许它可以被继承，那么你需要使用open声明：
//这个类具有`open`属性，可以被其他类继承
open class People: Speakable{
//`open`的方法被实现和覆写，该方法也是`open`的
override fun say() {}
//`final`属性的方法，不可被覆写
fun sayHello() {}
//`open`属性的方法，可以被继承和覆写
open fun sayName() {}
}
当然，你也可以阻止某些方法被覆写：
open class People: Speakable{
//`final`修饰一个原本具有`open`属性的方法，使其变得不可再被覆写
final override fun say() {}
}
在kotlin中
，abstract的用法几乎和Java一致，我就不再啰嗦，
值得一提的是，
当你使用abstract修饰符的时候，可以忽略open修饰符，因为被abstract修饰的类默认具有open属性。
修饰符 相应类的成员 注解
final 不能被覆写 在kotlin中默认所有的方法和类都是final属性
open 可以被覆写 需要被明确指出
abstract 必须要覆写 不能被实例化，默认具有open属性。
override 覆写超类的方法 如果没有被指定为final，则默认具有open属性
上述表格仅适用于基类，对于接口类来说，你基本用不上fianl、open、abstract，因为接口类默认是open，且不能被声明为final，如果接口类的方法没有函数体，那么其为abstract，但是不需要你明确指出他是abstract的
objeck👇
Kotlin学习系列之：object关键字的使用场景
- 对象声明（Object Declaration）
- 伴生对象（Companion Object）
- 对象表达式（Object Expression）
下面就一一介绍它们所表示的含义、用法以及注意点，保证你在看完本篇之后就可以完全掌握object关键字的用法。
- 对象声明（Object Declaration）
- 语法含义：将类的声明和定义该类的单例对象结合在一起（即通过object就实现了单例模式）
- 基本示例
object RepositoryManager{
fun method(){
println("I'm in object declaration")
}
}
即将class关键字替换为object关键字，来声明一个类，与此同时也声明它的一个对象。只要编写这么多代码，这个类就已经是单例的了。
- 使用
a. 在Kotlin中：
fun main(args: Array<String>) {
RepositoryManager.method()
}
b. 在Java中：
public class JavaTest {
public static void main(String[] args) {
RepositoryManager.INSTANCE.method();
}
}
换句话说，object declaration的类最终被编译成：一个类拥有一个静态成员来持有对自己的引用，并且这个静态成员的名称为INSTANCE，当然这个INSTANCE是单例的，故这里可以这么去使用。如果用Java代码来声明这个RepositoryManager的话，可以有如下代码：
class RepositoryManager{
private RepositoryManager(){}
public static final RepositoryManager INSTANCE = new RepositoryManager();
}
- 注意点:
尽管和普通类的声明一样，可以包含属性、方法、初始化代码块以及可以继承其他类或者实现某个接口，但是它不能包含构造器（包括主构造器以及次级构造器）
它也可以定义在一个类的内部：
class ObjectOuter {
object Inner{
fun method(){
println("I'm in inner class")
}
}
}
fun main(args: Array<String>) {
ObjectOuter.Inner.method()
}
- 伴生对象（Companion object）
在阐述伴生对象之前，首先我们要明确一点：在Kotlin中是没有static关键字的，也就是意味着没有了静态方法和静态成员。那么在kotlin中如果要想表示这种概念，取而代之的是包级别函数（package-level function）和我们这里提到的伴生对象。至于它们之间的区别，不急，我们后面再说。
- 语法形式：
class A{
companion object 伴生对象名(可以省略){
//define method and field here
}
}
- 基本示例：
class ObjectTest {
companion object MyObjec{
val a = 20
fun method() {
println("I'm in companion object")
}
}
}
- 对象表达式（Object Expression）
- Java的匿名内部类回顾：
在去学习对象表达式之前，我们先来回顾一下Java中的匿名内部类。
interface Contents {
void absMethod();
}
public class Hello {
public Contents contents() {
return new Contents() {
@Override
public void absMethod() {
System.out.println("method invoked...");
}
};
}
public static void main(String[] args) {
Hello hello = new Hello();
hello.contents().absMethod(); //打印method invoked...
}
}
这个contents()方法返回的是一个匿名内部类的对象，这个匿名内部类实现了Contents接口。这些代码很熟悉，不多说了。现在提出两个局限性问题：
a. 如果在匿名内部类中新添加了一些属性和方法，那么在外界是无法调用的
return new Contents() {
private int i = 1;
public int value() {
return i;
}
@Override
public void absMethod() {
System.out.println("method invoked...");
}
};
public static void main(String[] args) {
Hello hello = new Hello();
hello.contents().absMethod();
hello.contents().value(); //Cannot resolve method 'value()'
}
b. 不实现任何接口和类，并且在匿名内部类中添加方法
fun main(args: Array<String>) {
val obj = object {
fun a() {
println("a invoked")
}
}
obj.a() //打印：a invoked
}
这是Kotlin官方文档上的一段话：匿名对象只有定义成局部变量和private成员变量时，才能体现它的真实类型。如果你是将匿名对象作为public函数的返回值或者是public属性时，你只能将它看做是它的父类，当然你不指定任何类型时就当做Any看待。这时，你在匿名对象中添加的属性和方法是不能够被访问的。
再来举个例子帮助大家理解：
class MyTest {
private val foo = object {
fun method() {
println("private")
}
}
val foo2 = object {
fun method() {
println("public")
}
}
fun m() = object {
fun method(){
println("method")
}
}
fun invoke(){
val local = object {
fun method(){
println("local")
}
}
local.method() //编译通过
foo.method() //编译通过
foo2.method() //编译通不过
m().method() //编译通不过
}
}
Lazy👇
Kotlin中的延迟属性（lazy properties）
属于Kotlin中的委托属性这一章中的标准委托
延迟属性Lazy
lazy() 是接受一个lambda 并返回一个 Lazy <T> 实例的函数，返回的实例可以作为实现延迟属性的委托。也就是说：
第一次调用get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果， 后续调用get() 只是返回记录的结果。
这里需要注意的是 调用的是 get()方法,和set没啥关系
val lazyValue: String by lazy {
println("computed!")
"Hello"
}
fun main(args: Array<String>) {
println(lazyValue)
println(lazyValue)
}
输出结果为
computed!
Hello
Hello
这是输入"kotlin ?和!!"搜索到的百度第一条答案，确实这位说的没错。不过我觉得对于一个刚接触KT(Kotlin)的新手来说，他恐怕需要有汉语八级才能透彻理解这两句话的意思。
先阐述两个概念：
"?"加在变量名后，系统在任何情况不会报它的空指针异常。
"!!"加在变量名后，如果对象为null，那么系统一定会报异常！
val myList : ArrayList<String>? = null
Log.d("TAG", "-->> List Size = ${myList!!.size}")
