1. 协议(Protocol)：与OC之间唯一不同的是Swift中的协议不管是属性还时方法全部是必须实现的
/** protocol*/
protocol FullNamed {
/** 计算属性申明,只读的计算属性*/
var fullName:String { get }
}
/** 实现协议*/
struct Person:FullNamed {
/** 实现协议 可以把计算属性实现为存储属性，更改其本身的性质*/
var fullName: String = "abc"
}
/** 开发中的协议*/
protocol MyPotocol {
//计算属性的get set声明
var prop:Int {
get
set
}
var onlyRead:Int{ get }
//实例方法
func instanceMethod()->Int
//静态方法或者类方法
static func typeMethod()
}
class MyClass: MyPotocol {
var prop:Int = 10
var onlyRead:Int = 10
func instanceMethod() -> Int {
return 10
}
//此处按规范应该写static
class func typeMethod() {
print("class method")
}
}
var mc = MyClass()
mc.prop = 3
MyClass.typeMethod()
mc.instanceMethod()
mc.onlyRead = 5
mc.onlyRead
protocol SomeProtocol {
init(a: Int)
func test() -> Int
}
class parent {
init(a:Int){}
}
/** Swift中的协议的所有方法都必须实现,此处MyClass需要实现协议就需要对父类的方法进行改写，所以同时改写方法和实现required协议，前面使用 override 和 required关键字组合搭配：*/
class MyClass1: parent,SomeProtocol {
override required init(a:Int) {
super.init(a: 100) //改写内部实现方法依然为父类的方法。
}
func test()->Int {
return 1
}
}
//使用OC中的协议方式
@objc protocol ObjecProtocol {
func requiredMethod()
optional func optionalMethod()
}
class ObjectClass:ObjecProtocol {
@objc func requiredMethod() {
}
}
var r2 = Rect(x: 100, y: 200, w: 33, h: 2)
2.扩展(Extension),Swift中使用扩展的原则
不可以再扩展中定义存储属性，这是格式，定义了会报错，无法执行
可以再扩展中定义计算属性
extension Double{
//不可以在扩展中定义存储属性
//错误 var i = 10
//可以在扩展中定义计算属性
var km:Double {
return self/1000.0
}
var cm:Double {
return self * 100.0
}
/** 扩展一个方法实现四舍五入*/
func round()->Int{
//整数情况
return Int(self + 0.5)
}
}
350.0
print(350.5.km)
print(350.5.cm)
print(350.49.round())
print(350.50.round())
struct Point {
var x = 0.0
var y = 0.0
}
struct Size {
var w = 0.0
var h = 0.0
}
struct Rect {
var origin = Point()
var size = Size()
}
var r = Rect()
//通过扩展一个带有四个参数的初始化器使得Rect在初始化的时候可以同时赋上四个值
extension Rect {
init(x:Double,y:Double, w:Double, h:Double){
self.origin = Point(x: x, y: y)
self.size = Size(w: w, h: h)
}
}
//其实上面的操作和OC里面的 -(id)initWithName:(NSString*)name andAge:(int) age{ if (self = [super init]; self.name = name, self.age = age)}功能是差不多的，只是表现形式不同而已
还可以通过扩展对系统类型的空间进行增加方法或者计算值属性
extension UIButton {
func show(){
print(self.tag)
}
}
3. 泛型(genericity): 字面意思理解就是广泛地被使用的类型,言外之意可以充当很多中类型。并且在赋值的时候它会根据系统的自动推倒公司变成制定的类型(Swift语言所期望的类型)
比如当我有很多个不同类型它门需要调换值,且实现逻辑一样。
函数+<T>指定T是一个泛型 T就代表各种类型的类型了
func swapTwoValues<T>(inout a:T,inout b:T) {
let temp = a
a = b
b = temp
}
swap(&str1, &str2)
str1
str2
/**类型的范型 Array<Double 属于一个类型> */
var arr:Array<Double> = Array()
struct Instack {
private var items = [Int]()
/**栈的特点后进先出*/
mutating func push(item:Int){
items.append(item)
}
mutating func pop(item:Int){
items.removeLast()
}
}
/**T属于一个类型函数，必须根据用户制定，通过Stack制定T(数组中元素的类型)*/
struct Stack<T> {
private var items = [T]() //一个任意类型的数组,当T被指定为什么类型，那么该数组就为什么类型］
/**这里利用栈的特定，后进先出 构造一个数组*/
mutating func push(item:T){
items.append(item)
mutating func pop(item:T){
items.removeLast()
}
}
var intStack:Stack<Int> = Stack()
var StringStack:Stack<String> = Stack()
4. 访问控制public表示在任何地方都能访问
internal表示在本项目能访问，为了限制类成员的作用阈在类的作用阈范围内，所以在类的内部不能使用public
private 职能在本.xxx文件中访问
/** 任何地方都可以访问*/
public class AClass {
}
/** 在本项目中访问*/
internal class IClass {
}
/**限于本文件中*/
private class CClass {
}
/** internal*/
class FClass {
//属性的权限不能高于类 public var = c = 2
internal var a = 10
private var b = 20
}
var fc:FClass = FClass()
fc.a
fc.b
5. 异常处理:非常有用，尤其在后续开发设计用户体验度相关问题的时候。**********************
/**异常处理(exception) ，这是OC常用的描述，而在我们的Swif提供了一类错误的支持，包括运行时抛出错误，捕捉错误，以及控制收回错误，使用了一个符合的ErrorType协议来表示。
1. 定义错误type,一般为枚举值,需要用一个值把程序中的问题表达出来
2. 根据不同的运算结果返回不同的ErrorType枚举值
3. 处理抛出的异常，通常采用 throws{ } 方法来判断不同的逻辑值后再调用throw选择性的抛出错误值
4. 处理抛出的异常，采用 do { try } catch 枚举值{ }catch枚举值{ }，这样一个循环监听事件，持续的尝试去判断逻辑抛出一异常，然后执行接收异常。
*/
/** 自动售货机的Error*/
enum VendingMachineError:ErrorType {
case InvalidSelection //没有物品或者选择错误，选择物品错误
case OutOfStock //超出了范围,数量不够
case InsufficentFounds(required:Double) //前不够,差多少
}
/** 商品条目*/
struct Item {
var price:Double
var count:Int
}
/** 商品的数组*/
var inventory = ["可乐":Item(price: 1.25, count: 0),"