我感觉泛型挺难，希望对你们有帮助
//一个泛型a,b值交换的列子，可以传入什么类型
func mySwap<T>(inout a: T,inout b: T) {
let temp = a
a = b
b = temp
}
var a = 111
var b = 222
mySwap(&a, b: &b)
//普通整形a,b值交换列子，只能传入整形
func mySwap2(inout a: Int,inout b: Int) {
let temp = a
a = b
b = temp
}
var z = "aa"
var y = "bb"
//mySwap2(&z, b: &y)这里报错了，因为这里指定了必须是整形才能进行交换
//Swift<泛型> 模拟实现入栈出栈
//struct Stack<Element> {
// var containers = [Element]()
// mutating func push(e:Element) {
// containers.append(e)
// }
// mutating func pop() ->Element {
// return containers.removeLast()
// }
//}
//
//var data: Stack<Int> = Stack<Int>()
//data.push(1)
//data.push(2)
//data.push(3)
//data.pop()
//加入我们要对一个泛型进行扩展，我们只需要写泛型名就好，不要写<>里面的参数了
//extension Stack {
// var conut: Int {
// return containers.count
// }
//}
//
//var data2 = Stack<String>()
//
//data2.push("adas")
//data2.push("dasdasd")
//data2.conut
//泛型约束
//普通的计算下标的函数
//func index(arr: [Int],data: Int) ->Int {
// for(a,b) in arr.enumerate() {
// if b == data {
// return a
// }
// }
// return -1
//}
//
//let array = [1,4,5,6,3]
//index(array, data: 3)
//泛型的实现方式
//泛型是不可以使用== 必须继承系统的这个协议Equatable
protocol IA{
}
protocol IB{
}
extension Int: IA,IB{
}
func index<T:Equatable where T:IA,T:IB>(arr:[T],data: T) ->Int {
for (m,n) in arr.enumerate() {
if n == data {
return m
}
}
return -1
}
let array2 = [1,3,8,2]
index(array2,data:8)
class Person {
var salary = 0
}
func calc<T: Person>(persons:[T]) -> Int {
var total = 0
for p in persons {
total += p.salary
}
return total
}
//协议的关联类型
//协议的关联类型（associative type）
protocol Containter {
typealias Element
mutating func push(e: Element)
mutating func pop()-> Element
}
struct MyStack: Containter{
// typealias Element = Int
var containers = [Int]()
mutating func push(e: Int) {
containers.append(e)
}
mutating func pop() -> Int {
return containers.removeLast()
}
}
struct Stack<Element>: Containter {
//按照当前的实现，下面的代码由于类型推断，可以省略
// typealias Element = E
var containers = [Element]()
mutating func push(e: Element) {
containers.append(e)
}
mutating func pop() -> Element {
return containers.removeLast()
}
}
typealias MyInt = Int //给Int取个别名
let i: MyInt = 3
typealias s = String
let ss: s = "121212"
//扩展协议时的约束以及与协议关联类型的使用
protocol MM {
}
class MMClass: MM {
}
protocol NN : MM{
}
class NNClass: NN {
}
protocol Container {
typealias ItemType
}
extension Container where ItemType: MM {
var b: Int {return 5}
}
extension Container where ItemType: NN {
var b: Int {return 6}
}
class TestTest: Container {
typealias ItemType = MMClass //如果这里改为MMClass，那么aaaa.b输出结构是5
}
class TestTest2: Container {
typealias ItemType = Int
}
let aaaa = TestTest2()
//aaaa.b 报错
//Swift的修饰符 默认都是internal
internal class TestModifier {
func m() {
}
}
let tu = (TestModifier(),"aa")
//异常 Swfit异常处理有四种方式
//创建自己的异常，也是就错误类
enum PasswordError: ErrorType {
case LengthIsNotEnough
case TooSimple
}
//第一种 抛出去
func validatePwd(pwd: String)throws -> Bool {
let count1 = pwd.characters.count
if count1 < 6 {
throw PasswordError.LengthIsNotEnough
}
if count1 > 10 {
throw PasswordError.TooSimple
}
return true
}
//第二种 解决
do {
//可以写多行代码
try validatePwd("dasdasd")
//可以写多行代码
}catch {
print("error")
}
//第三种
let result = try?validatePwd("dadada")
if result == nil {
print("调用时出错")
}
//第四种
let result2 = try! validatePwd("dasdhua")
//defer有点类似异常处理中得finally，但是他也是可以用在非异常处理的情况
func m() {
print("你好")
defer {
print("你们好")
}
print("大家好")
}
m()