1.接口
interface Movable {var maxSpeed: Intvar wheels: Intfun move(movable: Movable): String}class Car(var name: String, override var wheels: Int = 4, _maxSpeed: Int) : Movable {override var maxSpeed: Int = _maxSpeedget() = fieldset(value) {field = value}override fun move(movable: Movable): String {TODO("Not yet implemented")}}fun main() {val car = Car("1",4,8)println(car.maxSpeed)
}1.1 接口属性默认实现
interface Movable {val maxSpeed: Intget() = (1..500).shuffled().first()//相当于给这个属性赋值 每次不一样但他不是修改它 只是修改了它的get方法 所有只读变量不可赋值var wheels: Intfun move(movable: Movable): String}class Car(var name: String, override var wheels: Int = 4) : Movable {override val maxSpeed: Intget() = super.maxSpeedoverride fun move(movable: Movable): String {TODO("Not yet implemented")}}fun main() {val car = Car("1",4)println(car.maxSpeed)println(car.maxSpeed)println(car.maxSpeed)println(car.maxSpeed)
}2.抽象类
abstract class Gun(val range:Int){abstract fun pullTrigger():String
}abstract class Gun1(val a:Int){abstract fun pullTrigger():String
}
class AK47(val price:Int):Gun(range = 80),Movable{override fun pullTrigger(): String {return "AK47 shooting"}override var wheels: Intget() = TODO("Not yet implemented")set(value) {}}3.泛型
class MagicBox<T> (item:T){var subject:T = item}class Boy(val name:String,val age:Int)class Dog(val weight:Int)fun main() {val magicBox1 = MagicBox(Boy("Jack", 20))val magicBox2 = MagicBox(Dog( 20))println(magicBox1.subject is Boy)println(magicBox2.subject is Dog)}4.泛型函数
class MagicBox<T> (item:T){var subject:T = itemvar available = falsefun fetch():T?{return subject.takeIf { available } //true返回 this false返回null}}class Boy(val name:String,val age:Int)class Dog(val weight:Int)fun main() {val magicBox1 = MagicBox(Boy("Jack", 20))val magicBox2 = MagicBox(Dog( 20))magicBox1.available =trueprintln(magicBox1.fetch())magicBox2.available=trueprintln(magicBox2.fetch())magicBox2.fetch()?.run {println("you find $weight")}
}5.多泛型参数
class MagicBox<T>(item: T) {var subject: T = itemvar available = falsefun fetch(): T? {return subject.takeIf { available } //true返回 this false返回null}//return -> Rfun <R> fetch(subjectModFunction: (T) -> R): R? {return subjectModFunction(subject).takeIf { available }}
}class Boy(val name: String, val age: Int)class Dog(val weight: Int)fun main() {val magicBox1 = MagicBox(Boy("Jack", 20))magicBox1.available =trueval fetch = magicBox1.fetch {Boy("男人", 30)}println(fetch)println(fetch?.name)println(fetch?.age)
}6.泛型类型的约束
7. vararg关键字与get函数
vararg相当于Java的可变参数 Int ... age 类似效果
class MagicBox<T:Human>( vararg item: T) {var subject: Array<out T> = itemvar available = falsefun fetch(index:Int): T? {return subject[index].takeIf { available } //true返回 this false返回null}//return -> Rfun <R> fetch(index: Int,subjectModFunction: (T) -> R): R? {return subjectModFunction(subject[index]).takeIf { available }}
}
open class Human(val age:Int)class Boy(val name: String, age: Int):Human(age)class Dog(val weight: Int)fun main() {val magicBox1 = MagicBox(Boy("Jack0", 20),Boy("Jack1", 20),Boy("Jack2", 20),Boy("Jack3", 20))magicBox1.available =trueval fetch = magicBox1.fetch(3) {it}println(fetch)println(fetch?.name)println(fetch?.age)
}8.get函数
也就是运算符重载
class MagicBox<T:Human>( vararg item: T) {var subject: Array<out T> = itemvar available = falsefun fetch(index:Int): T? {return subject[index].takeIf { available } //true返回 this false返回null}//return -> Rfun <R> fetch(index: Int,subjectModFunction: (T) -> R): R? {return subjectModFunction(subject[index]).takeIf { available }}operator fun get(index: Int):T?{return subject[index]}}
open class Human(val age:Int)class Boy(val name: String, age: Int):Human(age)class Dog(val weight: Int)fun main() {val magicBox1 = MagicBox(Boy("Jack0", 20),Boy("Jack1", 20),Boy("Jack2", 20),Boy("Jack3", 20))magicBox1.available =trueval fetch = magicBox1.fetch(3) {it}println(fetch)println(fetch?.name)println(fetch?.age)println(magicBox1[3]?.name)
}9. out 协变 in 逆变 invariant(不变)
//out
interface Production<out T> {fun product(): T
}//in
interface Consumer<in T> {fun consume(item: T)
}//不变
interface ProductionConsumer<T> {fun product(): Tfun consume(item: T)
}open class Foodopen class FastFood : Food()class Burger : FastFood()//汉堡生产者
//食品商店
class FoodStore : Production<Food> {override fun product(): Food {println("Product Food")return Food()}}class FastFoodStore : Production<FastFood> {override fun product(): FastFood {println("Product FastFood")return FastFood()}}class BurgerStore : Production<Burger> {override fun product(): Burger {println("Product Burger")return Burger()}}//消费者
class EveryBody : Consumer<Food> {override fun consume(item: Food) {println("consume food")}}class ModernPeople : Consumer<FastFood> {override fun consume(item: FastFood) {println(item is Burger)println("consume FastFood")}}class AmericanPeople : Consumer<Burger> {override fun consume(item: Burger) {println("consume Burger")}}fun main() {//赋值val production1: Production<Food> = FoodStore()val product = production1.product()//用了Out关键字 子类转父类泛型 泛型可以协变和逆变val production2: Production<Food> = FastFoodStore()val production3: Production<Food> = BurgerStore()//in 父类转子类泛型val consumer1: Consumer<Burger> = EveryBody()val consumer2: Consumer<Burger> = ModernPeople()consumer2.consume(Burger())val consumer3: Consumer<Burger> = AmericanPeople()}
10. reified关键字
reified 和 inline 关键字配合使用能够实现泛型类型判断。因为匿名函数会被优化到这个随机类型函数中，那么就能够知道具体类型是啥了
这个函数的返回类型由backup函数的返回类型决定 和类定义的泛型无关 也就是类的泛型没有起到任何约束作用 你写一个String都可以
class MagicBox<T : Human>() {//产生一个指定类型的对象，如果不是指定类型的对象，就通过backup函数生成一个指定类型的对象
// fun <T> randomOrBackUp(backup: () -> T): T {
// val items:List<out Human> = listOf(
// Boy("Jack", 20),
// Man("John", 35)
// )
// val random:Human =items.shuffled().first()
// return if (random is T){ //T会被擦除
// random
// }else{
// backup()
// }
//
// }inline fun <reified T> randomOrBackUp(backup: () -> T): T { //内联函数它就会被替换，泛型擦除从而解决 类型将会保留下来val items:List<Human> = listOf(Boy("Jack", 20),Man("John", 35))val random:Human =items.shuffled().first()return if (random is T){ //T会被擦除random}else{backup()}}}open class Human(val age: Int)class Boy(val name: String, age: Int) : Human(age){}class Man(val name: String, age: Int) : Human(age){override fun toString(): String {return "Man(name='$name' age ='$age')"}
}fun main() {val box1:MagicBox<Boy> = MagicBox()val subject:Man = box1.randomOrBackUp {Man("Jimmy", 36)}println(subject)
}11.定义扩展函数
//给字符串追加若干个感叹号
fun String.addExt(amount:Int =1 ):String{return this + "!".repeat(amount)
}fun main() {println("abc".addExt(3))
}
//给字符串追加若干个感叹号
fun String.addExt(amount:Int =1 ):String{return this + "!".repeat(amount)
}fun Any.easyPring(){println(this)
}
fun Any.easyPring1(){println(this.toString()+1)
}fun main() {println("abc".addExt(3))"abc".easyPring()
}可以用private修饰符，只能在此文件下使用
12.泛型扩展函数
//给字符串追加若干个感叹号
fun String.addExt(amount:Int =1 ):String{return this + "!".repeat(amount)
}private fun <T> T.easyPring():T{println(this)return this;
}
fun Any.easyPring1(){println(this.toString()+1)
}fun main() {println("abc".addExt(3))"abc".easyPring().addExt(3).easyPring()
}
13.扩展属性
val String.numVowelsget() = count{ "aeiou".contains(it) }//true 计数器加1 fun <T> T.easyPrint():T{println(this)return this
}fun main() {"The people's Republic of China".numVowels.easyPrint()val count = "the".count()println(count)}14. 可空类型扩展函数
fun String?.printWithDefault (default:String) = print(this ?: default)//如果为null就为defaultfun main() {val nullableString :String? = "asdas";nullableString.printWithDefault("jmj")
}15. infix关键字
infix fun String?.printWithDefault (default:String) = print(this ?: default)//infix 对一个参数的函数 可以简化写法，去掉调用的点和括号fun main() {val nullableString :String? = "asdas";nullableString printWithDefault "jmj"
}16.定义扩展文件
package com.jason.kotlin.extensionfun <T> Iterable<T>.randomTask():T = this.shuffled().first()import com.jason.kotlin.extension.randomTaskfun main() {val randomTask = listOf<String>("jmj", "sada", "asd").randomTask()println(randomTask)
}
