一.常量与变量
val（value 的简写）用来声明不可变的变量，类似java中的final，不可重复赋值
val <标识符> : <类型> = <初始值>
var（variable的简写）用来声明可变的变量，可被重新赋值
var <标识符> : <类型> = <初始值>
val a : String = "123"
注：也可直接写成 val a = "123" 这里的a会被自动推导成字符串变量，这是kotlin的类型推导机制
var a : String = "123"
把val 修改成var后，即可修改a的值
二.函数（方法）
函数是用来运行代码的载体
基本用法：
fun 方法名(参数) : 返回值类型{方法体}
fun是定义函数的关键字，无论定义什么函数都需要用fun声明
1.有返回值
fun domain(param1 : Int,param2 : Int) : Int{
return max(param1,param2)
}
简化写法:
fun domain(param1 : Int,param2 : Int) : Int = max(param1,param2)
2.无返回值
fun domain(param1 : Int) : Unit{
println("$param1")
}
注：Unit相当于java中的void，也可以不写
fun domain(param1 : Int){
println("$param1")
}
三.程序的逻辑控制
1.if语句
kotlin中的if语句跟java中的if语句用法基本一样
写法可不断精简
fun domain(param1 : Int,param2 : Int) : Int{
var a = 0
if (param1>param2){
a = param1
}else{
a = param2
}
return a
}
fun domain(param1: Int, param2: Int): Int {
val a = if (param1 > param2) {
param1
} else {
param2
}
return a
}
fun domain(param1: Int, param2: Int): Int {
return if (param1 > param2) {
param1
} else {
param2
}
}
fun domain(param1: Int, param2: Int): Int = if (param1 > param2) {
param1
} else {
param2
}
fun domain(param1: Int, param2: Int): Int = if (param1 > param2)
param1
else
param2
2.when条件语句
kotlin中的when语句跟java中的switch语句很相似，但却比switch强大很多
例子：有返回参数传入一个分数，返回描述
fun ScoreDescn(score:Int):String{
var descn:String;
when(score){
10 -> descn = "优"
9 -> descn = "良"
8 -> descn = "中"
7 -> descn = "可"
else -> descn = "差"
}
return descn
}
运行
fun main(){
val a = 10
ScoreDescn(a)
}
返回 "优"
无返回参数
fun ScoreDescn(score:Int){
when(score){
10 -> "优"
9 -> "良"
8 -> "中"
7 -> "可"
else -> "差"
}
}
3.循环语句
for循环 kotlin中把java中的for-i循环直接舍弃，加强了java中的for-each循环，变成了for-in循环
0到10遍历
..是创建两端闭区间的关键字 数学表达式[0,10]
for(i in 0..10){
println(i)
}
until是左闭右开区间的关键字 数学表达式[0,10)
for(i in 0 until 10){
println(i)
}
四.类
创建一个类
class Car {
}
然后定义一个变量“速度“，并在里面加上两个动作，跑和停止两个函数
class Car {
var velocity = 0
fun run(){
velocity = 10
println("这辆车的速度达到了"+velocity)
}
fun stop(){
velocity = 0
println("这辆车的速度达到了"+velocity)
}
}
然后进行实例化，kotlin中取消了new关键字
fun main(){
val car = Car()
car.velocity = 10
car.run()
car.velocity = 0
car.stop()
}
继承与构造函数
在kotlin中所有任何一个非抽象类默认都是不可以被继承的，相当于java中加了final关键字，如果需要被继承要在类的前面加上open关键字
open class Car {
.......
}
class bus : Car(){
}
kotlin中将构造函数分成了主构造函数和次构造函数
主构造函数的特点是没有函数体，直接定义在类名后面即可
class Bus(val size : Int) : Car(){
}
val bus = Bus(10)
kotlin提供了一个init结构体，所有主构造函数中的逻辑写在里面
class Bus(val size : Int) : Car(){
init {
println(size)
}
}
任何一个类可以有多个次构造函数，所有次构造函数都必须调用主构造函数(包括间接调用)，次构造函数是通过constructor关键字定义的
class Bus(val size : Int,height : Int) : Car(height){
constructor(height: Int):this(10,100){
}
constructor():this(0){
}
}
