上一回//www.greatytc.com/p/fe204df5e1f5
------结构与枚举
---结构
红色重点
class RPoint{
var x:Int
var y:Int
init(x:Int, y:Int){
self.x=x
self.y=y
}
deinit{
print("clean up")
}
}
struct SPoint{
var x:Int
var y:Int
var z:RPoint
}
var rp=RPoint(x:10, y:20)
//struct有默认按成员初始化器
var sp1=SPoint(x:10, y:20, z: RPoint(x: 100,y: 200))
var sp2=sp1
print(" \(sp1.x), \(sp1.y), \(sp1.z.x), \(sp1.z.y)")
print(" \(sp2.x), \(sp2.y), \(sp2.z.x), \(sp2.z.y)")
sp1.x+=10
sp1.y+=10
sp1.z.x+=10
sp1.z.y+=10
//会发现2的x,y没有随1的x,y改变而改变.
//但是2zx,zy就随着1的zx,zy 改变而改变.
//随意关于数据修改方面 不要在struct内定义引用类型
print(" \(sp1.x), \(sp1.y), \(sp1.z.x), \(sp1.z.y)")
print(" \(sp2.x), \(sp2.y), \(sp2.z.x), \(sp2.z.y)")
---结构与类的相同点与不同点(struct VS Class)
---枚举类型
//定义枚举类型
enum Color {
case Red
case Green
case Blue
}
enum ComplexColor{
case Red,Green,Blue,Alpha
}
//枚举的使用
var c1=Color.Red
var c2:Color
c2 = Color.Green
c1 = .Blue
var c3=c1
//全局函数使用枚举类型
func print(color: Color){
//switch类型要包含所有枚举类型
switch color {
case .Red:
print("Red Color!")
case .Green:
print("Green Color!")
case .Blue:
print("Blue Color!")
//default:(可以省略剩余的)
//print("剩余的")
}
}
//基本属于用于计算性
//指定原始类型
enum WeekDay: Int{//类型只能是字符,字符串,整数.或者浮点数
case Monday=1, Tuesday, Wednesday,Thursday, Friday, Saturday, Sunday
}
var day: WeekDay?
day = WeekDay(rawValue: 7)
var data=WeekDay.Saturday.rawValue
class Point{
var x=0
var y=0
init(x:Int, y:Int){
self.x=x
self.y=y
}
}
//枚举关联值
enum Position{
case Number(Point)
case Name(String)
}
var p1=Position.Number(Point(x: 123,y: 588))
var p2=Position.Name("Shanghai People's Square")
func print(position: Position){
switch position {
case .Number(let number):
print("[\(number.x), \(number.y)]")
case .Name(let name):
print(name)
}
}
print(p1)
print(p2)
------继承与多态
Snip20160515_25.png
struct Point{
var x=0
var y=0
}
class Shape{
var no=0
func move() {
print("NO: \(no) Shape.move")
}
}
class Rectangle: Shape{
var leftUp=Point()
var width=0
var height=0
}
class Circle: Shape{
var center=Point()
var radius=0
}
func process(shape: Shape){
shape.no += 1
shape.move()
}
var r1=Rectangle()
var c1=Circle()
//成员复用
r1.no += 1
r1.move()
c1.no += 1
c1.move()
//类型抽象
process(c1)
process(r1)
var s:Shape
s=c1
s=r1
class Shape{
var no=0
//0x000340
final func show(){
print("Shape.show")
}
//0x000640
func move() {
print("Shape.move")
}
}
//override多态定义
//Rectangle 重写
class Rectangle: Shape{
override var no: Int {
get{
print("Rectangle.no.get()")
return super.no
}
set{
print("Rectangle.no.set()")
super.no=newValue
}
}
//0x000880
override func move() {
print("Rectangle.move")
}
}
//override多态定义
class Circle: Shape{
override func move() {
print("Circle.move")
}
}
func process(shape: Shape){
shape.no += 1
shape.move() //根据实际类型来调用
}
//变量有双重身份：
//1. 声明类型
//2. 实际类型
var sp: Shape
sp=Shape()
sp.move() // JMP GetVirtualMethod(sp) 二次指针间接运算
sp.show() // JMP 0x000340
//换实际类型
sp=Rectangle()
sp.move() // JMP GetVirtualMethod(sp) 二次指针间接运算
process(sp)
sp=Circle()
sp.move()
process(sp)
class Base{
var data1:Int
init(){
data1=100
print("\(data1)")
print("Base.init")
}
deinit{
print("Base.deinit")
}
}
class Sub1: Base{
var data2=200
//自动继承base的初始化器
//自动继承父类的析构器
}
class Sub2: Base{
var data2=200
//不继承Base初始化器,使用自己的初始化器
//override 初始化器的原型一致的时候使用
override init(){
super.init()//手动调用父的初始化器,还有想调用父类的属性也要手动
//不调用回自动生成
print("\(data1), \(data2)")
print("Sub.init")
}
deinit{
//子类调用完 会自动调用父类的析构器 super.deinit
print("Sub.deinit")
}
}
func process(){
var a:Base
a=Base()
print("----------")
var b:Base
b=Sub1()
print("----------")
var c:Base
c=Sub2()
print("----------")
}
process()
------协议
协议很少使用到静态属性
struct 实例方法要加上mutating
---协议变量的内存模型遵从实际类型的内存模型
引用类型传值.拷贝采用传引用方式
值类型传值.采用拷贝传值方式
---检查协议类型
使用is检查类型是否实现了协议
使用as?和as!将类型下追溯转型为协议
protocol AProtocol {
func display()
}
class Base {
var no = 0
}
class sub: Base,AProtocol {
func display() {
print(no)
}
}
//Compilt-time Type = 编译时类型,声明类型
var item1 , item2:Base
//Runtime Type = 运行时类型,实际类型
item1 = Base()
item2 = sub()
if (item1 is AProtocol){
print("item1是AProtocol的基类")
}
if (item2 is AProtocol){
print("item2是AProtocol的基类")
}
var item3:AProtocol?
var item4=sub()
//item3 = item1//不能写,因为var item3:AProtocol? 而item1 :base
item3 = item1 as? AProtocol //as?多态转型
item3 = item2 as? AProtocol
item3 = item4
---协议中的属性
--协议可以定义只读属性,也可以定义读写属性
--协议可以定义实例属性,也可以定义类型属性
--协议中只能定义变量属性,不能定义常量属性
--实现协议并不要求实现为储存属性还是计算属性
---协议中的方法
-协议可以定义实例方法,也可以定义类型方法
--协议中方法不能定义参数默认值
--针对值类型的mutating协议方法
-值类型(struct and enum )实现的实例方法如果要更改实例本身,需要在协议方法的定义中标明mutating关键字,同时在方法实现时也添加mutating关键字
-添加了mutating的协议方法,对类的实现方法无影响.在类内实现mutating协议方法时,无需再添加mutating关键字
---协议中的初始化器
--协议可以定义初始化器,但是不能定义析构器
--当class中实现协议定义的初始化器时候,需要添加required关键字
-标明子类也需要提供该初始化器
-如果定义为final类就不需要required关键字
--协议可以定义可失败的初始化器 init?,具体实现时可以失败,也可以非失败
----更多协议形式
---协议继承
--协议可以继承一个或者多个协议
--实现子协议类型,也必须实现父类协议中约定成员
---协议组合
--可以实现组合协议类型,使用protocol<A,B,.....>来组合多个协议
--显示组合协议类型,必须实现组合协议中的每一个协议.
--组合协议是一个临时类型
---可选协议
--协议的某些成员可以定义为optional ,不必实现
--可选协议只能应用于class,不能引用于struct和enumeration
--可选协议必须表用@objc特性
@import Foundation
//协议继承
protocol AProtocol{
func display()
}
//B协议继承A协议
protocol BProtocol:AProtocol {
func invoke ()
}
protocol CProtocol {
func excute ()
}
//ClassA BProtocol 要实现A协议的display也要同时B协议invoke
class ClassA: BProtocol {
func display() {
print("dispaly")
}
func invoke() {
print("invoke")
}
}
class ClassB: AProtocol,CProtocol {
func display() {
print("dispaly")
}
func excute() {
print("excute")
}
}
//协议组合,临时类型
func process (item:protocol<AProtocol,CProtocol>){
//可以调用a.c协议其中一个
item.display()
item.excute()
}
var b = ClassB()
process(b)
@objc protocol DProtocol{
optional var discription:String{get}
optional func move()
}
// DProtocol成员里面添加optional ClassC 就不用DProtocol实现成员
class ClassC: DProtocol {
}
------字符串
//String是一个Struct,但内部包含一个指向堆上的"内容指针",其指向的对象存放真正的字符串内容
var srt1:String = "Hello"
var srt2 = "Hello,World"
var srt3 = "I am programming in Swift"
print(sizeofValue(srt1))
print(strideofValue(srt1))
print(sizeofValue(srt2))
print(strideofValue(srt2))
print(sizeofValue(srt3))
print(strideofValue(srt3))
import Foundation
/*
-----------------------------
*/
//使用var和let控制字符串的可变性
var str1 = "Hello"
let str2 = ",Swoft"
//str1+=str2
//枚举字符
for item in str1.characters{
print(item)
}
for index in str1.characters.indices{
print(str1[index])
}
print(str1.characters.count)
print(str1[str1.startIndex])
//不能提出某个字符
//str1[1]
//起始字母
print(str1[str1.startIndex])
//起始字母的下一个字符
print(str1[str1.startIndex.successor()])
//最后一个字符
print(str1[str1.endIndex.predecessor()])
//起始字母往后数第四个距离的子午
let index = str1.startIndex.advancedBy(4)
print(str1[index])
/*
-----------------------------
*/
//链接字符串
//1.用appendContentsOf
str1.appendContentsOf(",World")
//2.+ 和+=号
var str3 = str1+str2
str1+=str2
//3.用append方法
var char:Character="!"
str1.append(char)
//字符转义
let heart = "\u{2665}"
print(heart)
//\t空出一个位置
let work = "\tHello"
print(work)
//插值
var x=100
var y=200
var text = "[\(x),\(y)]"
//字符串比较
var text1 = "Swift"
var text2 = "Swift"
var text3 = "swift"
print(text1==text2)
print(text1==text3)
import Foundation
var str1 = "Hello"
var str2 = str1
str1.appendContentsOf(",Work")
print(str1)
print(str2)
缓存容量与增长
import Foundation
var str = "Hello"
print(str.characters.count)
print(str)
//分配好capacity
str.reserveCapacity(10000)
print(str.characters.count)
------集合类
----数组
//数组声明与实例化
var array1 = [1,2,3,4,5]
var array2 :[Int]
var array3:Array<Int>
//--------------------
class MyClass{
init(){
print("MyClass.init")
}
deinit{
print("MyClass.deinit")
}
}
var objectArray = [MyClass]()
for _ in 1...5{
objectArray.append(MyClass())
}
print(objectArray.count)
////清空元素
objectArray.removeAll()
//变量数组和常量数组
var array5=[1,2,3]
let array6=[1,2,3]
array5.append(40)
array5[3]=4
print(array5)
//数组操作
for item in array5{
print(item)
}
for(index,value) in array5.enumerate(){
print("\(index),\(value)")
}
for index in 0..<array5.count {
print(array5[index])
}
var array7=array5+array6
array5+=[5,6,7]
print(array5.count)
array5[4...6]=[6,7,8]
print(array5)
//加入元素
array5.insert(5, atIndex: 4)//代价大
print(array5)
//删除元素
array5.removeAtIndex(7)//代价大
print(array5)
//缓存容量
var array8=[1,2,3]
array8.reserveCapacity(120)
for index in 4...100{
array8.append(index)
}
//打印口可以清晰看见capacity 的呈倍数上次 最好是一开始定义好capacity的大小
print("\(array8.count).\(array8.capacity)")
Snip20160515_19.png
//copy-0n-write
var array9 = array1
//未修改前array9 与array1 同一个指针
array1[0]=10
array1.append(20)
//修改后array9与array1不同一个指针
print(array1)
print(array9)
----集合
var words = Set<String>()
//不能有重复元素
words.insert("Hello")
words.insert("Swift")
words.insert("Language")
words.insert("Hello")
words.count
words=[]
words.count
var cities1:Set<String>
cities1=["Shanghai"]
for city in cities1.sort(){
print(city)
}
cities1.count
//contains是否含有相同元素
cities1.contains("New York")
var ciries2:Set = ["New York","Shanghai"]
print(cities1.isSubsetOf(ciries2))
//remove清楚元素
cities1.remove("Shanghai")
//是否相等
print(cities1==ciries2)
//2是否含有1的元素
print(cities1.isSubsetOf(ciries2))
----数组
var dictionary1 = [String:Int]()
var dictionary2 :Dictionary<String,Int>
dictionary2=["jason":36,"tom":31,"Marty":44]
for(name,age) in dictionary2{
print("the age of \(name) is:\(age)")
}
for name in dictionary2.keys{
print(name)
}
for value in dictionary2.keys{
print(value)
}
dictionary2.count
//修改元素, 一下两个性质是一样
dictionary2["tom"]=32
dictionary2.updateValue(33, forKey: "tom")
//添加
dictionary2["julie"]=28
dictionary2.count
//shan
dictionary2["Marty"]=nil
dictionary2.removeValueForKey("tom")
dictionary2.count