笔记：kotlin 学习第三天

作者: s酸菜 | 来源:发表于2018-07-18 17:32 被阅读0次

kotlin - get和set

/**
 * @ 文件名:   `1.get和set`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 09:41
 * @ 描述: kotlin中的字段默认是私有的，get和set方法是自动生成的
 */
    fun main(args: Array<String>) {
    val person = Person()
    person.say()
    println(person.name)
    println(person.age)
}

open class Person {
    var name: String = "林志玲"

    var age = 19

    fun say() {
        println("高德地图持续为您服务")
    }
}

kotlin - 访问器 private set

/**
 * @ 文件名:   `02.访问器`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 09:47
 * @ 描述:    通过private set 设置可以私有set或者get方法
 */
fun main(args: Array<String>) {
    val user = User()

    println(user.login(user.phone, user.password))
}

class User {
    //private //写在上面表示set 和 get 方法都会生成
    var phone: String = "110"
    private set//私有化set：private final void setPhone(String var1) {this.phone = var1; }

    var password: String = "12345"

    fun login(phone: String, pwd: String): String {
        return phone + pwd
    }
}

kotlin - 自定义访问器 set(){} this.age field

/**
 * @ 文件名:   `03.自定义访问器`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 09:51
 * @ 描述:    set(){}  this.age会引起栈溢出，用field。
 */
fun main(args: Array<String>) {
    val goods = Goods()

    goods.price = 20199

    println(goods.price)
}

class Goods {
    var name: String = "Mac"

    var price: Int = 18880
        set(price) {
            if (price > 20000) {
                //this.price = price  递归调用导致栈溢出:if (price > 20000) {this.setPrice(price);}
                field = price
            }
        }
}

kotlin - 构造函数

/**
 * @ 文件名:   `04.构造函数`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 09:54
 * @ 描述:
 */
fun main(args: Array<String>) {
    val address = Address("广东省深圳市宝安区", "皮特", 10086)
    println(address.address + address.name + address.score)//广东省深圳市宝安区皮特10086

}

class Address(address: String, name: String, score: Int) {
    var address: String = address
    var name: String = name
    var score: Int = score
}

kotlin - 构造函数参数使用 init

/**
 * @ 文件名:   `05.构造函数参数使用_init`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 09:56
 * @ 描述:
 */

fun main(args: Array<String>) {
    val item = Item("标题一", "https://www.baidu.com", 12315)
    println(item.title + item.url + item.id)
}

class Item(title: String, url: String, id: Int) {
    var title: String = ""
    var url: String = ""
    var id: Int = 10000

    init {
        this.title = title
        this.url = url
        this.id = id
    }

    //init 中的代码会在构造函数中执行
    /*public Item(@NotNull String title, @NotNull String url, int id) {
        Intrinsics.checkParameterIsNotNull(title, "title");
        Intrinsics.checkParameterIsNotNull(url, "url");
        super();
        //默认定义的字段
        this.title = "";
        this.url = "";
        this.id = 10000;
        //init 块中的代码
        this.title = title;
        this.url = url;
        this.id = id;
    }*/
}

kotlin - 构造函数参数使用 var val

/**
 * @ 文件名:   `06.构造函数参数使用var和val`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 09:58
 * @ 描述:
 */
fun main(args: Array<String>) {
    val brand = Brand("奶粉", 12306)
    println(brand.name + brand.id)
    //brand.name = "电脑办公"不能被重新赋值
}

class Brand(val name: String, var id: Int)

//@NotNull
//private final String name;
//private int id;

kotlin - 次构函数 constructor

/**
 * @ 文件名:   `07.次构函数`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:01
 * @ 描述:
 */
fun main(args: Array<String>) {
    val person = Person("林志颖", 18, "12345")
    val person1 = Person("林志玲", 30)

    println("person: ${person.phone}")
    println("person1: ${person1.phone}")
}

