#.一、相对于Java,Kotlin语法整体变化简介
0.Kotlin源代码最终也会编译成.class文件,依赖于JVM来运行
但Kotlin是静态类型语言,所有变量和表达式类型在编译时已确定,
而Java支持动态绑定,可以在运行时再具体决定对象的类型。
1.Kotlin中一切皆为对象,
创建新对象构造方法前不加new关键字。
2.类型定义是后置的,类型放在":"后面
3.每句代码末尾不需要加";"(但加上也可以,编译时也是正确的)
#.二、常量与变量
//常量:隐式定义
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 定义方法的关键字是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 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()
class KotlinTest(name : String, size : Int) {
var v : Int = 0;
init {
v = size;
}
}
//构造方法创建对象
val kotlinTest = KotlinTest("name", 8)
class KotlinTest(name : String, size : Int) {
var v : Int = 0;
init {
v = size;
}
constructor(flag : Boolean) : this("name", 3){
}
constructor(name1 : String, name2 : String) : this(true){
}
}
##.继承和覆写方法
open class KotlinBaseTest {
open fun baseTest(){
}
}
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有差异。
//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
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")
}
KotlinTest3 kt = new KotlinTest3();
kt.getName1();
kt.getSize1();
kt.setSize1(4);
String name = kt.name2;
kt.size2 = 4;
kt.getInt(1, 2, true);
KotlinTest3Kt.testOut();
##.Kotlin调用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(){
}
}
val javaObj = Test3()
javaObj.name1 = "aaa"
javaObj.name = "sss"
javaObj.flag = true
javaObj.test1(3)
Test3.test2(3)
javaObj.`in`()
javaObj.`object`()