[Day09] swift & kotlin 入门篇！(7) 方法, 类别, 介面

方法

程序设计里面方法太重要了
当然～也有人习惯叫他函数
每个方法我们可以看做一个命令

这其中有两个知识点可以让大家去研究

Functional programming
好的FP可避免大量的重复程序码
也可以有清晰的程序逻辑
单一职责
方法即是命令
所以一个好的方法应该清楚又明确
一个方法应该只做一件事情
看似简单又废话的一段话
在真正实作时
是需要大量经验与知识才能达成的

swift

// 一般方法
func sayHi(_ name: String) -> String {
    // 如果name 拿掉前方的 _   呼叫必须变成 sayHi(name: "Ami")
    return "你好啊 \(name)!"
}
print(sayHi("Ami")) //你好啊 Ami!

// 可变参数, 每个方法最多只可以有一组
func sayHiFoEeveryone(_ name: String...) -> String {
    return "你们好啊 \(name)!"
}
print(sayHiFoEeveryone("Ami1","Ami2","Ami3","Ami4"))
// 你们好啊 ["Ami1", "Ami2", "Ami3", "Ami4"]!


// 命名参数 主要是增加可读性
func sayHiFrom(from: String, to: String) -> String {
    return "\(from)说: 你好啊 \(to)!"
}
print(sayHiFrom(from: "Ami", to:"Amit"))
// Ami说: 你好啊 Amit!

//print(sayHiFrom( to:"Amit", from: "Ami"))
// 编译错误 命名参数必须顺序正确

swift的命名参数
对提升可读性上有很大的加分喔

kotlin

// 一般方法
fun sayHi(name: String): String {
    return "你好啊 $name!"
}

// 可变参数, 每个方法最多只可以有一组
fun sayHiFoEeveryone(vararg name: String): String {
    val names = name.toList().toString()
    return "你们好啊 $names!"
}

// 命名参数 主要是增加可读性
fun sayHiFrom(from: String, to: String): String {
    return "${from}说: 你好啊 $to!"
}

fun main() {
	println(sayHi("Ami")) //你好啊 Ami!
    println(sayHiFoEeveryone("Ami1","Ami2","Ami3","Ami4")) //你们好啊 [Ami1, Ami2, Ami3, Ami4]!
    println(sayHiFrom(from = "Ami", to = "Amit")) // Ami说: 你好啊 Amit!
    println(sayHiFrom( to = "Amit", from = "Ami"))// Ami说: 你好啊 Amit! 
}

Swift参数设定严谨
Kotlin 相对较宽松
这样的设计可以带来比较大的弹性
不需要顺序一样
这在後续扩充参数上有很大的帮助

但较高的弹性相对的也会带来较高的混乱
用与不用～你自己决定搂

类别

啊呀～类别啊～太重要了
物件导向中类别是一个太重要的概念了
如果你对类别～物件导向都没概念
建议你停下来
先去补一些基本知识再往下走搂

swift

// protocol 就是swift的介面或契约
protocol IAnimal {
    func eat()
    func sleep()
}

class Animal: IAnimal {
    func eat() {
        print("开始吃饭搂～ 吃吃吃！")
    }
    func sleep() {
        print("开始睡觉!")
    }
}

class Cat: Animal {
    var name: String = ""
    var age: Int = 0

    init(_ name: String){
        self.name = name
    }

    func meow() {
        print("\(name): meow ~")
    }
    // 覆写方法使用关键字 override
    override func sleep() {
        print("本大爷要先来吃个宵夜～然後...")
        // 呼叫父层
        super.sleep()
    }
}

var mycat = Cat("Tom")
mycat.meow();
mycat.eat();
mycat.sleep();

interface 在这里变成 protocol
使用上没太大差异

但我特别喜欢他 override关键字的使用
清楚明了的标示这段在做什麽

特别提醒在类别内
指实体化後的自己
使用的是 self

kotlin

// interface 就是介面 可以定义行为
interface IAnimal {
    fun eat()
    fun sleep()
}

class Animal: IAnimal {
    // 实作界面需要写关键字 override
    override fun eat() {
        println("开始吃饭搂～ 吃吃吃！")
    }
    override fun sleep() {
        println("开始睡觉!")
    }
}
// 不行 class Cat(name: String): Animal  , kotlin里 类别与介面都只能扩展一层
class Cat(name: String): IAnimal {
    var name: String = ""
    var age: Int = 0

    init{
        this.name = name
    }

    fun meow() {
        println("$name: meow ~")
    }
    
    // 覆写方法使用关键字 override
    override fun eat() {
        println("开始吃饭搂～ 吃吃吃！")
    }
    override fun sleep() {
        println("本大爷要先来吃个宵夜～然後...")
        println("开始睡觉!")
    }
}


fun main() {
	var mycat = Cat("Tom")
    mycat.meow();
    mycat.eat();
    mycat.sleep();
}

kotlin在类别扩展上给出了限制
不管是介面还是类别都只能扩展一层
这彻底解决了其他语言中类别扩展过深的问题
这个限制会迫使开发者更遵守SOLID原则
不然....就可能面对超级多的重复程序码

当然还是有关键字可以取消这个限制
这边就不特别介绍搂