1. kotlin的方法 可以直接调用 不用 new?
   2.kotlin关于字符串 用 $拼接变量
   3.kotlin 类 方法 变量 可以同级的，同级的 方法 和 变量(常量) 是 生成了 一个新的 xxxKt.class ，并且都是 static的，
   4.kotlin的类，方法，默认是 final的，成员变量不是，如果想给成员变量定义，那么指定 val即可(局部变量 没有讨论 static final的 必要)
   5.kotlin变量 可以不初始化吗？(不知道 目前还)
   6.怎么定义 static 伴生类 和 单例类(推荐，因为半生类，还要再类下面写类)，用@JVMStatic 注解 修饰 方法 和 成员变量即可
   7.关于修饰符 后面再说
   kotlin 的 类型 分为 可空 和 非空？ 即使是 Unit也是 可空 和 非空的，如果定义了 非空变量，那么它一直是 非空的，代码上如果出现可能为 null的情况，idea会提示有问题的，所以如果编译成功，那么一定不会为null

8.Any 是 所有 kt类的 父类，Object是 java类 两者不一样
9.如果 在 kotlin中，知道 这个类型 一定是 某个具体的类型，那么 kotlin会自动将其转换成其类型，不像 java 要 强制转换才行
如果真的 不知道，你想要 强转，那么用 a As String 即可

10.when 可以替换 if else 和 switch case

11.如果 函数体 返回，且只有 一句话，那么 可以用 fun xxx = xxxx 省略 {} 用 = 连接
同样 var x = 后面可以接{}的

12.kotlin中 有 重载运算符的概念，范围的运算符 in（java 里面 btween and）, x in 2…5 代表 x 在 2到5的范围中

13.kotlin 的 stream流的使用 和 java 有点不一样

14.kotlin中，一个类可以有一个 primary构造方法 和 多个 secondary构造方法，实际就和 java的多个构造方法一样
kotlin 如果不定义构造方法，默认有一个 主构造方法，无参的，构造体没有代码
主构造方法是类头的一部分，它位于类的后面，
如果primary构造方法没有任何 可见修饰符修饰，或者注解修饰，constructor关键字 可以省略
primary构造方法的 参数，可以在 init里面使用（init就是 primary构造方法的 方法体），以及成员变量 后直接赋值，
对于变量后直接赋值，和java里面的不一样，kotlin中 如果用 primary构造参数 给 成员变量赋值，那么实际 是，在primary构造函数执行中，给其赋值初始值，
换句话说，成员变量 初始化的时候，都是在 primary构造函数中的，所以 成员变量 初始化 可以是任何值，这里用primary的参数，是因为，初始化过程是在 primary里面执行的
也就是在 init里面执行的，

主构造方法中的参数，可以在 init里面用，并给成员变量赋值，也可以直接 赋值在成员变量后，实际就是 编译后，在 init中给 其赋值

初始化 成员变量的 执行顺序 取决于，他们在代码中的顺序，例如 先执行 成员变量 = xxx 后执行 init里面的语句，可以重复赋值的，实际在java中，成员变量直接赋值，也是在 无参构造方法中执行的

成员变量 = xxx;
init{
成员变量 = xxx;
}

java中，是吧 成员变量xxx 和 {} 放在了无参构造中的，简单来说，初始化对象 必须 走 构造方法，不走无参，就是有参

这种只是 简化写法 这里的 成员变量 也是 赋初始值了的 就是 this.name = name

关于 secondry构造函数，实际 就是 kotlin给 提供的 构造函数 重载，secondary构造函数，必须调用 主构造函数 ，而且 secondary构造函数 是 不适用 上面的简便 写法的，

主构造方法必须有，次构造方法可有可无，如果不写构造函数会有一个默认空的构造函数，
如果写了 次后置函数，那么必须手写 主构造函数

如果 按照那种简便写法，

15.kotlin语言，方法中参数是可以 赋初始值的，java不具备
class Kk(var name:String = “zhangsan”)

而且 如果 主构造方法 所有参数 都有 默认值，那么 JVM 会生成 一个 不带参数的 构造方法，实际 是 为了 给 整合一些 框架使用的，当然 你完全 可以 把 无参构造 和 次级有参 都写出来 但是 很多代码 都是 不写 无参的，还要用到 无参，那么…

这种简便写法 是写的 最多的

15，修饰符的默认性，如果不知道，那么可以 手动加上 但是不一定手动加上 就一定是你加的那个，还是要遵守 kotlin的规范

16，成员变量 必须 赋初始值吗？，java中可以不赋初始值，都是如果有 无参构造的话，会在无参构造 中 赋默认初始值的

