01-extension

//: Playground - noun: a place where people can play

importUIKit

varstr ="Hello, playground"

// extention: Double添加计算属性

extensionDouble{

//默认get以及{}可以省略

varkm:Double{returnself*1_000.0}

varm:Double{returnself}//基本单位:m

varcm:Double{returnself/100.0}

varmm:Double{returnself/1_000.0}

varft:Double{returnself/3.28084}

}

letimDouble:Double=100.85.km

letimMeter:Double=1.85.m

//对Int结构体添加计算属性和自定义方法

extensionInt{

varsquare:Int{returnself*self}

varcube:Int{returnself*self*self}

//自定义方法:重复执行多个任务(逻辑)

funcrepetitions(task: () ->Void) {

for_in0..

task()

}

}

}

letimInt =10

funcrepeatFunc() {

print("repeat!!!!")

}

10.repetitions(repeatFunc)

//自定义的类，使用扩展的方式，添加自定义的方法(method)

structPoint {

varx =0.0

vary =0.0

}

structSize {

varwidth =0.0

varheight =0.0

}

classRectangle {

varorigin =Point()

varsize =Size()

init(origin:Point, size:Size) {

self.origin= origin

self.size= size

}

//.......

}

extensionRectangle{

//添加平移方法

functranslate(x:Double, y:Double) {

self.origin.x+= x

self.origin.y+= y

}

}

letrectangle =Rectangle(origin:Point(), size:Size(width:20, height:100))

rectangle.translate(-5, y:5)

rectangle.origin.x

02-generic

//: Playground - noun: a place where people can play

importUIKit

varstr ="Hello, playground"

funcswapTwoInt(inouta:Int,inoutb:Int) {

(a, b) = (b, a)

}

vara:Int=0

varb:Int=6

swapTwoInt(&a, b: &b)

a

b

funcswapTwoDouble(inouta:Double,inoutb:Double) {

(a, b) = (b, a)

}

//使用泛型函数优化上面问题: T: template;

funcswapTwoData(inouta:T,inout_b:T) {

(a, b) = (b, a)

}

varhello ="hello"

varbye ="bye"

swapTwoData(&hello, &bye)

hello

bye

//系统默认提供了一个交换两个任意类型的函数

//swap(&<#T##a: T##T#>, &<#T##b: T##T#>)

//泛型类型

//声明三个容器类(数组/字典/集合)

vararray =Array()

vararrayTwo: [Int] = []

vardictionary =Dictionary()

varset =Set()

//自定义泛型结构体:描述栈Stack

/*栈:后进先出

*结构体：属性(数组)、方法(入栈/出栈/是否为空)

*

*/

varitems = [Int]()

structStack {

//数组，存储栈中的数据

varitems = [T]()

//栈是否为空

funcisEmpty() ->Bool{

returnitems.count==0

}

//入栈: items数组的最后添加数据

mutatingfuncpush(item:T) {

items.append(item)

}

//出栈:删除数组的最后一项

mutatingfuncpop() ->T? {

//if self.isEmpty() {

//return nil

//} else {

//return items.removeLast()

//}

guard!self.isEmpty()else{

returnnil

}

returnitems.removeLast()

}

}

//对上面的泛型结构体扩展

extensionStack{

//添加只读计算属性,获取栈中最上面的item(数组的最后一个)

vartopItem:T? {returnitems.last}

//自定义的方法，返回当前栈中数据个数(数组的个数)

funccount() ->Int{

returnitems.count

}

}

//var array = Array()

//实例化

varstackWithInt =Stack()

stackWithInt.push(1)

stackWithInt.push(2)

stackWithInt.push(3)

stackWithInt.pop()

stackWithInt.topItem

varstackWithString =Stack()

stackWithString.push("Maggie")

stackWithString.push("Bob")

stackWithString.push("Jonny")

stackWithString.topItem

stackWithString.count()

stackWithString.pop()

/**

*课堂练习：创建队列结构体(泛型); FIFO:先进先出

*属性(数组)

*方法(添加数据到队列；移除队列；是否为空)

*/

/* GCD队列分类：

*串行队列Serial Queue(创建)；并行队列Concurrent Queue(创建)；主队列Main Queue(获取)；全局队列Global Queue(获取)

//回到主线程

dispatch_async(dispatch_get_main_queue(), ^{})

*/

structQueue {

//数组，存储队列中的数据

varitems = [T]()

//队列是否为空

funcisEmpty() ->Bool{

returnitems.count==0

}

//添加：items数组的最后添加数据

mutatingfuncaddItemToQueue(item:T) {

items.append(item)

}

//移除：删除数组的第一项

mutatingfuncremoveFromQueue() ->T? {

guard!self.isEmpty()else{

returnnil

}

returnitems.removeFirst()

}

//返回队列中的数据个数

funccountInQueue() ->Int{

returnitems.count

}

//使用自定义方法获取该队列中的第一项

funcfirstItemFromQueue() ->T? {

returnitems.first

}

}

//实例化

varqueueWithString =Queue()

queueWithString.addItemToQueue("Maggie")

queueWithString.addItemToQueue("Bob")

queueWithString.addItemToQueue("Jonny")

queueWithString.removeFromQueue()

queueWithString.countInQueue()

queueWithString.firstItemFromQueue()

//简单例子

structPair {

vara:T1

varb:T2

}

vardic =Dictionary()

varpair =Pair(a:0, b:"hello")

pair.a

pair.b

03-class-inher-poly

//: Playground - noun: a place where people can play

importUIKit

varstr ="Hello, playground"