class Person(name: String, age: Int) {
    var phone: String = "10000"

    constructor(name: String, age: Int, phone: String) : this(name, age) {
        this.phone = phone
    }
}

kotlin - init和次构函数的执行顺序

/**
 * @ 文件名:   `08.init和次构函数的执行顺序`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:02
 * @ 描述:
 */
fun main(args: Array<String>) {
    val person = Person("王祖贤", 18,"12312")
    println(person.name)
    //执行了init初始化
    //执行了次构函数
    //王祖贤
}

class Person(var name: String, var age: Int) {
    init {
        println("执行了init初始化")
    }

    constructor(name: String, age: Int, phone: String) : this(name, age) {
        println("执行了次构函数")
    }
}

kotlin - 继承 :

/**
 * @ 文件名:   `09.继承`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:26
 * @ 描述:
 */
fun main(args: Array<String>) {
    val father = Father()
    father.eat()
    father.smoking()

    val son = Son()
    //son.name = "张四"
    //son.age = 19
    println(son.name + son.age)
    son.eat()
}

open class Father {
    open var name: String = "张三"
    open var age: Int = 39

    open fun eat() {
        println("父亲喜欢吃米饭")
    }

    fun smoking() {
        println("父亲喜欢抽烟")
    }
}

class Son : Father() {
    override var name:String = "张四"
    override var age:Int = 19
    override fun eat() {
        //super.eat()
        println("儿子喜欢吃面条")
    }
}

kotlin - 抽象类 abstract

/**
 * @ 文件名:   `10.抽象类`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:27
 * @ 描述:
 */
 
fun main(args: Array<String>) {
    val chinese = Chinese()
    chinese.say()

    val america = America()
    america.say()
}

abstract class Human {
    abstract var skinColor: String
    abstract var language: String

    abstract fun say()
}

class Chinese : Human() {
    override var language: String = "中文"
    override var skinColor: String = "黄色"

    override fun say() {
        println("中国人皮肤颜色是${skinColor}，中国人讲$language")
    }

}

class America : Human() {
    override var skinColor: String = "白色"
    override var language: String = "英语"

    override fun say() {
        println("美国人皮肤颜色是${skinColor}，美国人讲$language")
    }

}

kotlin - 接口

/**
 * @ 文件名:   `11.接口`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:28
 * @ 描述:
 */
fun main(args: Array<String>) {
    val peat = Peat()
    println(peat.name + peat.age)
    peat.drive()
}

abstract class Man {
    abstract var name: String
    abstract var age: Int
}

class Peat : Man(), Drive {
    override var name: String = "peat"
    override var age: Int = 18

    override fun drive() {
        println("peat学会了开车")
    }


}

interface Drive {
    fun drive()
}

kotlin - 接口细节 kotlin接口中的字段不能实现

/**
 * @ 文件名:   `12.接口细节_字段`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:29
 * @ 描述:
 */
fun main(args: Array<String>) {
    val peat = Peat()
    println(peat.name + peat.age + peat.license)
    peat.drive()
}

abstract class Man {
    abstract var name: String
    abstract var age: Int
}

class Peat : Man(), Drive {
    override val license: String = "10086"
    override var name: String = "peat"
    override var age: Int = 18

    override fun drive() {
        println("peat学会了开车")
    }


}

//开车能力
interface Drive {
    //驾照号码
    val license: String

    //开车行为
    fun drive()
}

kotlin - 接口细节 kotlin接口中的方法可以实现

/**
 * @ 文件名:   `13.接口细节_方法`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:34
 * @ 描述:    kotlin 接口中的字段不能实现，但是方法可以实现。Java接口中的方法不能实现
 */
fun main(args: Array<String>) {
    val peat = Peat()
    println(peat.name + peat.age + peat.license)
    peat.drive()
}

abstract class Man {
    abstract var name: String
    abstract var age: Int
}

