kotlin 基础 是-函数式编程思想

val 是常量
var 是变量

声明常量：
fun main(args: Array<String>) {
  val a: Int = 1  // 立即初始化
  val b = 2   // 推导出Int型
  val c: Int  // 当没有初始化值时必须声明类型
  c = 3       // 赋值
  println("a = $a, b = $b, c = $c")
}
变量：

fun main(args: Array<String>) {
  var x = 5 // 推导出Int类型
  x += 1
  println("x = $x")
}

var 可以定义任何类型
    var a = 1
    var b = "1"
    var c = 1.2f
    var e = 12455
    var d = true
    var f = 'a'
    var g = 2342349072309

 //定义一个boolean类型变量 赋值为true
    var isEmpty: Boolean = true

//$可以直接塞入有值的变量

    print("$a")

打印
1

扩展

    print("this maxof is ${maxOf(9,2)}")


  fun maxOf(a: Int, b: Int) = if (a + b > 10) a else b

打印 
    this maxof is 9

类型之间的转换
    var bt: Int = 532
//    var aa: String = bt;// ERROR
    val toString = bt.toString()

    print(toString)


 var i = str!!.length; !! 操作符 如果str会null,
那么系统就会抛出KotlinNullPointerException

  var nullStr = null;
    var str: String? = "xxxx"//加上?表示可以为null

    // str = nullStr  //error不许null来赋值

    str = nullStr //可以赋值,但是会有颜色的提醒他是null的

    var i = str?.length; // str==null 如果用?来表示会返回null ,不会抛异常

    println(i) 
  
以前
if(Employee!=null &&  Employee.name!=null){
   int  i=Employee().name.length
}

  //这样就直接连续判断是否为null
   var i = Employee()?.name?.length
    println(i)  


以前的三目运算符
String b = (a != null) ? a : "";

现在这样就可以判断
    var ggg = str ?: "ccc"; //如果为null就返回ccc

fun foo(node: Node): String? {
  val parent = node.getParent() ?: return null //返回null
  val name = node.getName() ?: throw IllegalArgumentException("name expected")//为null直接抛异常  
}  
  三目判断
  var ggg = if (str.equals("a")) str else "ccc";



``
open 修饰符
Kotlin 默认会为每个变量和方法添加 final 修饰符。这么做的目的是为了程序运行的性能，其实在 Java 程序中，你也应该尽可能为每个类添加final 修饰符( 见 Effective Java 第四章 17 条)。 
为每个类加了final也就是说，在 Kotlin 中默认每个类都是不可被继承的。如果你确定这个类是会被继承的，那么你需要给这个类添加 open 修饰符。


 internal 修饰符

写过 Java 的同学一定知道，Java 有三种访问修饰符，public/private/protected，还有一个默认的包级别访问权限没有修饰符。
在 Kotlin 中，默认的访问权限是 public。而多增加了一种访问修饰符叫 internal。它是模块级别的访问权限。
何为模块(module)，我们称被一起编译的一系列 Kotlin 文件为一个模块。在 IDEA 中可以很明确的看到一个 module 就是一个模块，当跨 module 的时候就无法访问另一个module 的 internal 变量或方法。
  

 /**
    Objects中定义的成员类似于Java中的静态成员
    
    可以使用@JvmStatic使Companion object的成员真正成为静态成员
    Object expression是马上执行的
    Object declaration是lazy的，在第一次使用时执行
    Companion Object是在类第一次加载时执行
     */

companion object {
val BLANK = -1
val WEATHER = 0
val TOP = 1
val READ = 2
}

循环

val names = arrayOf("Jake", "Jill", "Ashley", "Bill")

for (name in names) {
   // println(name)
}


var i = 0;
while (names.size > i) {
    println(names[i])
    i++;
}

打印
Jake
Jill
Ashley
Bill

if 可以有返回值的

  var ggg = if (str.equals("a")) {
        "bb"
    } else {
        "ccc";
    }
    print(ggg)

打印
ccc
``  

在 Kotlin 中，用 is 来判断一个对象是否是某个类的实例，用 as 来做强转。

var str = null;
if (str is String) {//判断是否为同一个类型;

// print("str is String type")
}

var i = 555
var sss= str as? Int //as 强制转换

print(sss)

集合

val numbers: MutableList<String> = mutableListOf("1","2")
numbers.add("3")
numbers.remove("3")
println(numbers)  

打印
[1, 2]