/*封装Encapsulation

* 1.类的继承Inheritance/Inherite

* 2.类的多态Polymorphism

*/

classAvatar {

//两个存储属性

varname:String

varlife =100

varisAlive:Bool=true

init(name:String) {

self.name= name

}

//计算属性:描述当前角色的名字

vardescription:String{

get{

return"I'm Avatar\(name)"

}

}

//自定义方法：收到攻击

funcbeAttacked(attack:Int) {

life-= attack

iflife<=0{

isAlive=false

}

}

}

//玩家

classUser:Avatar{

//新添加两个存储属性

//分数/级别

varscore =0

varlevel =0

//重写父类的description计算属性(重写get方法)

overridevardescription:String{

get{

return"I'm User\(name)"

}

}

//添加自定义方法

funcgetScore(score:Int) {

self.score+= score

ifself.score>level*100{

self.level+=1

}

}

}

classMagician:User{

//魔法值

varmagic =100

//重写父类的description计算属性(重写get方法)

overridevardescription:String{

get{

return"I'm Magician\(name)"

}

}

funcheal(user:User) {

user.life+=10

}

}

//战士

classWarrior:User{

varweapon:String?

//重写/覆盖

overridefuncbeAttacked(attack:Int) {

life-= attack /2

iflife<=0{

isAlive=false

}

}

}

classMonster:Avatar{

funcattack(user:User, amount:Int) {

user.beAttacked(amount)

}

}

finalclassZombie:Monster{

vartype ="Default"

}

//多态性

funcprintBasicInfo(avatar:Avatar) {

print("The avatar's name is\(avatar.name)")

print("The life is\(avatar.life). He is\(avatar.isAlive)?")

}

//实例对象

varwarrior=Warrior(name:"Warrior")

varmagician =Magician(name:"Harray Potter")

magician.name

magician.heal(warrior)

warrior.life

warrior.beAttacked(10)

warrior.life

varzombie=Zombie(name:"default Zombie")

zombie.attack(warrior, amount:20)

warrior.life

magician.heal(warrior)

varmonster=Monster(name:"Monster")

printBasicInfo(magician)

printBasicInfo(warrior)

printBasicInfo(zombie)

printBasicInfo(monster)

vararray: [Avatar] = [warrior,magician,zombie,monster]

forvalueinarray{

print("\(value.description)")

}

/*了解：编译型语言的特性

*编译期(编译时类型) +运行期(运行时类型)

*/

/**

* 1.重写/覆盖(overwrite/override):子类的方法覆盖父类的方法(要求方法名和参数名都相同)

* 1.1场景:父类的属性和方法不足以来描述子类的特性，需要用到重写/覆盖

* 1.2 Swift语言中，重写父类的方法；也可以重写父类的计算属性(get/set)

* 2.重载(overload):在同一个类中的两个或者两个以上的方法，拥有相同的方法名，但是参数不相同(个数/类型)。最常见的重载就是类的构造函数(init方法)

*

*/

Day05

新内容

类：扩展Extension(OC: Category);泛型(Generic)

类：继承/多态...

1.extension:扩展:

->对象：系统存在的和自定义 ->类/结构体/枚举/协议

->内容：添加计算型属性; 自定义的方法(也包括构造方法)

2.样例：对Double结构体添加计算属性；自定义类添加方法(extension)

[ 01-extension ]

NSArray

Generic: 泛型

1. 描述：不指定任何类型的类型; 分为泛型函数和泛型类型

2. 问题：交换两个整型/字符串/Float/Double/类型数据;

-> 方法的逻辑：交换两个数据；只是类型不同

-> 解决方案：使用泛型函数

3.样例：如何使用泛型函数解决“问题”

[ 02-generic ]

/1603/08_Swift/Day05/Day05-AM1.zip

4.样例：创建泛型类型：描述”栈”结构体

[ 02-generic ]

/1603/08_Swift/Day05/Day05-AM2.zip

5. 课堂练习：仿照”栈”结构体，创建“队列”结构体

/1603/08_Swift/Day05/Day05-AM3.zip

——————————— 下午内容 ———————

6. 类的继承: OC/Swift语言都是单继承

7.样例：创建下面六个类，继承关系如下：

[ 03-class-inher-poly ]

viewController: UIViewController

/1603/08_Swift/Day05/Day05-PM1.zip

#prama mark - UITableViewDataSource

-> Swift：

extension ViewController {

func tableView…..

}

#prama mark - UITableViewDelegate

extension ViewController {

func tableView…..

}

样例：计算器样例(不包含协议语法)

1. 课堂版本：UIStackView(iOS9新视图)

2. 案例：使用Swift语法实现

[ Calculator ]

终结版本：

Day05知识点：

—> 扩展extension相关：

1.描述：对已存在的和自定义的类/结构体/枚举添加计算属性和方法

2.语法：extension关键词

—> 泛型Generic相关：

1. 泛型函数

funcswapTwoData(inouta:T,inout_b:T) {

(a, b) = (b, a) }

2. 泛型类型

structQueue {}

—>重写和重载override

1.重写/覆盖(overwrite/override):子类的方法覆盖父类的方法(要求方法名和参数名都相同)

1.1场景:父类的属性和方法不足以来描述子类的特性，需要用到重写/覆盖

1.2 Swift语言中，重写父类的方法；也可以重写父类的计算属性(get/set)

2.重载(overload):在同一个类中的两个或者两个以上的方法，拥有相同的方法名，但是参数不相同(个数/类型)。最常见的重载就是类的构造函数(init方法)