Swift 2.0 day04

01-class-basic

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

importUIKit

varstr ="Hello, playground"

/* 1.如何声明类、创建对象(不需要继承)

* 2.类是引用类型(对象赋值;不需要mutating)

* 3.object identity(对象的一致性); === !==

* 4.结构体和类的区别？

*/

/*class默认编译器不会创建构造函数

* 1.默认给初始值

* 2.添加构造函数(包含所有的属性;可选型例外)

*/

classPerson {

//存储属性

varfirstName:String//= ""

varlastName:String//= ""

varcareer:String?

//添加构造函数(包含所有)

init(firstName:String, lastName:String, career:String) {

self.firstName= firstName

self.lastName= lastName

self.career= career

}

//添加自定义的方法(修改career)

funcchangeCareer(newCareer:String) {

self.career= newCareer

}

//添加自定义的方法，返回全名

funcfullName() ->String{

returnfirstName+" "+lastName

}

}

//创建实例对象Instance

//var firstPerson = Person()

varfirstPerson =Person(firstName:"Steven", lastName:"Jobs", career:"CEO")

firstPerson.fullName()

//引用类型：Swift语言中类的对象的赋值是地址的赋值

varsecondPerson =firstPerson//地址

secondPerson.firstName="Taylor"

secondPerson.lastName="Swift"

secondPerson.career="Singer"

firstPerson.fullName()

secondPerson.fullName()

// object identity(对象的等价性):两个引用类型是否指向同一片内存空间，如果是，认为两个对象是等价的；否则，不等价

// Swift语言中，“==”用来判断值类型(数值是否相等),不能用来判断引用类型

// secondPerson == firstPerson

secondPerson===firstPerson

//创建实例对象

varthirdPerson =Person(firstName:"Taylor", lastName:"Swift", career:"Singer")

//虽然两个实例对象的值相等，但是并没有指向同一片内存空间

thirdPerson===secondPerson

thirdPerson!==secondPerson

/**结构体和类的选择问题

1.前者是值类型(copy;耗内存)；后者是引用类型

2.前者内存在栈中(效率高);后者内存在堆中(相对慢)

3.前者是不能继承；后者可以继承(重用/重写)

4.前者有默认的构造函数；后者没有(手动添加)

*/

02-property

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

importUIKit

varstr ="Hello, playground"

/* 1.存储属性:存储某个值(var/let);只可以添加到类和结构体

* 2.计算型属性(computed property)：不是简单存储某个值，提供get方法和可选的set方法(也可以不实现; readonly:只读),来间接地(逻辑)获取和设置自己的值，或者设置其他存储属性的值

* 3.类型属性(type property):针对于某种类型的属性

-> Int.max Int.min

* 4.特殊：为存储属性添加属性观察器:观察该属性的值是否越界；溢出；。。。。

*/

//先声明两个结构体(存储属性),类(计算属性)

structPoint {

//存储属性

varx:Double=0.0

vary:Double=0.0

}

structSize {

//存储属性

varwidth=0.0

varheight =0.0

}

//var rectangle = Rectangle(xxxx)

//rectangle.center = Point(x: 200, y:100)

classRectangle {

//左上顶点的坐标

varorigin =Point()

//矩形的大小

varsize =Size()

//声明描述矩形中心坐标点计算型属性

varcenter:Point{

// get方法(必须实现;只实现get方法就是只读性质)

get{

//计算中心的x和y值

letcenterX =origin.x+size.width/2

letcenterY =origin.y+size.height/2

returnPoint(x: centerX, y: centerY)

}

// set方法(可选)

//首先获取要设置的值(Point结构体对象)

// newCenter局部的常量(let)

//set(newCenter) {

////已知矩形的大小,修改左顶点属性的值

//origin.x = newCenter.x - size.width/2

//origin.y = newCenter.y - size.height/2

//}

//简单的set实现; newValue:系统默认提供的要赋值的对象

set{

//已知矩形的大小,修改左顶点属性的值

origin.x= newValue.x-size.width/2

origin.y= newValue.y-size.height/2

}

}

funcgetArea() ->Double{

returnsize.width*size.height

}

//声明只读计算型属性来描述矩形的面积

vararea:Double{

get{

returnsize.width*size.height

}

}

//自定义的构造函数

init(origin:Point, size:Size) {

self.origin= origin

self.size= size

}

}

