swift学习笔记之拓展和协议

原创 2016年05月30日 11:01:06
/**
*  Protocol(协议)用于统一方法和属性的名称,而不实现任何功能。协议能够被类,枚举,结构体实现,满足协议要求的类,枚举,结构体被称为协议的遵循者。

遵循者需要提供协议指定的成员,如属性,方法,操作符,下标等。
*/
//使用protocol来声明一个协议。

/**
*  协议的语法

协议的定义与类,结构体,枚举的定义非常相似,如下所示:

protocol SomeProtocol {
// 协议内容
}
在类,结构体,枚举的名称后加上协议名称,中间以冒号:分隔即可实现协议;实现多个协议时,各协议之间用逗号,分隔,如下所示:

struct SomeStructure: FirstProtocol, AnotherProtocol {
// 结构体内容
}
当某个类含有父类的同时并实现了协议,应当把父类放在所有的协议之前,如下所示:

class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 类的内容
}
*/

protocol ExampleProtocol {
    var simpleDescription: String {
        get
    }
    mutating func adjust()
}

//类,枚举和结构体都可以使用协议。

class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
var anotherProperty: Int = 69105
func adjust() {
    simpleDescription += "  Now 100% adjusted."
}
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription

struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

//注意在simpleStructure的声明中关键字mutating的使用,它用来标记这个方法修改了这个结构体。而在simpleClass的声明中则不需要使用mutating,因为类中的方法总是可以被修改的。


//二、协议(protocol)
//可定义方法与属性, 由具体的类去实现. 越来越像Java
//Swift中的协议能被类, 枚举,结构体实现.
protocol SomeProtocol{
    //协议内容
}

class SomeClass : SomeProtocol{ //实现协议, 可实现多个协议

}

//2.1 协议中属性/方法/突变方法的要求
//2.1.1 属性的要求

protocol AnotherProtocol1{
    //class表示类成员(结构体/枚举中用static)
    static var property : Int { get set} //get, set 表示可读可写
}

class AnotherClass1 : AnotherProtocol1{
    class var property : Int {  //实现协议中的属性
        get{
        return 10
        }
        set{

        }
    }
}

//2.1.2 方法要求
//不支持默认参数. 写法上只是没有方法的实现.
protocol AnotherProtocol2{
    func myFunc() -> Int   //只声明不实现
}

class AnotherClass2 : AnotherProtocol2{
    func myFunc() -> Int {  //实现方法
        return 10
    }
}

//2.1.3 突变方法要求
//能在方法或函数内部改变实例类型的方法称为突变方法. (mutating关键字)
//在类中,可以不写mutating, 但在结构体与枚举中国必须写
protocol Togg{
    mutating func togg()
}

enum OnOffSwitch : Togg{
    case Off , On

    mutating func togg() { //改变实例的值
        switch self{
        case .Off:
            self = On
        case .On:
            self = Off
        }
    }
}

var lightSwitch = OnOffSwitch.Off
lightSwitch.togg()   //值变为On

//2.2 协议类型.
//    协议也可以当做类型来使用. 这点和函数一样.
//    1.可作为参数/返回值类型
//2.可作为常量/变量/属性的类型
//3.可作为数组/字典和其他元素类型
protocol MyRect{
    func myLuckNumber() -> Int
}

class MyRectImp : MyRect{
    func myLuckNumber() -> Int {
        return 10
    }
}

class Dice {
    let sides :Int
    var gener : MyRect    //作为类型
    init(sides:Int, gener:MyRect){  //作为参数
        self.sides = sides
        self.gener = gener
    }
}

var dice = Dice(sides: 6, gener: MyRectImp())
dice.gener.myLuckNumber()




//------------------------extention--------------
//使用extension来为已经存在的类型添加功能,就像新的方法和计算属性一样。你可以用extension为已经声明的类型添加协议,甚至是类库中自带的类型。

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}

//使用协议名就像使用其他类型名一样——例如,创建一个不同类型对象的集合,但是这些对象都遵循一个单一的协议。当值的类型是协议类型时,在协议定义以外的方法是不可用的。
//[plain] view plaincopy在CODE上查看代码片派生到我的代码片
let protocolValue: ExampleProtocol = a
protocolValue.simpleDescription
//即使protocolValue有一个运行时类型(simpleClass),编译器同样会把它看作是ExampleProtocol类型。也就是说,你不能访问除了遵循协议以外的类的方法和属性。


//一、扩展(extension)
//扩展 extension (类似OC中的分类, 但Swift中没有名字), 即在没有权限获取到原始代码的情况下, 为类增加新功能.
//注意: 只要定义了扩展, 那么该扩展对该类的实例都是可用的.
//extension SomeType{
//    //添加到SomeType的新功能写在这里
//}

//1.1扩展属性(只能是计算属性)
//扩展可以添加新计算属性, 但是不能添加存储属性(也不可以添加属性观察).
extension Double{  //为API中的已有类型添加实例属性
    var km : Double { return self * 1_000.0 }
    var m : Double { return self }
    var cm : Double { return self / 100.0 }
}

