swift_028（Swift 的协议）
//***********swift学习之28--协议--***************************
/*
协议规定了用来实现某一特定功能所必需的方法和属性。
任意能够满足协议要求的类型被称为遵循(conform)这个协议。
类，结构体或枚举类型都可以遵循协议，并提供具体实现来完成协议定义的方法。
*/
// protocol 关键字实现
protocol FirstProtocol {
}
protocol AnotherProtocol {
}
// 遵循某个协议，需要在 类型名称 以冒号:分隔，作为类型定义的一部分。遵循多个协议时，各协议之间用逗号,分隔。
struct SomeStructure: FirstProtocol, AnotherProtocol {
// 结构体内容
}
class SomeSuperClass {
}
// 如果类在遵循协议的同时拥有父类，应该将父类名放在协议名之前，以逗号分隔。
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 类的内容
}
// 协议里怎么规定属性、Mutating方法、构造器
// 1.对属性的规定(协议跟 OC 有些区别的)
// 协议用于指定特定的实例属性或类属性，而不用指定是存储型属性或计算型属性。此外还必须指明是只读的还是可读可写的。
// 协议中的通常用var来声明变量属性，在类型声明后加上{ set get }来表示属性是可读可写的，只读属性则用{ get }来表示。
protocol classa {
var marks: Int { get set }
var result: Bool { get }
func attendance() -> String
func markssecured() -> String
}
protocol classb: classa {
var present: Bool { get set }
var subject: String { get set }
var stname: String { get set }
}
class classc: classb {
var marks = 96
let result = true
var present = false
var subject = "Swift 协议"
var stname = "Protocols"
func attendance() -> String {
return "The \(stname) has secured 99% attendance"
}
func markssecured() -> String {
return "\(stname) has scored \(marks)"
}
}
let studdet = classc()
studdet.stname = "Swift"
studdet.marks = 98
studdet.markssecured()
print(studdet.marks)
print(studdet.result)
print(studdet.present)
print(studdet.subject)
print(studdet.stname)
/*
有时需要在方法中改变它的实例。
例如，值类型(结构体，枚举)的实例方法中，将mutating关键字作为函数的前缀，写在func之前，表示可以在该方法中修改它所属的实例及其实例属性的值。
*/
// 2.对Mutating方法的规定
protocol daysofaweek {
mutating func show()
}
enum days: daysofaweek {
case sun, mon, tue, wed, thurs, fri, sat
mutating func show() {
switch self {
case .sun:
self = .sun
print("Sunday")
case .mon:
self = .mon
print("Monday")
case .tue:
self = .tue
print("Tuesday")
case .wed:
self = .wed
print("Wednesday")
case .thurs:
self = .thurs
print("Thursday")
case .fri:
self = .fri
print("Friday")
case .sat:
self = .sat
print("Saturday")
default:
print("NO Such Day")
}
}
}
var res1 = days.fri
res1.show()
// 3.对构造器的规定
/*
协议可以要求它的遵循者实现指定的构造器。
你可以像书写普通的构造器那样，在协议的定义里写下构造器的声明，但不需要写花括号和构造器的实体，语法如下：
*/
// 协议构造器规定在类中的实现
// 你可以在遵循该协议的类中实现构造器，并指定其为类的指定构造器或者便利构造器。在这两种情况下，你都必须给构造器实现标上"required"修饰符：
protocol tcpIPprotocol {
init(aprot: Int)
}
class tcpClass: tcpIPprotocol {
required init(aprot: Int) {
}
}
// 使用required修饰符可以保证：所有的遵循该协议的子类，同样能为构造器规定提供一个显式的实现或继承实现。
// 如果一个子类重写了父类的指定构造器，并且该构造器遵循了某个协议的规定，那么该构造器的实现需要被同时标示required和override修饰符：
protocol tcpprotocol {
init(no1: Int)
}
class mainClass {
var no1: Int // 局部变量
init(no1: Int) {
self.no1 = no1 // 初始化
}
}
class subClassone: mainClass, tcpprotocol {
var no2: Int
init(no1: Int, no2 : Int) {
self.no2 = no2
super.init(no1:no1)
}
// 因为遵循协议，需要加上"required"; 因为继承自父类，需要加上"override"
required override convenience init(no1: Int) {
self.init(no1:no1, no2:0)
}
}
let res22 = mainClass(no1: 20)
let show = subClassone(no1: 30, no2: 50)
print("res22 is: \(res22.no1)")
print("res22 is: \(show.no1)")
print("res22 is: \(show.no2)")
/*协议类型
尽管协议本身并不实现任何功能，但是协议可以被当做类型来使用。
协议可以像其他普通类型一样使用，使用场景:
作为函数、方法或构造器中的参数类型或返回值类型
作为常量、变量或属性的类型
作为数组、字典或其他容器中的元素类型
实例
*/
protocol Generator {
associatedtype members
func next() -> members?
}
var items = [10,20,30].makeIterator()
while let x = items.next() {
print("ffdfdf0----\(x)")
}
for lists in [1,2,3].map( {i in i*5}) {
print(lists)
}
//
print([100,200,300])
print([1,2,3].map({i in i*10}))
/*
在扩展中添加协议成员
我们可以可以通过扩展来扩充已存在类型( 类，结构体，枚举等)。
扩展可以为已存在的类型添加属性，方法，下标脚本，协议等成员。
*/
protocol AgeClasificationProtocol {
var age: Int { get }
func agetype() -> String
}
class PersonTest {
let firstname: String
let lastname: String
var age: Int
init(firstname: String, lastname: String) {
self.firstname = firstname
self.lastname = lastname
self.age = 10
}
}
extension PersonTest : AgeClasificationProtocol {
func fullname() -> String {
var c: String
c = firstname + " " + lastname
return c
}
func agetype() -> String {
switch age {
case 0...2:
return "Baby"
case 2...12:
return "Child"
case 13...19:
return "Teenager"
case let x where x > 65:
return "Elderly"
default:
return "Normal"
}
}
}
let persom = PersonTest(firstname:"li",lastname:"zhzh")
print("\n\npersom-----\(persom.fullname())\n")
print("\nagetype-----\(persom.agetype())\n\n")
// 协议的继承
// 协议能够继承一个或多个其他协议，可以在继承的协议基础上增加新的内容要求。
// 协议的继承语法与类的继承相似，多个被继承的协议间用逗号分隔：
protocol SomeProtocol {
}
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 协议定义
}
protocol Classa {
var no1: Int { get set }
func calc(sum: Int)
}
protocol Result {
func print(target: Classa)
}
class Student2: Result {
func print(target: Classa) {
target.calc(sum: 1)
}
}
class Classb: Result {
func print(target: Classa) {
target.calc(sum: 5)
}
}
class Studentbb: Classa {
var no1: Int = 10
func calc(sum: Int) {
no1 -= sum
print("学生尝试 \(sum) 次通过")
if no1 <= 0 {
print("学生缺席考试")
}
}
}
class Player {
var stmark: Result!
init(stmark: Result) {
self.stmark = stmark
}
func print(target: Classa) {
stmark.print(target: target)
}
}
var marks = Player(stmark: Student2())
var marksec = Studentbb()
marks.print(target: marksec)
marks.stmark = Classb()
marks.print(target: marksec)
/*
类专属协议
你可以在协议的继承列表中,通过添加class关键字,限制协议只能适配到类（class）类型。
该class关键字必须是第一个出现在协议的继承列表中，其后，才是其他继承协议。格式如下：
*/
protocol SomeInheritedProtocol {
}
protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
// 协议定义
}
protocol TcpProtocol {
init(no1: Int)
}
class FathClass {
var no1: Int // 局部变量
init(no1: Int) {
self.no1 = no1 // 初始化
}
}
class SunClass: FathClass, TcpProtocol {
var no2: Int
init(no1: Int, no2 : Int) {
self.no2 = no2
super.init(no1:no1)
}
// 因为遵循协议，需要加上"required"; 因为继承自父类，需要加上"override"
required override convenience init(no1: Int) {
self.init(no1:no1, no2:0)
}
}
let resff = FathClass(no1: 20)
let showss = SunClass(no1: 30, no2: 50)
print("\nresff is: \(resff.no1)")
print("showss is: \(showss.no1)")
print("showss is: \(showss.no2)\n")
// 协议合成
// Swift 支持合成多个协议，这在我们需要同时遵循多个协议时非常有用。
protocol Stname {
var name: String { get }
}
protocol Stage {
var age: Int { get }
}
struct PersonRR: Stname, Stage {
var name: String
var age: Int
}
func show(celebrator: Stname & Stage) {
print("\(celebrator.name) is \(celebrator.age) years old")
}
let student = PersonRR(name: "Roshan", age: 19)
print(student)
show(celebrator: student)
/*
检验协议的一致性
你可以使用is和as操作符来检查是否遵循某一协议或强制转化为某一类型。
is操作符用来检查实例是否遵循了某个协议。
as?返回一个可选值，当实例遵循协议时，返回该协议类型;否则返回nil。
as用以强制向下转型，如果强转失败，会引起运行时错误。
实例
下面的例子定义了一个 HasArea 的协议，要求有一个Double类型可读的 area：
*/
protocol HasArea {
var area: Double { get }
}
// 定义了Circle类，都遵循了HasArea协议
class Circle1: HasArea {
let pi = 3.1415927
var radius: Double
var area: Double { return pi * radius * radius }
init(radius: Double) { self.radius = radius }
}
// 定义了Country类，都遵循了HasArea协议
class Country: HasArea {
var area: Double
init(area: Double) { self.area = area }
}
// Animal是一个没有实现HasArea协议的类
class Animal1 {
var legs: Int
init(legs: Int) { self.legs = legs }
}
let objects: [AnyObject] = [
Circle1(radius: 2.0),
Country(area: 243_610),
Animal1(legs: 4)
]
for object in objects {
// 对迭代出的每一个元素进行检查，看它是否遵循了HasArea协议
if let objectWithArea = object as? HasArea {
print("面积为 \(objectWithArea.area)")
} else {
print("没有面积")
}
}
swift_028（Swift 的协议）相关推荐
- swift 用协议实现代理传值功能
2019独角兽企业重金招聘Python工程师标准>>> swift 用协议实现代理传值功能 原文 http://blog.csdn.net/whzhaochao/article/d ...
- Swift 面向协议编程 基础篇 （一） 介绍
前言 好久没有写文章了,期末复习周也到了.在复习的同时顺便开了一个专题,面向协议编程,[ 基础篇 ],[ 进阶篇 ],[ 实践篇 ]. 介绍 首先,面向对象(OOP)大家并不陌生,苹果的很多框架都是以 ...
- Swift 面向协议编程的那些事
一直想写一些 Swift 的东西,却不知道从何写起.因为想写的东西太多,然后所有的东西都混杂在一起,导致什么都写不出来.翻了翻以前在组内分享的一些东西,想想把这些内容整理下,写进博客吧.我对计划要写的 ...
- Swift Codeable协议
前言 Swift 4.0版本引入了一种新的对象序列化的方式Codeable,用于代替原先OC语法的NSCode协议. 在程序执行过程中,我们经常需要通过网络发送数据,保存数据到磁盘,这往往是一个对象序 ...
- Swift 使用协议加载Xib
import UIKitprotocol NibLoadable {}extension NibLoadable where Self : UIView {static func loadFromNi ...
- 知道swift为什么是面向协议编程么？不知道，还不快来学习！
swift为什么是面向协议编程 面向协议编程 (Protocol Oriented Programming) 是 Apple 在 2015 年 WWDC 上提出的 Swift 的一种编程范式. 面向协 ...
- Swift协议与扩展
转载:http://www.jianshu.com/p/e70bd6645d88 前言 熟悉Objective-C语言的同学们肯定对协议都不陌生,在Swift中苹果将protocol这种语法发扬的更加 ...
- swift开发之--Protocol(协议)
使用object-c语言的同学们肯定对协议都不陌生,但在swift中苹果将protocol这种语法发扬的更加深入和彻底. Swift中的protocol不仅能定义方法还能定义属性,配合extensio ...
- Swift学习: 从Objective-C到Swift
作者:@方秋枋(GitHub) 这篇文章是自己学习Swift的笔记与深化.希望这篇文章能够帮助已经有Objective-C经验的开发者更快地学习Swift.同时也品味到Swift的精妙之处. 结论放在 ...
最新文章
- 用@Data注解的形式替代类中的setter、getter方法
- OpenvSwitch代码分析之bridge和port
- 基于DotNet构件技术的企业级敏捷软件开发平台 - AgileEAS.NET - 插件标记实现
- 正则表达式-匹配数字范围
- /MD, /MDD, /ML, /MT,/MTD(使用运行时库)
- 跟一个傻逼程序员合作是什么感受？
- 亲儿子 | Azure SignalR 服务现在支持 ASP.NET
- Vue「五」—— 动态组件、插槽、自定义指令
- php 日历哪个好,简单的PHP日历
- LeetCode（783）——二叉搜索树结点最小距离（JavaScript）
- JVM调优及调优参数详解
- win7 、2008 提示Error 1606 Could Not Access Network Location %SystemDrive%/inetpub/wwwroot/ 的错误解决方法...
- 为什么html字体之间有间隔,css字体间隔怎么调整？css文字间隔的调整方法
- PPT模板 | 红色学术风论文答辩PPT模板
- 单片机入门数字电路之边沿触发器
- Java文件压缩加密
- 调用win api将指定名称的打印机设置为默认打印机
- BFC是什么？BFC可以做什么？
- 视频抠像边缘模拟真实光照AE/PR插件 Light Wrap Fantastic
- 通俗理解偏序关系中的八个特殊元（极大、极小、最大、最小元和上界、下界、上确界、下确界）