//实例化Rectangle对象

varrectangle =Rectangle(origin:Point(), size:Size(width:10, height:20))

rectangle.getArea()

rectangle.center.x

rectangle.center.y

rectangle.center=Point(x:10, y:20)

rectangle.origin.x

rectangle.origin.y

//类型属性(type property):属于某个类型(结构体/类);不属于任何一个实例对象

//需求：声明Player玩家类，包含名字存储属性+玩家分数存储属性;需要一个属性记录所有玩家的最高分数(类型属性);添加方法(记录玩家的分数)

classPlayer {

//名字

varname:String

//分数(某个实例对象)

varscore =0

//声明类型属性；记录所有玩家的最高分数

staticvarhightestScore =0

//构造函数，初始化名字

init(name:String) {

self.name= name

}

//自定义一个方法

funcplay() {

// 0 ~ 99随机整数

letscore =random()%100

print("\(name) played and got\(score) scores.")

//将之前的分数累加到该玩家的分数上

self.score+= score

print("Total score of\(name) is\(self.score)")

//将任意一个玩家的分数和最高分比较

ifself.score>Player.hightestScore {

Player.hightestScore =self.score

}

print("Highest score is\(Player.hightestScore).")

print("====================")

}

}

//实例化两个玩家

letfirstPlayer =Player(name:"Magician")

firstPlayer.play()

firstPlayer.play()

letsecondPlayer =Player(name:"Zombie")

secondPlayer.play()

secondPlayer.play()

03-property-observer

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

importUIKit

varstr ="Hello, playground"

/*属性观察器*/

//var imUInt8:UInt8 = 2000

UInt8.max

UInt8.min

//需求：创建灯泡类，特定最大电流:20A(类型属性);声明存储属性，包含属性观察器

classLightBulb {

staticletmaxCurrent =30

varcurrent =0{

willSet{

//将要设置的时候(newValue)

print("Current value will be changed! The change is\(abs(current- newValue))")

}

didSet{

//已经设置完毕(oldValue)

print("Current value was changed and old Value is\(oldValue)")

ifcurrent>LightBulb.maxCurrent {

current=LightBulb.maxCurrent

//current = oldValue

print("New Value is\(current)")

}

}

}

}

//实例化

varlightBulb =LightBulb()

lightBulb.current=100

lightBulb.current=20

//延迟加载属性

//需求：创建闭区间类;两个存储属性,描述左区间和右区间(Int);声明属性，该属性存储整个闭区间所有整数和

/*

- (CLLocation *)userLocation {

if (_userLocaiton == nil) {

_userLocaiton = [[CLLocation alloc] init];

}

return _userLocaiton;

}

*/

classClosedRange {

letstart:Int

letend:Int

//var sum = 0

//延迟属性

lazyvarsum:Int= {

print("start computing sum value")

varresult =0

foriinself.start...self.end{

result += i

}

returnresult

}()//不要忘记()

init(start:Int, end:Int) {

self.start= start

self.end= end

//

//for i in start...end {

//sum += i

//}

}

}

//实例化

varclosedRange =ClosedRange(start:0, end:100)

closedRange.sum

closedRange.sum

closedRange.sum

04-access-control

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

importUIKit

varstr ="Hello, playground"

varstring:String=""

//创建App实例对象？

letapp =App(name:"Angry Bird")

app.name

app.show()

app.switchMode()

app.show()

//创建UI实例对象？无法访问，原因是Internal

//let ui = UI(

05-singleton

importFoundation

publicclassGameManager {

//声明公开的类型属性

publicstaticletdefaultManager =GameManager()

publicvarscore =0

//声明私有的构造函数

privateinit() {

//.....

}

publicfuncaddScore() {

self.score+=10

}

}

