1. 类
Swift中的结构体和类非常相似，但是又有不同之处
类是具有相同属性、方法的抽象
格式：
class 类名称 {
类的属性、方法
}
class Rect {
var width: Double = 0.0
var height: Double = 0.0
func show() ->Void{
print("width = \(width) height = \(height)")
}
}
类没有逐一构造器
var r1 = Rect()
r1.show()
var r2 = r1
r2.show()
/*
类是引用类型，类之间的赋值其实是将r2指向了r1的存储空间
所以他们两个只想同一块存储空间，修改其中一个会影响到另外一个
*/
r1.width = 99
r1.show()
r2.show()
恒等运算符
用于判断是否是同一个实例，也就是是否指向同一块存储空间
=== !==
var r3 = Rect()
if r1 === r3
{
print("指向同一块存储空间")
}else{
print("指向不同块存储空间")
}
2. 属性
存储属性
Swift中的存储属性就是以前学OC中的普通属性
在结构体或者类中定义的属性，默认就是存储属性
struct Person {
var name: String
var age: Int
}
var p: Person = Person(name: "gaojun", age: 19)
p.name = "高俊"
p.age = 20
常量存储属性
常量存储属性只能在定义时会构造时修改
构造好一个对象之后不能对常量存储属性进行修改
struct Person1 {
var name: String
var age: Int
let card: String // 身份证
}
var p1: Person1 = Person1 (name: "gaojun", age: 21, card: "123456789")
p1.name = "niCai"
p1.age = 22
以下写法是错误的：p.card = "123456"因为构造好对象之后，不能再修改常量存储属性
结构体和类常量与存储属性的关系
结构体和枚举是值类型|||类是引用类型
struct Person2 {
var name: String
var age: Int
}
let p2: Person2 = Person2(name: "sb", age: 23)
因为结构体是值类型，所以不能修改结构体常量中的属性
不能修改结构体/枚举常量对象中的值，因为他指向对象是一个常量
以下写法错误
p.name = "2b"
不能修改结构体常量对象的值
以下写法错误：
p = Person(name:"2b", age : 23)
class Person3 {
var name: String = "twoB"
var age: Int = 30
}
let p3: Person3 = Person3()
// 可以修改类常量中的值，因为他指向的对象不是一个常量
p.name = "2bb"
// 不可以修稿常量的指向
// 以下写法是错误的：
p3 = Person2()
** 延迟存储属性**
Swift 语言中所有的存储属性必须有初始值
也就是当构造完一个对象后，对象中所有的存储属性必须有初始值
但是也有例外
其中，延迟存储属性可以将属性的初始化推迟到该属性第一次被调用的时候
懒加载应用场景：
1、有可能不会用到
2、依赖于其他值
class Line {
var start: Double = 0.0
var end: Double = 0.0
如果不是lazy属性，定义的时候对象还没有初始化，所以不能访问self
如果加上lazy，代表使用时才会加载，也就是使用到length属性时，才会调用self
而访问一个类的属性必须通过对象方法
所以访问时对象已经初始化完成了，可以使用self
lazy var length: Double = self.getLength()
// 通过闭包懒加载
lazy var container: Array<AnyObject> = {
print("懒加载")
var arrM = []
return arrM as [AnyObject]
}()
func getLength() ->Double
{
print("懒加载")
return end - start
}
}
var line = Line()
line.end = 150.0
print("创建对象完毕")
print(line.length)
var arrM = line.container
arrM.append("1")
arrM.append(5)
print(arrM)
计算属性
1、Swift中的计算属性不直接存储值
跟存储属性不同，没有任何的"后端存储与之对应"
2、计算属性用于计算，可以实现setter和getter这两种计算方法
3、枚举不可以有存储属性，但允许有计算属性
setter 对象.属性 = 值
getter var value = 对象.属性
struct Rect {
var origion: (x: Double, y: Double) = (0, 0)
var size: (w: Double, h: Double) = (0, 0)
// 由于center的值是通过起点和宽高计算出来的，所以没必要提供存储属性
var center: (x:Double, y: Double) {
get {
return (origion.x + size.w / 2, origion.y + size.h / 2)
}
set {
/*
注意：计算属性不具备存储功能，所以不能给计算属性赋值
如果赋值会发生运行时错误
注意：setter可以自己传递一个参数，也可以使用系统默认的女阿叔newValue
如果要使用系统自带的参数，必须删除自定义参数
*/
origion.x = newValue.x - size.w / 2
origion.y = newValue.y - size.h / 2
}
}
}
var r = Rect()
r.origion = (0, 0)
r.size = (100, 100)
print("center.x = \(r.center.x) center.y = \(r.center.y)")
r.center = (100, 100)
print("origion.x = \(r.origion.x) origion.y = \(r.origion.y)")
print("center.x = \(r.center.x) center.y = \(r.center.y)")
只读计算属性
/*
对应OC中的readonly属性
所谓只读属性就是只提供了getter方法，没有提供setter方法
*/
class Line2 {
var start: Double = 0.0
var end: Double = 0.0
/*
只读属性，只读属性必须是变量var 不能是常量let
例如想获取长度
只能通过计算获得，而不需要外界设置，可以设置为只读计算属性
*/
var length: Double{
//只读属性的简写，可以省略get{}
return end - start
}
}
var line2 = Line2()
line2.end = 100
print(line2.length)
** 属性观察器**
类似于OC中的KVO
可以用于监听属性什么时候被修改，只有属性被修改才会调用
有两种属性观察器：
1、willSet，在设置新值之前调用
2、didSet，在设置新值之后调用
可以直接为除计算属性和lazy属性之外的存储属性添加属性添加属性观察器
但是可以在继承类中为父类的计算属性提供属性观察器
因为在计算属性中也可以监听到属性的改变
所以计算属性添加书信观察器没有任何的意义
class Line3 {
var start: Double = 0.0 {
willSet{
print("willSet newValue = \(newValue)")
}
didSet {
print("didSet old = \(oldValue)")
}
}
var end: Double = 0.0
}
var l = Line3()
l.start = 10.0
类属性
// 在结构体和枚举中用static
// 在类中使用class，并且类中不允许将存储属性设置为类属性
struct Person4 {
// 普通的属性是每个对象一份
var name: String = "gaojun"
// 类属性是素有对象公用一份
static var gender: String = "man"
static var age: Int{
return 30
}
func show()
{
print("gender = \(Person4.gender) name = \(name)")
}
}
var p4 = Person4()
print("gender = \(Person4.gender)")
var p5 = Person4()
print("gender = \(Person4.gender)")
p4.show()
print("age = \(Person4.age)")
class Person6 {
var name: String = "sb"
// 类中不允许将存储属性定义为类属性： class var gender: String = "sb"
// 类中只能将计算属性定义为类属性
class var age: Int {
return 30
}
func show1(){
print("age = \(Person6.age)")
}
}
var p6 = Person6()
print("age = \(Person6.age)")
p6.show1()
3. 方法:
方法
隶属于每一个类或结构体的函数称之为方法：
方法分为类方法和实例方法，对应OC中的+ - 方法
实例方法：实例方法一定是通过对象来调用的，，实例方法隶属于某一个类
class Person {
var _name: String = "gaojun"
var _age: Int = 30
// 实例方法一定是通过对象来调用的，实例方法隶属于某一个类
// 如果不希望某个参数作为外部参数，可以在参数前面加上_ ,忽略外部参数
func setName(name: String, age: Int)
{
_name = name
_age = age
}
func show()
{
print("name = \(_name) age = \(_age)")
}
}
var p = Person()
//由于第一个参数可以通过方法名称指定，多以默认第一个参不作为外部参数
p.setName("shuai", age: 19)
// 可以在参数前面加上_ , 忽略外部参数
p.setName("shuai", age: 19)
p.show()
self关键字
Swift中的self和OC中的是self基本一样，self指当前对象
如果self在对象方法中代表当前对象，但是在类方法中没有self
class Person2 {
var name: String = "2b"
var age: Int = 30
/*
当参数名称和属性名称一模一样时，
无法区分那个是参数、那个是属性
这个时候可以通过self明确的来区分参数和属性
*/
func setName (name: String, age: Int)
{
/*
默认情况下，_name和_age前面有一个默认的self关键字，
因为所有变量都需要先定义再使用
而setName方法中并没有定义过_name和_age，
而是在属性中定义的，所以setName中访问的其实是属性，
编译器默认帮我们在前面加了一个self
*/
self.name = name
self.age = age
}
func show()
{
print("name = \(name) age = \(age)")
}
}
var p2 = Person2()
p2.setName("2bb", age: 18)
p2.show()
mutating方法
值类型（结构体和枚举）默认的方法是不可以修改属性的
如果需要修改属性
需要在方法前加上mutating关键字，让该方法变成一个改变方法
struct Person3 {
var name: String = "nicai"
var age: Int = 30
// 注意： 类不需要，因为类的实例方法默认就是可以修改
mutating func setName(name: String, age: Int)
{
self.name = name
self.age = age
}
func show()
{
print("name = \(name) age = \(age)")
}
}
var p3 = Person3()
p3.setName("wohehe", age: 99)
p3.show()
enum LightSwitch{
case OFF, ON
mutating func next()
{
switch self{
case OFF:
self = ON
case ON:
self = OFF
}
}
}
var ls: LightSwitch = LightSwitch.OFF
if ls == LightSwitch.OFF
{
print("off")
}
ls.next()
if ls == LightSwitch.ON
{
print("on")
}
类方法
和类属性一样通过类名来调用
类方法通过static关键字（结构体/枚举）， class（类）
类方法中不存在self
struct Person4 {
var name: String = "gaojun"
static var card: String = "1234567890"
func show()
{
print("name = \(self.name) card = \ (Person4.card)")
}
static func staticShow()
{
// 类方法那个没有self
// 静态方法对应OC中的 + 号方法， 和OC一样在类方法中不能访问非静态属性
print("card = \(Person4.card)")
}
}
var p4 = Person4()
p4.show()
Person4.staticShow()
class Person5 {
var name: String = "gaojun"
class var card: String{
return "1234567890"
}
func show()
{
print("name = \(self.name) card = \(Person4.card)")
}
class func staticShow()
{
// 类方法那个没有self
// 静态方法对应OC中的 + 号方法， 和OC一样在类方法中不能访问非静态属性
print("card = \(Person4.card)")
}
}
var p5 = Person5()
p5.show()
Person5.staticShow()
4. 下标
subscripts(下标)
访问对象中数据的快捷方式
所谓下标脚本语法就是能够通过，实例[索引值]来访问实例中的数据
类似于以前我们访问数字和字典，其实Swift中的数组和字典就是一个结构体
struct Student {
var name: String = "gaojun"
var math: Double = 99.0
var chinese: Double = 99.0
var english: Double = 99.0
func score (course: String) ->Double?
{
switch course{
case "math":
return math
case "chinese":
return chinese
case "english":
return english
default:
return nil
}
}
/*
要想实现下标访问，必须实现subscript方法
如果想要通过下标访问，必须实现get放啊发
如果想要通过下标赋值，必须实现set方法
*/
subscript (course: String) ->Double?{
get{
switch course{
case "math":
return math
case "chinese":
return chinese
case "english":
return english
default:
return nil
}
}
set{
switch course{
case "math":
// 因为返回的是可选类型
math = newValue!
case "chinese":
chinese = newValue!
case "english":
english = newValue!
default:
print("not found")
}
}
}
}
var stu = Student(name: "nicai", math: 99.0, chinese: 88.0, english: 10.0)
print(stu.score("math"))
stu["chinese"] = 100.0
print(stu["chinese"])
作者说:
这次给大家推荐一本书: <Swift开发指南> 关东升\赵志荣著
这本书, 对Swift写的还是非常详细的, 希望对正在学Swift的人, 有所帮助
