(一) 结构体
- 关键字 - - - - frame
1.属性分类:在Swift语言中结构体分为两种属性,第一种为储存属性,粗存属性仅仅是用来做存储值得作用;第二种为计算属性,计算属性通过计算来获取自己的值.
2.属性的作用:
(1)声明了setter和getter方法;
(2)实现了setter和getter方法;
(3)声明了一个和此属性同名并带下划线的成员变量;
<示例代码如下>
struct Frame {
//在Swift中,X,Y,长和宽都为存储属性
var x : Float
var y : Float
var width :Float
var height : Float
//变量属性(重写getter方法和setter方法都直接写在变量属性之中)
var centerX : Float {
get{
return x + width / 2
}
set{
self.centerX = newValue //newValue表示新值
} }
var centerY : Float {
get{
return y + height / 2
}
set{
self.centerY = newValue //newValue便是新值
}
}
- 注意 : 在Swift语法中,setter方法是不允许单独存在的,如果想要重写setter方法,必须要有一个同属性额getter方法存在之后才可以重写setter 方法
3.结构体初始化方法(init方法)
外部参数名:(例如X,Y,Width,Height)
内部参数名:(例如newX等)
<示例代码如下>
//在Swift的结构体里面,可以创建一个init方法
init(x newX : Float, y newY : Float, width newWidth : Float, height newHeight : Float) {
self.x = newX
self.y = newY
self.width = newWidth
self.height = newHeight
}
4.修改函数属性的值
<示例代码如下>
//在Swift结构体函数里面修改属性的值 要在函数前面添加mutating关键字修饰
mutating func daniuniu() {
self.x = 100
}
- mutating关键字的作用: Swift的结构体可以任意的创建函数,但如果需要在函数里面修改属性的值得话需要在函数前面添加mutating关键字修饰
5.属性:
(1)结构体属性是不能在普通的函数里面去调用的;
(2)结构体函数里面可以调用结构体属性
(3)结构体函数里面可以调用一些本结构体内存在的函数
<示例代码如下>
//结构体属性是不能再普通的函数里面去调用的
static var name : String? = nil
//结构体函数
static func sayName() {
self.name = "我是一个frame"
print(self.name)
}
}
6.结构体函数调用方法
let fram :Frame = Frame.init(x: 10, y: 10, width: 10, height: 10)
print(fram.centerY, fram.centerX)
let fram1 : Frame = Frame(x: 100, y: 100, width: 100, height: 100)
print(fram1.centerX, fram1.centerY)
//调用接头体函数,必须得通过这个二结构体去调用
Frame.sayName()
(二) 类
- 类的格式 : class 关键字 + 类名 {类的实现}
1.属性 : 在类里面创建一个属性的时候,必须要有初值,如果不想设置初始值,那么就设置成为可选类型(nil)
(1)私有属性: 用private这个关键字来表示
(2)类属性:用static这个关键字来表示 - 注意:
1>实例方法里面不能直接调用类属性;但是可以直接对实例对象进行修改赋值
2>在函数证明之前添加private表示私有方法
<实例代码如下>
class Person {
//再类里面创建一个属性的时候,必须有初值,如果不想设置初值,那么就设置成为可选类型
var name : String? = nil
var age : Int? = nil
//private 表示的是私有属性
private var gender : String? = nil
//static 修饰的属性表示类属性
static var country : String? = nil
init(name newName : String, age newAge: Int) {
self.name = newName
self.age = newAge
}
//实例方法里面不能直接调用类属性
//实例方法可以直接对实例对象进行修改赋值
//在函数声明之前添加一个private 表示私有方法
func sayHi() {
self.gender = "男"
}
//static 修饰的是类方法
//static 修饰的方法是不可以被子类重写的
static func sayHello() {
self.country = "中国"
print(self.country)
}
//class 修饰的也是类方法
//class 修饰的方法可以被子类重写
class func sayNihao() {
self.country = "China"
print(self.country)
}
}
2.class与static修饰类方法的区别: static修饰类方法不可以被子类重写,但是class修饰的类方法可以被子类重写
< 结构体与类的区别 >
1.属性:结构体里面创建属性不需要给类型和初值,类里面要给初始值或者可选类型
2.类方法重写:结构体里用
3.类用class修饰,结构体用struct
(三) 协议
- 格式 : protocol 关键字 + 协议名字
protocol myDelegate {
//没有返回值的写法
//学一方法前面添加mutating修饰的关键字之后,可以修改结构体里面的参数,在类里面会自动的忽略mutating
mutating func daniuniu()
//有返回值的写法
func daniuniu() -> String
}
//如果一个类既有父类 也遵守了摸个协议,那么它的格式是: class + 类名:父类,协议名字
class Teacher: Person {...}
//如果有需要可选实现的协议,在最前面添加@objc修饰,内部的方法用optional修饰可选实现的方法,其他的不变
// @objc 是OC的协议
@objc protocol newDelegate{
optional func lalala()
}
class newClass: myDelegate,newDelegate {
func daniuniu() { ... }
}
//结构体可以遵守协议,但是结构体只能遵守Swift的协议,不能遵守OC的协议
struct newStudent : myDelegate {
var name : String
mutating func daniuniu() {
self.name = "niuniu"
}
}
//extension可以给一个类拓展新的协议
extension Person :myDelegate {
func daniuniu() { ... }
//extension不可以添加新的属性
// var height : Float? = nil
//可以给一个类添加新的函数
func fuwei() { ... }
}
//extension 可以给一个结构体拓展新的协议
extension Frame : myDelegate { ... }
//枚举
enum time {
case spring
case summer
case autumn
case winter
}
//使用枚举的时候,初次给变量赋值,必须使用枚举名.case名
var timer = time.autumn
//第二次使用的时候 可以直接通过.case名使用
timer = .spring
//switch 搭配枚举使用
//switch 的value要填写一个枚举类型的实例变量
//case .枚举的case名字
switch timer {
case .spring:
print("春天")
case .summer:
print("夏天")
case .autumn:
print("秋天")
case .winter:
print("冬天")
}
(四) 闭包
- 表达式 : 闭包名字: ((参数) -> 返回值类型)
var newPassValue : ((a : Int, b : Int) -> Int) - 闭包表达式的三种写法
//第一种闭包表达式的写法
newPassValue = { (a : Int, b : Int) -> Int in
return a > b ? a : b
}
//第二种写法 苹果推荐的写法
newPassValue = { (a , b) -> Int in
return a > b ? a : b
}
//第三种写法
newPassValue = {
$0 > $1 ? $0 : $1
}
newPassValue = { (a, b) in
return a > b ? a : b
}
newPassValue = {(a , b) in
a > b ? a : b
}
