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
}
}