#.一、相对于Java，Kotlin语法整体变化简介
0.Kotlin源代码最终也会编译成.class文件，依赖于JVM来运行但Kotlin是静态类型语言，所有变量和表达式类型在编译时已确定，而Java支持动态绑定，可以在运行时再具体决定对象的类型。1.Kotlin中一切皆为对象， 创建新对象构造方法前不加new关键字。2.类型定义是后置的，类型放在":"后面3.每句代码末尾不需要加";"(但加上也可以，编译时也是正确的）
#.二、常量与变量
/**
* 2.常量val与变量var。
* 2.1常量一旦初始化值就不能再更改，类似于Java中被final修饰的效果。
* 2.2可通过初始化值的方式隐式定义，也可显式定义，但必须通过某种方式静态指明类型。
* （编译时，Kotlin会根据上下文判断出变量类型）
*/
//常量:隐式定义
val value1 = 6
//常量:显式定义
val value2 : Int = 6;
//常量:显式定义，但未初始化值
val value3 : Int;
//变量:隐式定义
var value4 = 6
//变量:显式定义
var value5 : Int = 6
//变量:显式定义，但未初始化值
var value6 : Int
//变量:隐式定义
var buffer1 = StringBuffer()
//变量:显式定义
var buffer2 : StringBuffer = StringBuffer()
//变量:显式定义，但未初始化值
var buffer3 : StringBuffer##.基本数据类型
1.数值（Numbers）：包含6种，Byte、Short、Int、Long、Float、Double。2.布尔（Boolean）3.字符（Char）：与Java中不同，Kotlin中Char不属于数值类型，不能直接当做数值参与运算。4.字符串（String）5.数组（Arrays）
|
类型
|
显示转换成该类型，需要调用的方法
|
|
Byte
|
toByte()
|
|
Short
|
toShort()
|
|
Int
|
toInt()
|
|
Long
|
toLong()
|
|
Float
|
toFloat()
|
|
Double
|
toDouble()
|
|
Char
|
toChar()
|
|
String
|
toString()
|
##.数组创建和使用
/**
* 数组创建和使用
*/
// 创建方式1：使用arrayOf
val arr1 = arrayOf(1, 2, 3)
// 创建方式2：使用工厂函数创建1个数组[0,2,4]
//参数1是数组长度，参数2是初始化代码块
//对应的构造方法是public inline constructor(size: Int, init: (Int) -> T)
val arr2 = Array(3, {i -> (i * 2)})
//Kotlin已经封装好了各种基本数据类型的数组，例如ByteArray, IntArray, BooleanArray等
val arr3 : IntArray = IntArray(4)
val arr4 : IntArray = IntArray(4, {i -> (i+1)})
val arr5 = IntArray(4, {i -> (i+1)})
arr3[0] = 5;
//java中数组length对应的属性值是size
val count = arr3.size#.三、方法（或者叫函数)
模板：fun 函数名（参数名：参数类型）：返回值类型{函数体return 返回值}3.1 定义方法的关键字是fun3.2 没有定义返回值的方法，默认会返回Unit对象3.3 可以简化定义，将方法写成一个运算式的形式3.4 可以定义参数的默认值
/**
3.方法定义
模板
fun 函数名（参数名：参数类型）：返回值类型{
函数体
return 返回值
}
3.1 定义方法的关键字是fun
3.2 没有定义返回值的方法，默认会返回Unit对象
3.3 可以简化定义，将方法写成一个运算式的形式
3.4 可以定义参数的默认值
*/
//定义了返回类型
fun getString() : String{
return "abcedfg";
}
//未定义返回类型，默认返回Unit对象
fun doProcess() {
val a = 6
}
/**
* 以下三个方法等价，后两者定义成了运算式的形式，是第一个方法的简写形式
*/
fun getInt1(a : Int, b : Int, flag : Boolean) : Int{
if(flag){
return a+b
} else {
return a-b
}
}
//显式定义返回值类型
fun getInt2(a : Int, b : Int, flag : Boolean) : Int =
if(flag){
a+b
} else {
a-b
}
//因为赋值本身可以定义类型，所以可以隐式定义返回值类型
fun getInt3(a : Int, b : Int, flag : Boolean) =
if(flag){
a+b
} else {
a-b
}
/**
* 定义了有默认值的fun，第二个参数定义了默认值
*/
fun doProcess2(a : Int, b : Int = 2, flag : Boolean) {
}
fun aaa(){
/**
* 调用时，定义了默认值的参数可以不传值
* 但如果不传值的话，后面的参数传值时要额外用参数名来定义
*/
doProcess2(1, 3, true)
doProcess2(1, flag = true)
}#.四、类相关
4.1可以不定义参数和构造函数，一切使用默认形式4.2 可以为类添加参数，参数定义与方法一致，也可以定义参数默认值。4.3 可以定义构造方法，构造方法包括一个主构造函数和若干次构造函数4.4 继承父类和父类方法，需要对父类相应位置用open关键字修饰继承父类从语法形式上讲，就像定义方法的返回类型一样
##.类定义
/**
* 类定义，可以不定义参数和构造函数，一切使用默认形式
*/
class KotlinTest {
}
//构造方法创建对象
val kotlinTest = KotlinTest()
/**
* 类定义
* 2.可以为类添加参数，参数定义与方法一致，也可以定义参数默认值
*/
class KotlinTest(name : String, size : Int) {
var v : Int = 0;
/**
* 主构造函数的初始化逻辑
*/
init {
v = size;
}
}
//构造方法创建对象
val kotlinTest = KotlinTest("name", 8)
/**
* 类定义
* 3.可以定义构造方法，构造方法包括一个主构造函数和若干次构造函数
*/
class KotlinTest(name : String, size : Int) {
var v : Int = 0;
/**
* 主构造函数的初始化逻辑
*/
init {
v = size;
}
/**
* 次构造函数
* 在返回类型一栏中，要通过this调用其它某个构造函数
*/
constructor(flag : Boolean) : this("name", 3){
}
/**
* 次构造函数
* 在返回类型一栏中，要通过this调用其它某个构造函数
*/
constructor(name1 : String, name2 : String) : this(true){
}
}##.继承和覆写方法
/**
* 父类
*/
open class KotlinBaseTest {
open fun baseTest(){
}
}
/**
* 类定义
* 4.继承父类和父类方法，需要对父类相应位置用open关键字修饰
* 继承父类从语法形式上讲，就像定义方法的返回类型一样
*/
class KotlinTest(name : String) : KotlinBaseTest() {
/**
* 覆写父类方法
*/
override fun baseTest() {
super.baseTest()
}
}##.可见性修饰符
与java相比除了public/private/protected/默认类型之外，多了internal关键字。internal与public的差异是，public修饰的整个工程都可见，而internal修饰的只有module内部可见。
#.五、判断-循环语句
1.判断语句
Kotlin中when代替了Java中的Switch。Kotlin中if和when分支判断语句都是有返回值的。
val d =
if(flag){
a+b;
} else {
a-b;
}
val e = when(a){
1 -> 1334
2 -> 2333
3 -> getInt3(2,4, true)
4 -> {
val v1 = 2
val v2 = 4
v1+v2
}
else -> 7
}
2.循环语句
Kotlin中while用法与java相同。
Kotlin中for用法与Java有差异。
/**
* while语句语法与java相同
*/
/**
* for语句
* java中的for-i句式被废弃，for-each句式被Kotlin保留
* 1.支持某个定义的区间进行遍历，可以用step来指定每一步的变化
* 2.支持针对某个数据集合进行遍历
*/
//1.针对某个定义的区间进行遍历
//定义区间，递增：[0,10]
val range1 = 0..10
//定义区间，递增：[1,10)
val range2 = 0 until 10
//定义区间，递减：[10,0]
val range3 = 10 downTo 0
for(i in range1){
print(i)
}
//step后是每轮的变化值,此处每一轮i增2，可跳过区间中的某些值
for(i in 0..10 step 2){
print(i)
}
for(i in 10 downTo 0 step -2){
print(i)
}
//2.支持针对某个数据集合进行遍历，示例
val arr = intArrayOf(4, 9, 3, 1)
for(i in arr){
print(i)
}#.六、Java与Kotlin的简单的互相调用介绍
##.Java调用Kotlin
/**
* Kotlin中的定义
*/
class KotlinTest3 {
val name1: String = ""
var size1: Int = 1
@JvmField
val name2: String = ""
@JvmField
var size2: Int = 1
fun getInt(a : Int, b : Int, flag : Boolean) =
if(flag){
a+b
} else {
a-b
}
}
/**
* 定义在类闭包的外面的包级方法
*/
fun testOut(){
print("testOut")
}/**
* Java中的调用
*/
KotlinTest3 kt = new KotlinTest3();
/**
* 1.属性读写
* 1.1 val属性只读，默认可通过getXXX()来读取
* var属性可修改，默认可通过getXXX()和setXXX()来读或写
*/
kt.getName1();
kt.getSize1();
kt.setSize1(4);
/**
* 1.2 对于@JvmField修饰的属性，需直接调用
*/
String name = kt.name2;
kt.size2 = 4;
/**
* 2.方法
* 2.1 调用类中定义的方法
*/
kt.getInt(1, 2, true);
/**
* 2.2 类闭包外定义的包级函数通过[类名+Kt]来调用
*/
KotlinTest3Kt.testOut();##.Kotlin调用Java
/**
* Java中定义
*/
public class Test3 {
public String name1;
private String name;
private boolean flag;
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public void test1(int value){
}
public static void test2(int value){
}
public void in(){
}
public void object(){
}
}/**
* Kotlin中调用
*/
val javaObj = Test3()
/**
* 1.属性
* 1.1 public的属性可直接调用
*/
javaObj.name1 = "aaa"
/**
* 1.2 即使是private的属性，只要提供了对应getXXX()/setXXX方法也能直接调用
* 只提供get方法只能读，二者都提供可读可写。
*/
javaObj.name = "sss"
javaObj.flag = true
/**
* 2.方法调用
* 2.1 普通方法
*/
javaObj.test1(3)
/**
* 2.2静态方法
*/
Test3.test2(3)
/**
* 3.因为Java比Kotlin早出现，而Kotlin设计时兼容Java，
* 所以Java中的关键字在Kotlin中也是关键字，但Kotlin中的关键字未必在java中是关键字
* 若java中方法名、属性名是Kotlin中关键字，则Kotlin中调用时需用单引号''包裹
*/
javaObj.`in`()
javaObj.`object`()