[swift学习之十]扩展语法练习

//------------------------//
/*注意点：
 1：扩展可以对类添加新的功能，不能覆盖已有功能。提示：invalid redeclaration of ...
 2：扩展可以实现接口内容，如extension Base{}，但得注意创建实例的位置了。
 3：先实例对象，再扩展，然后可以调用扩展内容，这点很爽啊～
 4：扩展数量没限制，而且后面的扩展可以调用前面扩展内容。
 5：扩展可以实现协议或者覆盖父类的函数。
 6：扩展不可以有存储属性，但可以有计算属性，如CompareZero。还可以嵌套类型，如EqualZero
 7：扩展协议的时候，能调用协议以前的方法，但必须给个实现。
 */
/*扩展基类*/
protocol pro1 {
    func ShowNomal() -> String
    func ShowNomalEx() -> String
}
class Base:NSObject,pro1 {
    var ID = 0
    func ShowNomal()->String {
        return "Base func ShowNomal"
    }
}
//let B1 = Base()/*放这里的时候，就提示没实现接口pro1*/
extension Base{
    enum EqualZero: String {
        case MoreThanEqual = "大于零"
        case LessThanEqual = "小于零"
        case EqualZero = "等于零"
    }
    var CompareZero: EqualZero{
        get{
            switch ID {
            case let a where a > 0:
                return EqualZero.MoreThanEqual
            case let a where a < 0:
                return EqualZero.LessThanEqual
            default:
                return EqualZero.EqualZero
            }
        }
    }
    func ShowNomalEx()->String {
        return "Base func ShowNomalEx"
    }
}

let B1 = Base()
extension Base{
    func ShowMsg() ->String {
        return ShowNomalEx() + "Base ShowMsg"
    }
}
B1.ShowMsg()//注意点3
B1.ID = -1
B1.CompareZero.rawValue//注意点6
/*扩展子类*/
class Child: Base {
    override func ShowNomal()->String {
        return "Child ShowNomal"
    }
}
let B2 = Child()
extension Child{
    //这里覆盖的是扩展实现的方法，而且还有super。
    override func ShowNomalEx() -> String {
       return super.ShowNomalEx() + "Child ShowNomalEx"
    }
}
B2.ShowNomalEx()
B2.CompareZero.rawValue
/*扩展协议*/
extension pro1{
    func showPro1Ex() -> String {
       return self.ShowNomalEx()
    }
}

B1.showPro1Ex()
B2.showPro1Ex()
/*扩展基本类型Int*/
extension Int{
    enum EqualZero: String {
        case MoreThanEqual = "大于零"
        case LessThanEqual = "小于零"
        case EqualZero = "等于零"
    }
    func ExcuteTimes(@autoclosure aFun:()->()) -> Void {
        for _ in 1...self {
            aFun()
        }
    }
    func ToString() -> String {
        return "\(self)"
    }
    mutating func Square() -> Void {
        self = self * self
    }
    var CompareZero: EqualZero{
        get{
            switch self {
            case let a where a > 0:
                return EqualZero.MoreThanEqual
            case let a where a < 0:
                return EqualZero.LessThanEqual
            default:
                return EqualZero.EqualZero
            }
        }
    }
}

5.ExcuteTimes(print("Hello"))
//5.Square()/*常量不能调用mutating函数*/
var aInt = 5
aInt.Square()
aInt.CompareZero.rawValue
let aStr = 5.ToString()
/*扩展下标*/
extension Int{
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..<digitIndex{
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}
789[0]
789[1]
789[2]
/*
 总结下吧：这个扩展语法无比犀利，没有你做不到，只有你想不到。～
 个人理解，除了不能有存储类型以外，就和写在一起一样。基础类型基本都是struct，所以就支持了。
 这个让人脑洞大开的语法指不定法在实际工程里面怎么用呢，木有名字，最好自己扩展的内容加标示～～
*/

参考：http://www.swiftvip.cn/guide/chapter2/21_Extensions.html