kotlin从小白到大神Day03 2020.7.15

内容

1.普通函数
2.数据类
3.内部类和嵌套类
4.接口和匿名类
5.抽象类

一.普通函数

注意：
①如果有返回值且执行代码只有一行的精简写法
②可变参数vararg
③also怎么用

//正常的没有参数没有返回值的函数
fun work(){

}
//kotlin里面 Unit = void，所以上面的函数也可以写成
fun work1():Unit{

}

//有参数有返回值
fun study(money: Int): Int{
    return 10
}

//如果代码只有一行，还有精简的写法，省略了返回值的类型和return
fun add(a: Int,b: Int):Int{
    return a + b
}
//等价于
fun add1(a: Int,b: Int) = a + b

//这里的参数也可以指定默认值
fun Study(money: Int,name: String = "Jack"){
    //study(30)到时候就可以这样调用
}
fun Study1(money: Int = 300,name: String){
    //Study1(name = "jack")到时就可以这样调用
}

//可变参数，类似与Java中的 ...  ，就是可以传进来多个类型一样的参数，相当于传进来的数组
fun add1(vararg nums: Int){//vararg就是指明一下它是可变类型，这里就类似Java中的 int... nums
    var result = 0
    for(value in nums){
        result += value
    }
    println(result)
}
//到时候主函数中这样调用 add1(1,2,3,4,5)//输出15

//函数里面还可以定义函数
fun showView(){
    //定义下载数据的函数
    fun load() = "图片"

    //定义展示图片的函数
    fun showImg(){
        var Img = load()
        println(Img)
    }

    showImg()
}
//这里就是，有定义，有执行，可以放大理解为 类似有main外面的定义，有main里面的执行

//如果马上就想用这个返回值，那么就可以这样写
//比如上面的那个函数
fun showView1(){
    //定义下载数据的函数
    fun load() = "图片"

    //定义展示图片的函数
    fun showImg(){
       load().also{
           println(it)
       }
    }

    showImg()
}
//it代表返回值

fun main(){
    add1(1,2,3,4,5)//输出15
    showView()//输出： 图片
    showView1()//依然输出 图片
}

二.数据类

注意数据类使用的四个要求
1.数据类的主构造函数必须有至少一个参数（这个也好理解，如果不传参数，那要这个数据类就没啥意义了）
2.参数必须使用var 或者 val修饰（val只能get不能set）
3.不能使用 open inner abstract
4.不能实现接口

//数据类，可以避免较多的 setter和getter方法，避免过多的冗余代码出现
data class User(
        var name: String,
        var password: String,
        var id: Int){

}
//数据类使用有四个要求
//1.数据类的主构造函数必须有至少一个参数（这个也好理解，如果不传参数，那要这个数据类就没啥意义了）
//2.参数必须使用var 或者 val修饰（val只能get不能set）
//3.不能使用 open inner abstract
//4。不能实现接口

fun main(){
    //而且数据类重写了toString方法
    val u = User("jack","123",1)
    println(u)//输出结果是 User(name=jack, password=123, id=1)
    //像Java就不会这样，Java还要重写toString方法

    //或者利用刚刚的知识点，这样去写
    User("jack","123",1).also { println(it) }
}

三.内部类和嵌套类

注意内部类和嵌套类的区别

class Bank{
    var money: Money = Money(0)

    //钱 类
    //嵌套类 也即Nested，类似于Java中的静态类
    //嵌套类是独立的，基本和宿主类没有啥关系，不能访问宿主类的属性和方法
    class Money(var num: Int){}//里面有个变量是num类型

    //如果想产生关系，就加入关键字 init，这就变成了内部类
    //内部类可以访问类的属性和方法
    inner class Card(){
        fun save(count: Int){
            money.num += count
        }//这里虽然是一行代码，但是不能用also那个方法，因为这里没有返回值

        fun withdraw(count: Int){
            if(money.num >= count){
                money.num -= count
                println("取款成功")
            }else{
                println("余额不足")
            }
        }
    }
}

fun main() {
    //独立的嵌套类和从属的内部类的区别在创建时候的体现
    Bank.Money(0)//这是嵌套类的创建，可以发现Bank后面没有括号
    //证明不需要创建Bank这个类，而是通过Bank这个类找到Money这个类

    Bank().Card()//这是内部类的创建，可以发现内部类的创建需要Bank类的创建
    //如果Bank后面不加括号，会报错

    var card = Bank().Card()
    card.save(200)
    card.withdraw(500)
    card.withdraw(20)
    //输出
    //余额不足
    //取款成功
}

四.接口和匿名类

注意：
①接口，不能用（），因为接口不能实例化，而（）就是代表构造函数
②also和apply的使用
③object

//接口，内部类
//和Java一样，接口不能被实例化，只能实例化接口的实现类
//接口的方法默认是open的（这个很好理解）

//定义一个接口
interface OnTouchListener{
    fun onTouchEvent(type: String)
}

//定义一个函数，调用接口的方法
fun didTouch(listener: OnTouchListener){
    listener.onTouchEvent("手指按下")
}
//如果想调用didTouch函数，因为它的参数比较特殊，所以有两种方式
//方法一：创建接口的是实现类，然后实例化实现类，则函数的参数传递实现类就可以
class ButtonListener: OnTouchListener{
    override fun onTouchEvent(type: String) {//注意 override
        println("接收到事件为： $type")
    }
}

//方法二：用object来表示匿名类
fun main(){
    //以下是方法一的代码
    /*var btn = ButtonListener()
    didTouch(btn)//输出 接收到事件为： 手指按下
    //在kotlin里面，上面两行的代码还可以这样写
    ButtonListener().also {
        didTouch(it)
    }
    //或者
    ButtonListener().apply {
        didTouch(this)
    }*/

    //以下是方法二的代码
    didTouch(object: OnTouchListener{
        override fun onTouchEvent(type: String) {//注意 override
            println("接收到事件为： $type")
        }
    })
    //可以与方法一创建的类做一下对比，这里其实就是用object关键字代替了class ButtonListener
}

五.抽象类

注意：
①抽象方法不能实现，抽象属性不能初始化
②抽象属性重写的两种方式

//如果子类必须实现，多数情况下是子类之间”因类而异“去实现，那么就定义为抽象方法
//抽象类默认是 open的
//子类一定要实现抽象类中的抽象方法
//抽象方法不能实现，抽象属性不能初始化（因为这都是给别人用的）

//定义抽象类（在这里作为基类）
abstract  class BaseActivity{
    abstract var title: String//不能初始化
    init{
        //创建页面
        onCreate()
        //暂停页面
        onPause()
        //销毁页面
        onDestory()

    }

    abstract fun onCreate()

    //如果想重写 onPause与onDestory方法，那么就需要把这个方法open一下
    fun onPause(){
        println("页面暂停了")
    }

    fun onDestory(){
        println("页面被销毁了")
    }
}
//第一个子类：主页面
class MainActivity(override var title: String): BaseActivity(){//这种重写抽象属性的方式比较灵活
    override fun onCreate() {
        println("主页界面被创建了")
    }
}
//第二个子类：登录页面
class LoginActivity: BaseActivity(){
    override var title: String = "重写"//这种重写抽象属性的方式就是写死了
    override fun onCreate() {
        println("登录页面被创建了")
    }

}

fun main() {
    MainActivity("主页面")
    //主页界面被创建了
    //页面暂停了
    //页面被销毁了

    LoginActivity()
    //登录页面被创建了
    //页面暂停了
    //页面被销毁了
}