Day04

回顾：

1.枚举: 关联类型(常用)

2.结构体: 属性; 自定义构造方法；自定义方法; 可失败的构造方法; mutating关键词(修改结构体中的属性)

新内容：类

1. 面向对象的三个特点：封装、继承和多态

2. OC添加属性两个分类：存储属性(stored property)和计算属性(computed property)

.m 文件中

@interface viewControll: UIViewController {

NSString *newString;

}

@property (nonatomic, strong) NSString *string;

—> 自动会创建set/get方法；自动创建_string属性

3.样例：Swift语言中如何创建类/实例对象？

[ 01-class-basic ]

-> 创建类，可以不继承任何类

4.样例：如何添加计算型属性；类型属性; 属性观察器....

[ 02-property ]

1. 属性观察器(property observer): 对存储属性的值的变化Set做出观察和响应的反应(逻辑)

-> 观察：willSet: 在设置存储属性值之前

-> 响应：didSet：已经设置完存储属性值

2.样例：如何实现”属性观察器”机制； 延迟加载属性

[ 03-property-observer ]

3.访问控制权限(access control)

-> 对象: 结构体/类/属性/方法

-> 目的：

a. SDK(Software Development Kit:软件开发包): public(公开)

b. Framework(框架)中的h文件，能看到，public/internal

-> 三种访问权限：

a. private:私有；限定到某个文件xxxx.swift

b. internal:内部(缺省Default权限); 限定到某个Module(模块); App bundle(Module); Framework(Module)

c. public:公开的；几乎没有限定

4.样例：创建两个类，设置不同的访问权限；

[ 04-access-control ]

-> playground: Module/File

5.单例Singleton:一种设计模式，某个类只创建一个实例对象Instance

[UIApplicationsharedApplication]

[NSFileManagerdefaultManager]

[NSUserDefaultstanstardUserDefault]

—> OC中创建单例对象的方法

a. 常用的使用static创建-> 线程不安全

b. GCD中dispatch_once一次性任务 -> 线程安全

c. 加锁 synchronize

d. 实现initialization方法实现

6.样例：如何创建单例对象;

[ 05-singleton ]

-> init构造函数(private);

-> 声明属性(let)

Day04知识点：

—> 类声明/创建相关:

1.声明:使用class关键词，添加自定义构造函数；添加自定义方法；

2.创建：使用自定义构造函数创建类的实例对象

3.类对象的等价性：使用===或者!==来判定两个引用类型是否等价; 如果两个引用类型指向内存中同一片内存空间，表示等价，即===返回true; 否则返回false

—> 属性相关：

1. 存储属性(stored property): var/let修饰，存储某个值

-> 添加属性观察器(property observer):willSet/didSet

2. 计算属性(computed property): get/set两个方法，去获取/设置属性(自己/其它属性)

3. 类型属性(type property)：static修饰

4. 延迟加载属性(lazy property): 和OC中的懒加载思路一致

—>场景：

a. 当某个属性(延迟属性)的初始化依赖于其它的属性初始化

b. 当某个属性(延迟属性)的计算耗时(占用资源), 不应该在类的初始化阶段计算

->描述：在类的初始化阶段，不赋值；直到使用/创建的时候才赋值；只赋值一次

->语法：关键词lazy;

—> 访问权限(access control)相关

1. 一般原则：统统先设定为private(结构体/类/属性/方法)，限定到某个文件内部可见；希望暴露哪个属性/方法，再设置为public

—> 创建单例:

1.语法：

a. 将init构造函数设置为private权限，init方法的调用限定在文件内部

b. 声明公开的类型属性(static)，使用let修饰，保证只可以初始化一次

2.样例如下：

publicclassGameManager {

//声明公开的类型属性

publicstaticletdefaultManager =GameManager()

publicvarscore =0

//声明私有的构造函数

privateinit() {

//.....

}

publicfuncaddScore() {

self.score+=10

}

}