1、嵌套类
说明:即类的内部再创建类 但是不适用inner关键字;
嵌套类是属于静态类,和外部类没有任何关系
fun main(args: Array<String>) {
//访问内部的方法
var name = OutClass.InnerClass().sayHello()
}
class OutClass {
var name = "张三"
class InnerClass {
fun sayHello() {
// println("你好$name")
println("你好${OutClass().name}")
}
}
}
2、内部类
说明:即类的内部再创建类使用inner关键字
fun main(args: Array<String>) {
//访问内部的方法
var inClass = OutClass().InnerClass()
inClass.sayHello()
}
class OutClass {
var name = "张三"
inner class InnerClass {
fun sayHello() {
// println("你好$name")
println("你好${OutClass().name}")
}
}
}
3、内部类使用this
说明:内部类访问属性使用关键是this
class OutClass {
var name = "张三"
inner class InnerClass {
var name = "李四"
fun sayHello() {
// println("你好$name")
// println("你好${OutClass().name}")
println("你好${this.name}")
}
}
}
4、泛型
1)泛型
泛型:在强类型程序设计语言中编写代码时定义一些可变部分
描述:
1)定义对象的时候使用泛型;
2)定义子类时候执行泛型;
3)定义子类的时候不知道具体类型,继续使用泛型。
fun main(args: Array<String>) {
val box = Box<String>("大头梨")
println(box.thing)
}
//定义一个箱子,箱子内不知道放啥
open class Box<T>(var thing: T) {
}
//定一个只放水果的箱子
class FruitBox(thing: Fruit) : Box<Fruit>(thing)
//不是道具体放什么
class SonBox<T>(thing:T):Box<T>(thing)
//抽象类水果
abstract class Fruit
//苹果
class Apple : Fruit()
//橘子
class Orange : Fruit()
2)泛型函数
说明:使用泛型可以判断基本数据类型和 类的类型
fun main(args: Array<String>) {
parseType(10)
}
fun <T> parseType(thing: T) {
when (thing) {
is Int -> {
println("是Int类型")
}
is String -> {
println("是String类型")
}
is Boolean -> {
println("是Boolean类型")
}
else -> {
println("不是道具体类型")
}
}
}
3)泛型擦除
泛型擦除:在kotlin中泛型背擦除
说明:获取泛型使用方法
1)泛型前加reified关键字;
2)方法前加上inline关键字
fun main(args: Array<String>) {
val box1 = Box<String>("")
val box2 = Box<Int>(10)
//获取其class类型
// println(box1.javaClass.name)
// println(box2.javaClass.name)
// println(box1::class.java.name)
// println(box2::class.java.name)
// com.hunter.kotlin.day03.Box
parseType(10)
}
inline fun <reified T> parseType(thing:T){
//获取传递的thing的class类型
println(T::class.java.name)
}
4)泛型类型投射
泛型类型投射:即抽象类作为参数,则继承抽象类的子类无法放入有该参数的方法中
描述:out关键字 类似于java中的 ? extents
fun main(args: Array<String>) {
val list = ArrayList<Fruit>()
val apple = ArrayList<Apple>()
// println(setFruitList(list))
println(setFruitList(apple))//会报错则要是用关键字out
val intList = ArrayList<Int>()
setFruitList1(intList)
}
fun setFruitList(list: ArrayList<out Fruit>) {
//使用关键字out
}
fun setFruitList1(list: ArrayList<*>) {
//使用关键字* 即型号投射}
//定义一个箱子,箱子内不知道放啥
open class Box<T>(var thing: T) {
}
abstract class Thing
//抽象类水果
abstract class Fruit : Thing()
//苹果
class Apple : Fruit()
//橘子
class Orange : Fruit()}
5、智能类型推断
说明:类似于java的强转
fun main(args: Array<String>) {
// val shepDog = ShepHerdDog()
// val ruralDog = RuralDog()
// shepDog.herdShep()
// ruralDog.LookDoor()
val shepDog: Dog = ShepHerdDog()
val ruralDog: Dog = RuralDog()
// shepDog.herdShep()
// ruralDog.LookDoor()
//增加判断
//判断完之后 已经将shepDog类型由Dog转换成ShepHerdDog
if (shepDog is ShepHerdDog) {
//
shepDog.herdShep()
}
if (ruralDog is RuralDog) {
ruralDog.LookDoor()
}
}
//定义狗 狗有很多品种
abstract class Dog
//牧羊犬
class ShepHerdDog : Dog() {
fun herdShep() {
println("牧羊犬放羊")
}
}
//中华田园犬
class RuralDog : Dog() {
fun LookDoor() {
println("中华田园犬看家")
}
}