Example练习-基础部分

• 函数

  • infix function

    fun main() {
    infix fun Int.times(str:String) = str.repeat(this)
    println(2 times "Bye")
    infix fun String.onto(other: String) = Pair(this, other)
    val myPair = "String1" * "String2"
    println(myPair) 
    }

  • 可变参数

    fun printAll(vararg messages: String) {
    for(m in messages) println(m)
    }
    

• 类

  class Contact(val id: Int, var email: String)
  fun main() {
  val contact = Contact(1, "string1")
  contact.email = "string2"
  println(contact.email)
  }
  

  class Student(name:String, age:Int, gender:String, grade:Int):Person(name,age,gender){
   constructor(name:String, age:Int, gender:String, grade:Int):this(name,age,gender,3)
   constructor():this(name,age,gender)
  }//次构造函数都要直接或者间接地调用主构造函数
  

• 泛型

  class MutalbleStack<E>(vararg items:E) {
   private val elements = items.toMutableList()
   fun push(element:E) = elements.add(element)
   fun peek() : E = elements.last()
   fun pop() : E = elements.removeAt(element.size - 1)
  }
  fun <E> mutableStackOf(vararg elements: E) = MutableStack(*elements)
  fun main() {
  val stack = mutableStackOf(0.62, 3.14, 2.7)
  println(stack)
  }
  

• 继承

  open class Animal {
    open fun bark() {
        print(" ")
    }
  }
  class Dog : Animal() {
    override fun bark() {
        println("wang wang")
    }
  }
  fun main() {
    val dog = Dog()
    dog.bark()
  }
  

  open class Tiger(val origin: String) {
    fun sayHello() {
        println("A tiger from $origin says: grrhhh!")
    }
  }
  class SiberianTiger : Tiger("Siberia")
  fun main() {
  val tiger = SiberianTiger()
  tiger.sayHello()
  }
  

• 控制流

  • when

    fun cases(number:Int):Any {
    val result = when(number) {
     10 -> "big"
     1 -> "small"
     else -> "middle"
    }
    return result
    }
    fun main() {
    println(cases(1))
    }
    

  • 循环

    val animalList = listOf("dog","cat","snake")
    for(animal in animalList){
    println("$animal is barking")
    }
    

    ```kotlin class Animal(val name: String) class Zoo(val animals:List) { operator fun iterator():Iterator { return animals.iterator() } }

fun main() { val zoo = Zoo(listOf(Animal(“zebra”), Animal(“lion”))) for (animal in zoo) { println(“Watch out, it’s a ${animal.name}”) } val animalIterator = zoo.iterator() while(animalIterator.hasNext()){ println(animalIterator.next().name) } }

   - 相等性判断
```kotlin
fun main() {
    val list1 = listOf("1","2","3")
    val list2 = listOf("3","2","1")
    println(list1==list2)//false
    println(list1===list2)//false
}
//因为list是有序的所以==判断时不相等
fun main() {
    val set1 = setOf("1","2","3")
    val set2 = setOf("3","2","1")
    println(set1==set2)//true
    println(set1===set2)//false
}
//==相当于if(set1==null) set2==null else set1.equals(b) 只是对内容判断,忽略顺序;而===是引用相等判断

• 条件运算符

  fun max(a:Int,b:Int) = if(a>b) a else b
  println(max(99, -42))
  

• 特殊类

  • 数据类 ```kotlin data class User(val name: String, val id:Int) { override fun equals(other: Any?) = other is User && this.id == other.id } fun main() { val user = User(“Alex”, 1) println(user) val secondUser = User(“Alex”, 1) val thirdUser = User(“Max”, 2) println(user == secondUser) println(user == thirdUser) //hashCode() println(user.hashCode())
    println(secondUser.hashCode()) println(thirdUser.hashCode()) //copy() println(user.copy()) println(user === user.copy()) println(user.copy(“Max”)) println(user.copy(id = 3))

    println(user.component1()) println(user.component2())

}

   - 枚举类
```kotlin
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF),
    YELLOW(0xFFFF00);
    fun containsRed() = (this.rgb and 0xFF0000 != 0)
}

