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

分手后的思念是犯贱 2022-07-24 03:29 197阅读 0赞

//------------------------//
    /*注意点：
     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