快速入门kotlin

变量和函数

变量

// val 用来声明一个不可变的变量，对应java中的final
val a = 10

// var 用来声明一个可变的变量,不用声明变量类型
var a = 10

// 显示声明变量类型使用 : 变量类型
// 变量类型有： Int Long Short Float Double Boolean Char Byte
val a : Int = 10

函数

// 声明一个函数，并指定参数以及返回类型
fun methodName (param1: Int, param2: Int) : Int {
	return param1 + param2
}

// 当一个函数体内只有一行代码时，Kotlin允许我们不必编写函数体，可以直接将唯一的一行代码卸载函数定义的尾部，中间用等号连接即可，使用这种语法，return关键字也可以是省略了。
fun addNumbers(num1 : Int, num2 : Int) : Int = num1 + num2

逻辑控制

if条件语句

fun largerNumber(num1: Int, num2 : Int) : Int {
	var value = 0
	if (num1 > num2) {
		value = num1
	} else {
		value = num2
	}
	return value
}

// kotlin中的if是可以有返回值的，所以上面代码可以优化如下：
fun largerNumber(num1: Int, num2 : Int) : Int {
	return if (num1 > num2) {
		num1
	} else {
		num2
	}
}

// 结合kotlin函数的语法糖，进一步优化代码
fun largerNumber(num1: Int, num2 : Int) : Int = if (num1 > num2) num1 else num2

when条件语句

// when的格式为
// when (参数) {
//	匹配值  -> { 执行逻辑 }  // 当执行逻辑只有一行代码时，{}可以省略
//	匹配值  -> { 执行逻辑 }
//	匹配值  -> { 执行逻辑 }
//	匹配值  -> { 执行逻辑 }
//	else -> {执行逻辑}
// }

// when和if语句一样，都可以有返回值，因此我们仍然可以使用单行代码函数的语法糖
fun getScore(name : String) = when (name) {
	"Tom" -> 86
	"Jim" -> 77
	"Jack" -> 95
	"Lily" -> 100
	else -> 0
}

// 除了精准匹配以外，when语句还允许进行类型匹配：
fun checkNumber(num: Number) {
	when(num) {
		is Int -> println("number is Int")
		is Double -> println("number is Double")
		else -> println("number not support")
	}
}

// when还有不带参数的用法
fun getScore(name : String) = when  {
	name == "Tom" -> 86
	name == "Jim" -> 77
	name == "Jack" -> 95
	name == "Lily" -> 100
	else -> 0
}

循环语句

// while 循环跟 java的 while循环用法一模一样，这里不做多的说明。
while(bol) {
	// todo
}

// for-i循环被kotlin直接舍弃

// for-in循环
var range = 0..10 // 在kotlin中可以用 .. 表示一个区间,且两端都是闭区间
for(i in range) {
	println(i)
}

valr range2 = 0 until 10 // kotlin使用 until 表示一个左闭右开的区间，表示 0 到 9

// 默认情况下，for-in循环每次执行循环时会在区间范围内递增1，相当于java for-i 中的 i++的效果，如果你想跳过一些元素，可以使用step关键字
for (i in 0 until 10 step 2) {
	println(i) // 这里代码表示在遍历[0,10)这个区间的时候，每次执行循环都会在区间范围内递增2，相当于for-i 循环中的 i = i + 2的效果，最后打印出来的值为 0 2 4 6 8
}

// 如果想创建一个降序区间，可以使用downTo关键字
for (i in 10 downTo 1) {
	println(i) // 打印的值为 10 9 8 7 6 5 4 3 2 1 ,降序区间也可以结合step使用
}

类与对象

// 创建一个类
class Person{
	var name = ""
	var age = 0
	fun eat () {
		println(name + " , " + age)
	}
}

// 创建一个对象，类的实例化
val p = Person() // 不需要new关键字
p.name = "jack"
p.age = 18
p.eat()

继承与构造函数

继承

// kotlin任何一个非抽象类默认都是不可以被继承的，相当于Java中给类声明了final关键字
// 在类前面加关键字open可以让它被继承
open class Person{} // Person 可以被继承