17.所有类 在kotlin中 都是 final的 open关键字 可以解除 类 和 方法的 final 让其可以继承 和 重写 重写必须加上 override关键字

kotlin 是可以没有 主构造函数，只有 次级构造函数的，如果有主构造，也有次级构造，那么次级构造 必须 调 主构造
也就是说，第一 类是一定有构造函数的，但是主构造(最多一个) 次级构造（随便），但是只有 一个类 有主构造 和 次级构造的 同时，次级构造 一定要想办法 调用一次 主构造，
主构造 和 次级构造 都是构造方法，都是构造方法的作用，不是无参有参的区别java 但是 都有的时候 次一定要调到 主

在继承的情况下，也是 子类 一定要 调 父类的构造函数 （这里就是，调 主 和 次都行） ，同时也要遵守，自己本类 次级构造 调 主构造的情况

所以就出现了一种，子类有主构造的情况下，必须主构造 去 super()父类，因为如果 次级构造 (前提有次级的情况下) 去 super父类，那么 主构造 就 没有被 次级构造调用到了

kotlin 继承中的 构造，子类 主构造，去调用父类 主构造方法，

在 kotlin 中 如果 一个类 没有 显示 primary构造方法，并且这个类 继承 父类，那么 这个类 必须初始化父类，只有定义次级构造方法，并显示 super调用 父类的 构造方法

kotlin 不管是 重写 父类 属性 还是 方法，都要加上 overide关键字

在 kotlin 中 var 和 val 都可能是 final的 虽然编译成 java var不是，val是 final的，但是在 kotlin中 例如 var a = xxx B类重写这个 a 会报错 a 是 final的 不能重写，只能 open var a = xxx

在 kotlin中 没有 static关键字 但是 有 final关键字的，和 java的一样的，有一种情况会用到
就是 继承 重写的方法的时候，新重写的方法 是 不用再 加 open的，是可以被重写的，例如
open A (){ open name{} } B可以重写 name的，B中的 name 不用加 open 已经是 open的了 (前提是 B类是 open的)，此时如果想要 不让 B中的 name 被重写，可以为其加上 final

可以在 primary构造方法中 声明重写
class A(override val name:String) : B(name){}

var 可以 重写 val
val 不可以重写 var
原因是 var = 提供了 get set方法
val = 提供了 get方法

函数返回 赋值的 简便写法 ？？ 重要

18.kotlin也是 单继承 多实现，如果 上级 类 出现了 重复的方法，kotlin可以通过 super<指明类名> 去确切的调用

19.接口的 类 和 方法 都不用加 open 也不能定义成 final,因为 接口本来是就来给其实现的，kotlin 默认是 open的

20.kotlin抽象方法，如果继承 一个普通类，可以将普通类的方法，重写成 抽象方法
例如 A fun f{()xxx} 抽象类B：A override abstruct fun f()

21.对象声明，很多语言都有，js 就没有类，只有对象，声明对象，直接使用对象，
例如：kotlin
object Axxxx Object 替换掉 class即可

半生对象：什么是伴生对象，就是 kotlin 因为没有 static ，没法定义静态变量 方法，采取伴生对象这种手段

当然 kotlin非常推荐 在 包级别 定义 变量 和 方法，会生成新的类，里面 有 静态 final 方法，和 static final 变量

Class A{
companion object {
		val devices = HashMap<Int/* position */, Device>()
	}
}

fun main(){
	A.devices
	A.Companion.devices
}

如果不提供 伴生对象的名字，那么 默认是 Companion , 本质上Companion是 A 的 内部类，
A.devices 和 A.Companion.devices 都是 调用的实例方法，只是是 A的内部类对象实例的 里面的
属性和方法，

这不算真正的，静态方法 和 静态变量，如果真想达到 java的效果，那么
Class A{
companion object {
		@JVMSTATIC
		val devices = HashMap<Int/* position */, Device>()
	}
}

这样编译后，devices就是 static final devices 并且是在 A下面的，调用时依旧是，
A.devices

观察发现，写法都是 A.devices 所以 我们 也不用加 @Jvmstatic ，只是底层走的代码不一样，一个是
真正的静态方法，一个是类的内部类实例对象的 实例方法

还有 一个类中 只能有一个 伴生对象Companion Object 目的是 避免多个 伴生对象 出现 同名方法，
A.同名方法  引发奇异

现在有的问题：
1.对象 初始值 到底 一定要 赋值吗? 赋值手段可以有哪些
2.get set
3. val a {} val a = {} 简化写法等，，，