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方法)