前言

关于Kotlin与Java语法对比总结。

一、变量

1、 val（value）声明不可变量，初始赋值后，不能重新赋值相当于Java中的final变量
2、 var（variable）声明可变变量
3、 优先使用val声明变量
4、 类型推导机制：不用说明变量类型（隐式：val a = 10）
5、 显示声明变量类型：val a: Int = 10
6、 Kotlin每一行代码结尾不加分号
7、 对象数据类型：（Int、Long、Short、Float、Double、Boolean、Char、Byte）首字母大写

二、函数

1、 定于函数语法规则：
	fun methodName（param1：Int, param2：Int)：Int{ 
   
	return 0
	}
2、 函数不需要返回任何数据，返回类型可以不写
3、 语法糖（简化代码）：fun methodName（param1：Int, param2：Int)：Int = max（num1,num2）

三、程序的逻辑控制

1、条件语句

1、 Kotlin中条件语句实现方式有两种：if和when
2、 Kotlin中的if语句与Java中的if语句几乎没有任何区别！ 唯一区别是Kotlin中的if语句有返回值！
3、 语法糖：当一个函数只有一行代码时，可以省略函数体部分，直接将这一行代码使用等号串联在函数定义的尾部。
4、 Kotlin中的when语句有点类似Java中的switch语句，但又比switch强大很多。
5、 Java中switch语句的缺点：判断条件只能是整型、短于整型的变量、字符串变量。
6、 使用when实现成绩查询函数：
	fun getScore（name: String） = when（name）{ 
   
		“Tom” -> 86
		“Jim” -> 77
		“Jack” -> 95
		“Lily”-> 100
		else -> 0
	}
7、 when语句和if语句一样，也是有返回值的。
8、 when语句允许传入一个任意类型的参数。
9、 when语句的条件格式：匹配值 -> { 
    执行逻辑 }，当执行逻辑只有一行代码时，{ 
   }可以省略。
10、when语句还允许类型匹配：
	fun checkNumber（num: Number）{ 
   
		when（num）{ 
   
			is Int -> println（“number is Int”）
			is Double -> println（“number is Double”）
			else -> println（“number not support”） 
		}
	}
11、 is关键字就是类型匹配的核心，它相当于Java中的instanceof关键字
12、 Int、Long、Float、Double等与字相关的类，都是Number的子类。
13、when语句还有一种不带参数的用法，扩展性很强：
	fun getScore（name: String） = when（name）											{ 
   
		name == “Tom” -> 86
		name == “Jim” -> 77
		name == “Jack” -> 95
		name == “Lily”-> 100
		else -> 0
	}
14、Kotlin中判断字符串或对象是否相等可以直接使用==关键字，不用Java那样使用equals（）。

2、循环语句