fun main() {
    val red = Color.RED
    println(red)                                      // 4
    println(red.containsRed())                        // 5
    println(Color.BLUE.containsRed())                 // 6
}

• 密封类,只有在同一个包中的才可以继承 ```kotlin sealed class Mammal(val name: String) class Cat(val catName:Stirng) : Mammal(catName) class Human(val humanName:String,val job:String):Mammal(humanName) fun greetMammal(mammal: Mammal) : String { when (mammal) { is Human -> return “Hello ${mammal.name}; You’re working as a ${mammal.job}” is Cat -> return “Hello ${mammal.name}”//不需要加else,因为所有可能的情况都已经包括了 } }

fun main() { println(greetMammal(Cat(“Snowy”))) }

   -  object关键字,用来保证只有一个实例,如果需要引用该对象,直接使用其名称即可
```kotlin
fun rentPrice(standardDays: Int, festivityDays: Int, specialDays: Int): Unit{
    val dayRates = object {
        var standard: Int = 30 * standardDays
        var festivity: Int = 50 * festivityDays
        var special: Int = 100 * specialDays
    }

    val total = dayRates.standard + dayRates.festivity + dayRates.special 
    println("Total price: $$total")
}

fun main() {
    rentPrice(10,2,1)
}

object DoAuth {
    fun takeParams(username: String, password: String) {
        println("input Auth parameters = $username:$password")
    }
}

fun main() {
    DoAuth.takeParams("foo", "qwerty")
}

• 伴生对象companion objects,可以直接通过类名来调用对象的成员 ```kotlin class BigBen { companion object Bonger { fun getBongs(times:Int){

    for(i in 1..times) {
       print("BONG")
    }
  

  } } }

fun main() { BigBen.getBongs(12) }

   -  高阶函数
```kotlin
fun calculate(x:Int, y:Int, operation:(Int,Int)-> Int) : Int{
  return operation(x,y)
}
fun sum(x:Int, y:Int) = x + y
fun main() {
    val sumResult = calculate(1,2,::sum)
    val mulResult = calculate(1,2) { a ,b -> a * b }
    println("sumResult $sumResult, mulResult $mulResult")
}

fun operation(): (Int) -> Int {
    return ::square
}
fun square(x:Int)=x*x
fun main() {
    val func = operation()
    println(func(2))
}

• Lambda

  fun main() {
  val upperCase1: (String) -> String = { str:String -> str.uppercase() }
  val upperCase2: (String) -> String = { str -> str.uppercase() }
  val upperCase3 = { str:String -> str.uppercase() }
  //val upperCase4 = { str->str.uppercase() } 报错需要精确类型
  val upperCase5:(String) -> String = { it.uppercase() }
  val upperCase6:(String) -> String = String::uppercase
  }
  

• 拓展函数及拓展属性 ```kotlin data class Item(val name: String, val price: Float) data class Order(val items:Collection) fun Order.maxPricedItemValue() : Float = this.items.maxByOrNull {it.price}?.price?:0F fun Order.maxPricedItemName() = this.items.maxByOrNull { it.price }?.name ?: “NO_PRODUCT” val Order.commaDelimitedItemNames: String get() = items.map {it.name}.joinToString() fun main() { val order = Order(listOf(Item(“Bread”,25.0F),Item(“Wine”,29.0F), Item(“Water”, 12.0F))) println(“${order.maxPricedItemName()}”) println(“${order.maxPricedItemValue()}”) println(“Items: ${order.commaDelimitedItemNames}”)

}

```kotlin
fun <T> T?.nullSafeToString() = this?.toString ?:"NULL"
fun main() {
    println(null.nullSafeToString())
    println("Kotlin".nullSafeToString())
}