let jjLength = 1.m  // 1与m进行点运算, 表示1的Double值
let jjLength_km = 1.km
print(10.km + 1.m)

//1.2扩展构造器
//可以定制自己的构造器
class MyClass{
    var a : Int
    init(){
        a = 10
    }
}

extension MyClass{
    convenience init( parm:Int){   //扩展构造器
        self.init()
        print("扩展构造器--->便利构造器, \(parm)")
    }
}

var myClass = MyClass(parm: 9)

//1.3扩展方法
//下面是像Int中扩展myIntFunc方法
extension Int{
    func myIntFunc(){
        print("值为\(self) , 哈哈哈哈!")
    }
}

1.myIntFunc()

//1.3.1 修改实例方法
//通过扩展方法, 可以修改该实例self本身.但是方法前要加 mutating
extension Double{
    mutating func myMoidfySelfValue() {
        self = self * self //修改self实例的值
    }
}

var d = 2.0
d.myMoidfySelfValue()

//1.4 扩展嵌套类型
//即向已有的嵌套类型中添加新的嵌套类型. 还可以扩展下标(附属脚本)等.
extension Character {
    enum Kind{   //嵌套了一个枚举类型
        case Big
        case Small
    }
    var k : Kind{
        if(String(self).lowercaseString == "a"){
            return Kind.Big
        }else{
            return Kind.Small
        }
    }
}
var ch : Character = "a"
ch.k   //返回一个枚举值Kind.Big

//1.5下标(Subscripts)
//扩展可以向一个已有类型添加新下标。这个例子向Swift内建类型Int添加了一个整型下标。该下标[n]返回十进制数字从右向左数的第n个数字
//123456789[0]返回9
//123456789[1]返回8
//...等等
extension Int {
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 1...digitIndex {
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}
746381295[0]
// returns 5
746381295[1]
// returns 9
746381295[2]
// returns 2
746381295[8]
// returns 7

//如果该Int值没有足够的位数,即下标越界,那么上述实现的下标会返回0,因为它会在数字左边自动补0:
746381295[9]
//returns 0,

//即等同于:
0746381295[9]

//1.6嵌套类型(Nested Types)
//扩展可以向已有的类、结构体和枚举添加新的嵌套类型:
extension Character {
    enum Kind1 {
        case Vowel, Consonant, Other
    }
    var kind: Kind1 {
        switch String(self).lowercaseString {
        case "a", "e", "i", "o", "u":
            return .Vowel
        case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
        "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
            return .Consonant
        default:
            return .Other
        }
    }
}

//该例子向Character添加了新的嵌套枚举。这个名为Kind的枚举表示特定字符的类型。具体来说,就是表示一个标准的拉丁脚本中的字符是元音还是辅音(不考虑口语和地方变种),或者是其它类型。
//
//这个类子还向Character添加了一个新的计算实例属性,即kind,用来返回合适的Kind枚举成员。
//
//现在,这个嵌套枚举可以和一个Character值联合使用了:
func printLetterKinds(word: String) {
    print("'\\(word)' is made up of the following kinds of letters:")
    for character in word.characters {
        switch character.kind {
        case .Vowel:
            print("vowel ")
        case .Consonant:
            print("consonant ")
        case .Other:
            print("other ")
        }
    }
    print("\n")
}
printLetterKinds("Hello")
// 'Hello' is made up of the following kinds of letters:
// consonant vowel consonant consonant vowel

//函数printLetterKinds的输入是一个String值并对其字符进行迭代。在每次迭代过程中,考虑当前字符的kind计算属性,并打印出合适的类别描述。所以printLetterKinds就可以用来打印一个完整单词中所有字母的类型,正如上述单词"hello"所展示的。
//
//注意:由于已知character.kind是Character.Kind型,所以Character.Kind中的所有成员值都可以使用switch语句里的形式简写,比如使用 .Vowel代替Character.Kind.Vowel

版权声明:版权所有,不得转载 举报

相关文章推荐

swift学习笔记(19)- 协议

协议语法协议的定义方式与类、结构体和枚举的定义非常相似:protocol SomeProtocol { // 这里是协议的定义部分 }要让自定义类型遵循某个协议,在定义类型时,需要在类型名称后...

Swift 学习笔记 [4] 类 多态和封装、协议、扩展、内存管理

类 多态和封装、协议、扩展、内存管理 一些概括

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

Swift学习笔记系列——(21)协议

Swift学习笔记系列——(21)协议

The Swift Programming Language学习笔记(二十三)——协议

协议 协议语法 属性要求 方法要求 mutating方法要求 构造器要求 构造器要求在类中的实现 可失败构造器要求 协议作为类型 委托代理模式 通过扩展添加协议一致性 通过扩展采纳协议 协议类型的集合...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)