1、 Kotlin与Java都提供了while和for两种循环，while循环二者语法、用法一模一样。
2、 Kotlin取消了Java中的for-i循环，加强了for-each循环成为了Kotlin中的for-in循环。
3、 区间[0,10] 用Kotlin语法实现val range = 0..10
4、 区间[0,10）用Kotlin语法实现val range = 0 until 10
5、 for-in遍历该[0,10]区间：
	fun main（）{ 
   
		for （i in 0..10）{ 
   
			println（i）
		}
	}
6、 for-in循环每次递增1，用step改变递增跨度：
	fun main（）{ 
   
		//递增跨度改成2
		for （i in 0 until 10 step 2）{ 
   
			println（i）
		}
	}
7、 ..和until关键字都要求区间的左端小于等于区间右端。
8、 前面都是升序区间，创建一个降序区间：
	fun main（）{ 
   
		for （i in 10 downTo 1）{ 
   
			println（i）
		}
	}
9、 提问：降序如何实现半开半闭区间？

四、面向对象编程

1、类与对象

1、 Kotlin中也使用class关键字来声明一个类，这一点和Java一样。
2、 创建一个类：
	class Person{ 
   
		var name = “”//用var声明可变变量，为赋值使用
		var age = 0
		fun eat（）{ 
   
			println（name+”is eating.He is ”+age+”years old.”）
		}
	}
3、 Kotlin的类实例化 val p = Person（）相比Java取消了new关键字
4、 Kotlin本着最简化的设计原则，将诸如new、行尾分号不必要的语法结构都取消啦！

2、继承

1、 Kotlin中任何一个非抽象类默认都是不可被继承的，相当于Java给类声明了final关键字。
2、 Java中如果一个类不是专门为继承设计的，就应该加上final声明，禁止它被继承。
3、 抽象类本身无法创建实例，一定由子类去继承才能创建实例，因此抽象类必须可以被继承。
4、 Kotlin的抽象类与Java的抽象类并无区别。
5、 实现继承需要两个步骤：
	open class Person { 
   
		...
	}
6、 Java中继承的关键字是extends而Kotlin变成了一个冒号。
	class Student : Person（）{ 
   
		var sno = “”
		var grade = 0
	}

3、构造函数

1、 Kotlin的构造函数分为两种：主构造函数和次构造函数
2、 主构造函数特点是没有函数体。
3、 语法结构：class  Student（val sno: String, val grade: Int）: Person（）{ 
       }
	实例化：val student = Student（“a123“, 5）

4、 主构造函数编写的的逻辑结构可以放在init结构体：
	class Student（val sno: String, val grade: Int）:Person（）{ 
   
		init{ 
   
			println（“sno is” + sno）
			println（“grade is ” + grade）
		}
	}
5、 Person类后面的空括号表示要去调用Person类中的无参构造函数
6、 如果Person中无参构造函数有了参数，子类也要加入参数：
	class Student（val sno: String, val grade: Int, name: String, age: Int）:Person（name,age）{ 
   }
7、 任何一个类只能有一个主构造函数，可以有多个次构造函数，次构造函数也可以实例化，且有函数体。
8、 Kotlin规定，当一个类既有主构造函数又有次构造函数，所有次构造函数必须直接或间接调用主构造函数。
9、 class Student（val sno: String, val grade: Int, name: String, age: Int）:Person（name,age）{ 
   
		constructor（name: String, age: Int）:this（“”, 0, name, age）{ 
   
		}
		constructor（）：this（“”,0）{ 
   //调用了第一个次构造函数name与age初始化
		}
	}
10、特殊情况：没有主构造函数只有次构造函数：
	class Student: Person{ 
   //Student类没有显示定义主构造函数，故继承Person类不需要加括号
		constructor（name:String,age:Int）:super(name,age){ 
   
		}//没有主构造函数，只能直接调用父类构造函数（this换成super）
	}

4、接口

1、 Kotlin和Java相同，最多只能继承一个父类，但可实现多个接口用于实现多态编程。
2、 接口的函数不要求有函数体。
3、 接口的定义：
	interface Study{ 
   
		fun readBooks（）
		fun doHomework（）
	}
4、 Kotlin的继承父类与实现接口的区别：
	class Student （name:String,age:Int）:Person（name,age）,Study{ 
   
		Override fun readBooks（）{ 
   
			println（name+”is reading”）
		} 
		Override fun doHomework（）{ 
   
			println（name+”is doing homework”）
		}
	}
5、 多态：面向接口编程
	fun main（）{ 
   
		val student = Student（“Jack”,19）
		doStudy（student）
	}
	fun doStudy（study: Study）{ 
   
		study.readBooks（）
		study.doHomework（）
	}
6、 Kotlin额外功能：对接口中定义的函数默认实现：
	interface Study{ 
   
		fun readBooks（）//强制实现
		//选择实现
		fun doHomework（）{ 
   
			println（“default!!!”）
		}
	}

#Java和Kotlin函数可见性修饰符对照表：

5、数据类与单例类

1、  data关键字：类前面声明data,表明其是一个数据类，主构造函数会自动重写equals（）、hashCode（）、toString（）等等。
2、 当一个类中没有任何代码时，还可以将尾部的大括号省略。
3、 Kotlin中特有功能——单例类。
4、 单例模式：避免创建重复的对象，希望某个类在全局最多只能拥有一个实例。
5、 Kotlin实现单例类： 
	object Singleton{ 
   
		singletonTest（）{ 
   
			println（“singletonTest is OK”）
		}
	}
	//调用单例类中的函数
	Singleton.SingletonTest（）

五、Lambda编程

1、集合的创建与遍历

1、 Java中List、Set、Map在Java中都是接口
	**List主要实现类ArrayList**  	**Set主要实现类HashSet**  	**Map主要实现类HashMap**
2、 Kotlin内置listOf（）函数，创建一个不可变集合，简化初始化集合方法：
	val list = listOf（“Apple”,”Banana”,”Orange”,”Pear”） 
3、 mutableListOf（）创建可变集合。
4、 set集合在Kotlin中的用法setOf（）、mutableSetOf（）。注：Set集合不可存放重复元素。
5、 Map集合用法：
	第一种：val map = HashMap<String,Int>（）
	map[“Apple”] = 1
	map[“Orange”] = 2
	map[“Banana”] = 3
	//使用
	val number = map[“Apple”]
	第二种：val map = mapOf（“Apple” to 1,”Orange” to 2,”Banana” to 3）

2、集合的函数式API

1、 函数式API的语法结构（Lambda表达式）：
	{ 
   参数名1：参数类型，参数名2：参数类型->函数体}
2、 Lambda表达式就是一小段可以作为参数传递的代码
3、 简化过程：
	val maxLengthFruit = list.maxBy（{ 
   fruit:String -> fruit.length}）
	val maxLengthFruit = list.maxBy（）{ 
   fruit:String -> fruit.length}
	val maxLengthFruit = list.maxBy { 
   fruit:String -> fruit.length}
	val maxLengthFruit = list.maxBy { 
   fruit -> fruit.length}
	val maxLengthFruit = list.maxBy { 
   it.length}
4、 map函数最常用的一种函数式API，实现对集合中的元素进行任意的映射转换。
	list.map { 
    it.toUpperCase（）}
5、 filter函数过滤集合数据：
	list.filter{ 
    it.length <= 5}
6、 any函数判断集合中是否至少存在一个元素满足指定条件
7、 all函数判断集合中是否所有元素都满足条件

3、Java函数式API的使用

1、单抽象方法来实现

六、空指针检查

1、可空类型系统

1、 Kotlin默认所有参数和变量都不可为空
2、 类名后面加？表示可空，例如：Int?  String?
	fun doStudy（study:Study?）{ 
   
		if（study != null）{ 
   
			study.readBooks（）
			study.doHomework（）
		}
	}

2、判空辅助工具

1、 ？.操作符：对象不为空时正常调用相应方法，当对象为空什么都不做。
2、 ？.代替if判断：
	fun doStudy（study:Study?）{ 
   
		study？.readBooks（）
		study？.doHomework（）
	}
3、 ？：操作符：左右两边都接收一个表达式，左边结果不空，就返回左边，否则就返回右边。
4、 风险写法：强制通过编译，使用非空断言工具，明确表明对象不会为空。
5、 辅助工具let（）函数：解决全局变量判空问题。

七、Kotlin小技巧

1、字母串内嵌表达式

1、 Kotlin字符串内嵌表达式的语法：“hello, ${ 
   obj.name}. nice to meet you!”
	举例：  val brand = “Samsung”
			val price = 1299.99
			println（“Cellphone（brand = $brand, price =$price）”）

2、函数的参数默认值

1、 双参数第二个默认值简单，但第一个默认值，则采用键值对传参,不会混乱。

八、附带ANDROID系统学习框架图

总结

求知若渴，虚心若愚，欢迎指正，后续会修改完善！

今天的文章kotlin和java性能对比_kotlin语法分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。