kotlin学习

kotlin方法一般不能接受空值,硬加能接受空值 就必须加?

fun method(value : String ?){
println(value)
}
 
 
 var nums = 1..100表示1到100的数组
var nums1= 1 until 100 表示1到99的数组
for( a in nums step 2 ){
println(a)
}

会显示13 579    step表示跳几个元素

nums.reversed()  表示翻转
var list = listOf("aaa","bbb","ccc")
for((i,e) in list.withIndex()){  //带下表的增强遍历数组
println("$i $e")
}

声明方法的一行写法

fun addValue(x:Int ,y:Int):Int = x+y

还有一种函数表达式的写法

var i= {x:Int,y:Int->x+y}
var result = i(3,5)
var j:(Int,Int)->Int ={x,y->x+y}
var result1 = j(3,5)

具名参数用法

val Pi= 3.14159f

fun 获取圆的周长(PI:Float=Pi,半径:Float){
return  2*PI*半径
}

PI在还没被调用的时候就被赋值了,叫默认参数

如果调用的时候不填,默认就是 3.14159f

在明知道PI的值的时候,可以只赋值半径

但是var area=获取圆的周长(2.0f)

这样是会报错的

正确写法是var area=获取圆的周长(半径=2.0f)

    这就叫具名参数

类要被继承  必须前面加open

方法允许被重写也要加关键字open

例如 open class Father{
var chactor ="内向"
open fun action(){
println("啦啦啦啦啦")
}
}
 
class Son :Father(){
 
override  fun action(){
println("儿子说话了")
}
}
 
fun main(args :Array<String>){
var son1= Son()
println("儿子在${son1.chactor)}")
son1.action()
}

抽象类的定义和java一样 方法也要抽象

abstract class Human(var name: String){
abstract fun eat()
}

接口是事物的能力

抽象类反应事物的本质

interface    IMan {
fun xiaodidi()
}
abstract class Human{
abstract   fun eat(){}
}
class  Man : Human(),IMan{
override fun xiaodidi(){
println("dasdasdasd")
}
override fun eat(){
println("dasdasdasda")
}
}

继承要带括号   实现不需要

代理
interface IWashing{
fun washing()
}
class son :IWashing {
override fun washing(){
println("儿子洗碗")
}
}
 class Father :IWashing by Son(){
override fun washing(){
println("爸爸开始洗碗")
Son().washing()
println("儿子替爸爸把碗洗好了")
}
}

通过by 来让别人代理自己做事

单例设计模式

只要把class 换成object就行,如果是单例 引用的时候就不需要加括号

object son :IWashing {
override fun washing(){
println("儿子洗碗")
}
}
 class Father :IWashing by Son{
override fun washing(){
println("爸爸开始洗碗")
Son.washing()
println("儿子替爸爸把碗洗好了")
}
}

枚举

enum class Week{

星期一,星期二,星期三,星期四,星期五

}

印章类

sealed class Son{
fun sayHello(){
println("大家好!")
}
class xiaoA():Son()
class xiaoB():Son()
}

fun main(args:Array<String>){
var s: Son= Son.xiaoA()
var v:Son= Son.xiaoB()
var d:Son = Son.xiaoA()
var list = listOf<Son>{s,v,d}
for(q in list){
if(q is Son.xiaoA){
q.sayHello()}
}
}

is  相当于 java的instanceof

kotlin中的单利

class MyApplication private constructor() : Application() {
  companion object {
     val instance :MyApplication by lazy{ 
       MyApplication()
     }
  }
}

private constructor～私有话构造方法，禁止手动创建对象； 
companion object～伴生对象，每个类都可以实现一个伴生对象，它是该类的所有实例共有的对象。它将类似于Java中的静态字段; 
by lazy～懒加载， 可以在我们使用这个对象时再对其创建。