class Peat : Man(), Drive {
    override val license: String = "10086"
    override var name: String = "peat"
    override var age: Int = 18

    //override fun drive()


}

//开车能力
interface Drive {
    //驾照号码
    val license: String

    //开车行为
    fun drive() {
        println("踩离合、挂挡、松离合、踩油门、走你")
    }
}

kotlin - 多态

/**
 * @ 文件名:   `14.多态`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:36
 * @ 描述:
 */
fun main(args: Array<String>) {
    val dog: Animal = Dog()
    val cat: Animal = Cat()

    dog.call()
    cat.call()

}

abstract class Animal {
    abstract var name: String
    open fun call() {
        println("动物叫")
    }
}

class Dog : Animal() {
    override var name: String = "旺财"

    override fun call() {
        println("${name}汪汪叫")
    }

}

class Cat : Animal() {
    override var name: String = "Tom"

    override fun call() {
        println("${name}喵喵叫")
    }

}

kotlin - 智能类型转换 is

/**
 * @ 文件名:   `15.智能类型转换`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:36
 * @ 描述:    kotlin 中不需要强转，智能类型推断
 */

fun main(args: Array<String>) {
    val shepHerdDog: Dog = ShepHerdDog()
    val ruralDog: Dog = RuralDog()

    if (shepHerdDog is ShepHerdDog) {
        val herdDog = shepHerdDog as ShepHerdDog//没有转换的必要
        herdDog.herdSheep()
    }

    if (ruralDog is RuralDog) {
        ruralDog.watchDoor()
    }
}

abstract class Dog

class ShepHerdDog : Dog() {
    fun herdSheep() {
        println("牧羊犬的作用是放羊")
    }

}

class RuralDog : Dog() {
    fun watchDoor() {
        println("中华田园犬的作用是看家")
    }
}

kotlin - 嵌套类 嵌套类是静态的

/**
 * @ 文件名:   `16.嵌套类`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:37
 * @ 描述:
 */

fun main(args: Array<String>) {
    val innerClass = OutClass.InnerClass()//inner类是静态的:public static final class InnerClass
    println(innerClass.name)
    innerClass.sayHello()

    val outClass = OutClass()
    println(outClass.name)
}


class OutClass {
    var name: String = "out"

    class InnerClass {
        var name: String = "inner"

        fun sayHello() {
            println("你好$name")//访问的inner类的name字段
        }
    }
}

kotlin - 内部类 inner class

/**
 * @ 文件名:   `17.内部类`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:38
 * @ 描述:    inner 关键字可以去掉static属性
 */
fun main(args: Array<String>) {
    val innerClass = OutClass().InnerClass()//public final class InnerClass
    innerClass.sayHello()
}

class OutClass {
    var name: String = "out"

    inner class InnerClass {
        var name: String = "inner"
        fun sayHello() {
            println("say 你好 $name")
        }
    }
}

kotlin - 内部类中使用this this@OutClass.name

/**
 * @ 文件名:   `18.内部类使用this`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:40
 * @ 描述:    内部类和Java一样需要依赖外部类对象环境。this@tag 和 Java中的OutClass.this.name 一样
 */
fun main(args: Array<String>) {
    val innerClass = OutClass().InnerClass()
    innerClass.sayHello()
}

class OutClass {
    var name: String = "out"

    inner class InnerClass {
        var name: String = "inner"
        fun sayHello() {
            println("say 你好 ${this@OutClass.name}")
        }
    }
}

kotlin - 泛型 <T> T

/**
 * @ 文件名:   `19.泛型`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:40
 * @ 描述:
 */
fun main(args: Array<String>) {

    val apple = Apple()
    val orange = Orange()
    val box = FruitBox(apple)//定义的水果箱子可以放🍎和🍊
    //val sonBox = SonBox<Apple>(orange)//定义的🍎箱子不能放入🍊，只能放入🍎
    val sonBox = SonBox<Apple>(apple)

}