// Java中继承的关键字是extends，而kotlin中变成了一个冒号
class Student : Person() {}

主构造函数

// 每个类都会有一个不带参数的主构造函数，当然你也可以显示的给它指明参数，主构造函数的特点是没有构造体！
class Teacher(val name: String, age: Int) : Person() {}

// 主构造函数没有函数体，如果你想在主构造函数中编写一些逻辑，kotlin为我们提供了一个init结构体，所有的主构造函数的逻辑都可以写在这里
class Teacher (val name: String, val age: Int) : Person() {
	init {
		println(name)
		println(age)
	}
}

// Java继承特性中有一个规定，子类中的构造函数必须调用父类中的构造函数，这个规定kotlin中也要遵守，因为kotlin的主构造函数没有函数体，无法调用父类的构造函数，所以kotlin中的继承如上面代码显示的那样，通过 : Person() 的形式一来继承Person类，二来调用父类Person的构造函数。

// 如果父类的主构造函数中也接收了参数，那么我们继承的时候子类主构造函数中就要添加父类需要的参数,再将这两个参数传递给父类
open class Person(val name: String, val age: Int) {} // 父类

class Student(val sex: String, val score: Int, name: String, age: Int) : Person(name, age) {} // 子类

// Student类的主构造函数中增加了name跟age字段，不能再将他们声明为val或者var，因为主构造函数中的val或者var声明的参数将自动成为该类的属性，这就会导致和父类中的同名属性name和age发生冲突。

次构造函数

// 任何一个类只能有一个主构造函数，但可以有多个次构造函数，次构造函数是可以有函数体的，所有次构造函数都必须调用主构造函数
// 次构造函数是通过constructor关键字定义，它又通过this关键字调用主构造函数

class Student (val sex: String, val score: Int, name, age) : Person(name, age) {
	constructor(name: String, age: Int) : this("", 0, name, age) {
		// 这里次构造函数接收name和age两个参数，又通过this关键字调用了主构造函数，并将sex与score这两个参数赋值成初始值
	}
}

// 现在我们有了两种形式来对Student类进行初始化
val stu1 = Student("男", 19)
val stu2 = Student("女", 5, "Jack", 19)


// 还有一种特殊情况，类中只有次构造函数，没有主构造函数，当一个类没有显示的定义构造函数且定义了次构造函数时，它就是没有主构造函数的。
class Student : Person {
	constructor(name: String, age: Int) : super(name, age) {
		// 因为没有主构造函数，所以继承Person类的时候就不需要再加上括号了，由于没有主构造函数，次构造函数只能直接调用父类的构造函数，所以kotlin把this关键字换成了super关键字。
	}
}

接口

// kotlin使用interface关键字定义接口，接口中的函数不要求有函数体
interface Study() {
	fun readBook()
	fun doHomeWork()
}

// kotlin中统一使用冒号：实现接口,继承与实现接口之间使用逗号分隔,接口后面不需要加括号，它没有构造函数
class Student(name: String, age: Int) : Person(name, age), Study {
	override fun readBook() {}
	override fun doHomeWork(){}
}

函数的可见性修饰符

kotlin中有4中函数的可见性修饰符：public，private，protected，internal，直接定义在fun关键字前面即可。

• private：表示只对当前类内部可见
• public：表示对所有类可见，在kotlin中是默认项
• protected：在kotlin中表示只对当前类和子类可见
• internal：只对同一模块内可见，比如我们开发了一个模块给别人使用，但有一些函数只允许在模块内部调用，不想暴露给外部，就可以将这类函数声明成internal

单例类

在kotlin中创建一个单例类的方式及其简单，只需要将class关键字改成object关键字即可

object Singleton{
	fun singletonTest() {
		println("singletonTest")
	}
}

// 调用单例类中的函数很简单，类似于java中静态方法的调用
Singleton.singletonTest() // 这种写法看上去像静态方法调用，但kotlin在背后自动帮我们创建了一个Singleton类的实例，并且保证全局只存在一个Singleton实例