Swift -5 面向对象基础(中)
存储属性与计算属性
1.实例存储属性与实例变量
2.结构体常量与实例属性
3.定义计算属性
4.setter方法
5.属性观察者
存储属性:存储在类.结构体里的变量或者常量
分为:实例存储属性.类型存储属性
所有的存储属性必须显示的指定初始值,在定义时或者构造器当中指定
可选类型的存储属性可以不指定初始值
结构体中实例存储属性的规则
1.程序为所有的实例存储属性指定了初始值,且没有构造器,则系统会提供两个构造器:一个无参数的构造器和一个初始化所有实例存储属性的构造器
2.没有初始值和构造器,系统会提供一个初始化所有实例存储属性的构造器
3.有构造器,则程序必须为结构体中的所有存储属性提供初始值
存储属性
struct LengthRange{
var start: Int
// 定义常量存储属性,可以不指定初始值
let length: Int
}
var len = LengthRange(start: 9, length: 3)
// 通过构造器参数完成实例存储属性的初始化
print("len的起点为\(len.start), 长度为\(len.length)")
// 结构体常量与实例属性
struct LengthRange2{
var start: Int
var length: Int
}
let len2 = LengthRange2(start: 1, length: 5)
// 延迟存储属性:第一次被调用时候才会被计算初始值的属性,用lazy修饰符计算属性
/*
[修饰符]var 计算属性名: 属性类型{
get{
// get方法执行体,该方法一定要有返回值
}
set(形参名){
// setter方法执行体,该方法一定不能有返回值
}
}
*/
class User {
var first: String = ""
var last: String = ""
// 定义计算属性
var fullName: String {
// 定义计算属性的getter方法,该方法的返回值由first.last两个存储属性决定
get{
return first + "-" + last
}
// 定义计算属性的setter方法
// 该setter方法将负责改变该实例的first.last两个存储属性
set(newValue){
var names = newValue.componentsSeparatedByString("-")
self.first = names[0]
self.last = names[1]
}
}
init(first: String, last: String) {
self.first = first
self.last = last
}
}
let s = User(first: "Devin", last: "hello")
print(s.fullName)
s.fullName = "Devin-Hello"
print(s.first)
print(s.last)
// 只读属性,则无需set部分,可以省略get和花括号属性观察者
1.除了延迟存储属性之外的所有存储属性(包括实例存储属性和类型存储属性)
2.可通过重载方式为继承得到的属性(包括存储属性和计算属性)添加属性观察者
/*
[修饰符]var 计算属性名: 属性类型 = 初始值{
willSet(newValue){
// 属性即将被赋值之前自动调用的方法
}
didSet(oldValue){
// 属性被赋值完成之后自动调用的方法
}
}
注意:willSet和didSet后的参数都可以省略
*/
/*
willSet(newValue): 被观察的属性即将被赋值之前自动调用的方法
didSet(oldValue): 被观察的属性被赋值完成之后自动调用的方法
*/
class Person {
// 定义存储属性
var name: String = "" {
willSet{
//
if (newValue.characters.count > 6 || newValue.characters.count < 2)
{
print("您设置的人名\(newValue)不符合要求, 请重新设置")
}else{
print("人名设置符合要求, 设置成功")
}
}
didSet{
print("人名设置完成, 被修改的原名为:\(oldValue)")
}
}
var age: Int = 0 {
willSet{
//
if newValue > 100 || newValue < 0
{
print("您设置的年龄\(newValue)不符合要求, 请重新设置")
}else
{
print("年龄设置符合要求, 设置成功")
}
}
didSet{
print("年龄设置完成,被修改的年龄为:\(oldValue)")
}
}
}
var p = Person()
//p.age = 999 // 不成功设置
// 成功设置age属性后
p.age = 10
print("成功设置age属性后, age为\(p.age)")
方法
方法的所属性
1.定义方法需要在类型(枚举.结构体.类)里定义,不能独立定义
2.方法要么属于该类型本身,要么是该类型的一个实例
3.不能独立执行方法,执行方法必须使用类型或实例作为调用者
注意:枚举.结构体中方法使用static修饰,类中用class修饰,都属于类型方法,否则的话属于实例方法
将方法转换为函数
class SomeClass {
func test() {
print("===test 方法===")
}
class func bar(msg msg: String) {
print("==bar类型方法==, 传入的参数为:\(msg)")
}
}
// 创建实例
var sc = SomeClass()
// 将sc的test方法分离成函数
var f1: () -> () = sc.test
// 将sc的bar方法分离成函数
var f2:(String) -> Void = SomeClass.bar
f1() // 等价于sc.test()
sc.test()
f2("Devin") // 等价于SomeClass.bar(msg:"Devin")
SomeClass.bar(msg: "Devin")
方法的外部形参名
class Person1 {
var name: String
//
init(name: String) {
self.name = name
}
//
func eat(food: String, _ drink: String, _ cigarette: String) {
print("\(self.name)吃着\(food), 喝着\(drink), 抽着\(cigarette)")
}
}
var p1 = Person1(name: "Devin")
p1.eat("烤鸭", "啤酒", "雪茄")
// Swift默认为除第一个参数外都添加了外部参数名,与局部参数名一样,如果不需要的话,则用 _ 下划线的方式去掉
值类型的可变方法
将mutating关键字放在func之前,即将该方法声明为可变方法
struct JKRect {
var x: Int
var y: Int
var width: Int
var height: Int
mutating func moveByX(x: Int, y: Int) {
self.x += x
self.y += y
}
}
// 创建实例
var rect = JKRect(x: 20, y: 12, width: 200, height: 300)
// 调用mutating方法,该方法可以改变rect实例的存储属性
rect.moveByX(100, y: 90)
print("rect矩形的左上角的x坐标为:\(rect.x), y坐标为:\(rect.y)")
// 注意:常量类型的结构体.枚举是不可变的
属性和方法的统一
使用函数类型定义存储属性,并将函数或者闭包作为该属性的初始值,这个属性就成了方法
func factorial(n: Int) -> Int {
var result = 1
for i in 1...n {
result *= i
}
return result
}
struct SomeStruct {
var info: () -> Void = {
print("info方法")
}
// 将全局函数作为fact存储属性的初始值
static var fact: (Int) -> Int = factorial
}
var sc1 = SomeStruct()
// 调用info方法
//sc1.info()
// 使用闭包对sc1对象的info赋值,相当于重新定义sc1的info方法
sc1.info = {
print("另外一个闭包")
}
//sc1.info()
var n = 6
// 调用fact方法,执行的是阶乘
print("\(n)的阶乘是:\(SomeStruct.fact(6))")
// 使用闭包对SomeStruct的fact赋值,相当于重新定义SomeStruct的方法
SomeStruct.fact = {
var result = 1
for i in 1...$0 {
result += i
}
return result
}
// 再次调用fact方法,执行的是累加
print("\(n)的累加的和是:\(SomeStruct.fact(6))")
下标
1.下标的基本用法
2.下标重载
1.所有的Swift类型(枚举.类和结构体)都支持下标定义
2.同一个类型可以定义多个下标
3.通过下标的形参列表或者返回值类型来区分不同的下标
4.同一类型中定义多个不同的下标被称为下标重载
/*
Subscript(形参列表) -> 下标返回值类型 {
get {
// getter方法执行体,该方法必须有返回值
}
set(形参名) {
// setter方法执行体,该方法不能有返回值
}
}
*/
// 1.形参列表:与函数的形参列表的用法基本相同,但是不支持指定外部参数和默认值
// 2.下标的返回值类型:可以是任何有效的类型
struct JKRect2 {
var x: Int
var y: Int
var width: Int
var height: Int
// 定义下标,指定下标只接受一个Int类型的参数,下标的返回类型为Int
subscript(index: Int) -> Int {
// get部分
get{
switch(index) {
case 0:
return self.x
case 1:
return self.y
case 2:
return self.width
case 3:
return self.height
default:
print("不支持该索引值")
return 0
}
}
// 定义set部分
set{
switch(index) {
case 0:
self.x = newValue
case 1:
self.y = newValue
case 2:
self.width = newValue
case 3:
self.height = newValue
default:
print("不支持该索引值")
}
}
}
}
// 创建实例
var rect2 = JKRect2(x: 20, y: 12, width: 200, height: 300)
// 通过下标进行赋值
rect2[0] = 40
rect2[1] = 67
// 通过下标访问rect的属性
print("rect2矩形的左上角的x坐标为:\(rect2.x), y坐标为:\(rect2.y)")