//定义一个水果类
abstract class Fruit

//定义一个🍎类
class Apple : Fruit()

//定义个橘子🍊类
class Orange : Fruit()


//定义一个不知道装什么东西的箱子
open class Box<T>(var thing: T)

//不知道具体放什么东西,前面声明，后面两个都是 使用
class SonBox<T>(thing: T) : Box<T>(thing)

//水果箱子
class FruitBox(thing: Fruit) : Box<Fruit>(thing)

kotlin - 泛型函数 <T> T

/**
 * @ 文件名:   `20.泛型函数`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:42
 * @ 描述:
 */
fun main(args: Array<String>) {
    add("a")//[a]
    add(12)//[12]
    val dog = Dog()
    add(dog)//[com.ty.ktolin.day03.Dog@49476842]
}

//定义一个函数，参数泛型为T
fun <T> add(item: T) {
    val listOf = arrayListOf<T>()
    listOf.add(item)
    println(listOf)
}

kotlin - 泛型上限 T:Fruit

/**
 * @ 文件名:   `21.泛型上限`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:43
 * @ 描述:
 * 定义对象的时候使用泛型
 * 定义子类时候执行泛型
 * 定义子类的时候不知道具体类型,继续使用泛型
 * T:Fruit  泛型上限  泛型智能是Fruit类型或者Fruit类型的子类
 * 泛型作用:放任何类型 限制存放的类型
 */
fun main(args: Array<String>) {
    val two = Two()
    val three = Three()
    val four = Four()

    val five = Five(two)
    val five1 = Five(three)
    //val five2 = Five(four)
}

abstract class One

open class Two : One()

class Four : One()

class Three : Two()

class Five<T : Two>(var num: T)

kotlin - 泛型擦除 泛型前加reified 方法前inline

    /**
 * @ 文件名:   `22.泛型擦除`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:48
 * @ 描述:
 * 两种类型应该是不一样的
 * 必须要通过反射获取泛型类型
 *
 * 解决泛型擦除方案:
 * 第一步:泛型前加reified关键字
 * 第二步:方法前加上inline关键字
 */

fun main(args: Array<String>) {
    parseType("a")
}

inline fun <reified T> parseType(thing: T) {
    //获取传递的thing的class类型
    val name = T::class.java.name
    println(name)
}

kotlin - 泛型类型投射 out Fruit in Fruit

    /**
 * @ 文件名:   `23.泛型类型投射`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:49
 * @ 描述:
 * in:接收当前类型或者它的父类  相当于java的 ? super
 * out:接收当前类型或它的子类 相当于java的 ? extents
 */

fun main(args: Array<String>) {
    val arrayList = ArrayList<Fruit>()
    val apple = Apple()
    val fushiApple = FushiApple()

    arrayList.add(apple)
    arrayList.add(fushiApple)

    setFruitList(arrayList)
    //addFruitList(arrayList)

}

//能装富士苹果以及他的父类
fun setFruitList(list: ArrayList<in FushiApple>) {
    println(list.size)
}

//只能装富士苹果以及他的子类
fun addFruitList(list: ArrayList<out FushiApple>) {
    println(list.size)
}

//定义一个水果类
abstract class Fruit

//定义一个🍎类
open class Apple : Fruit()

//定义一个富士🍎类
class FushiApple : Apple()

kotlin - 星号投射 *

    /**
 * @ 文件名:   `24.星号投射`
 * @ 创建者:   ty
 * @ 时间:    2018/7/14 10:50
 * @ 描述:    *可以传递任何类型  相当于java的 ?
 */
fun main(args: Array<String>) {
    val arrayList = ArrayList<Int>()
    arrayList.add(111)
    add(arrayList)

    val list = ArrayList<String>()
    list.add("abc")
    add(list)
}

fun add(list: ArrayList<*>) {
    println(list.size)
}

笔记：kotlin 学习第三天

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读