import Foundation // MARK: - ?和！的区别
// ?代表可选类型，实质上是枚举类型，里面有None和Some两种类型，其实nil相当于OPtional.None，如果非nil相当于OPtional.Some
// !强制解包
//var number : Int? // 此时解包会崩溃
var number : Int? = // 此时解包不会崩溃 // 如果对没值（nil）的变量进行强制解包的情况下会造成崩溃
var number1 = number!
print(number1) // 可选绑定，不用强制解包
if var number2 = number {
print(number2)
} // !隐式解析可选类型：有值，没值（nil）
// 如果！强行解析没值的变量，也会造成崩溃
//var intNumber : Int! // 此时解包会崩溃
var intNumber : Int! = // 此时解包不会崩溃
var intNumber1 = intNumber
print(intNumber1) // 可选绑定
if var intNumber2 = intNumber {
print(intNumber2)
} // MARK: - 结构体
// 1.声明一个结构体
struct Rect {
// 声明结构体变量的属性(存储属性)
var x : Float
var y : Float
var width : Float
var height : Float // 声明结构体属性， 要使用static
static var description : String? // 声明一个计算属性（是用来专门计算结构体变量属性的setter和getter方法的，本身并没有存储功能）
var centerX : Float {
// set方法
set {
x = newValue
}
// get方法（必须要写）
get {
return x /
}
} var centerY : Float {
// 可以不写set方法，只写get方法
get {
return y /
}
} // 声明方法
// 声明一个结构体变量方法(相当于OC中的实例方法)
func frameInfor() {
print("x : \(x), y : \(y), width : \(width), height : \(height)")
} // 声明一个结构体方法(相当于OC中的类方法)，使用static修饰
static func inFor() {
print("这是结构体方法")
}
} // 2.根据结构体去定义一个结构体变量
var frame = Rect(x: , y: , width: , height: ) // 3.访问结构体变量中的属性
// 注意：结构体变量的属性类型可以使用let去修饰，只不过访问的时候不能进行修改
frame.x =
print(frame.x) // 4.访问结构体属性
Rect.description = "我是结构体属性"
print(Rect.description) // 5.访问计算属性
frame.centerX = // 这句话相当于在调用centerX的set方法
let value = frame.centerX // 这句话就相当于在调用centerX的get方法
print(value) // 6.调用结构体变量方法
frame.frameInfor() // 7.调用结构体方法
Rect.inFor() // MARK: - 类（class）
class Person {
var name : String?
var age : Int? // 构造初始化方法
init (name : String, age : Int) {
self.name = name
self.age = age
} // 自定义初始化方式（可以只初始化一部分属性）
init (name : String) {
self.name = name
} // 声明类属性
static var introduce : String? // 计算属性
var value : Int {
set(a) {
age = a // 在写计算属性的时候，一定不能出现self.,否则会造成死循环
}
get {
return age!
}
} // 声明一个类方法
// 1.在类方法前边加上static修饰【虽然是一个类方法，但是该方法在子类中不能进行重写】
static func sayHi() {
print(introduce) // 注意：在类方法中只能使用类属性，不能使用对象属性
}
// 2.在类方法前边加上class修饰【它是一个类方法，可以被子类重写】
class func sayHi1() {
print(introduce)
} // 声明一个实例（对象）方法
func sayHi2() {
print("hello, 我是实例方法")
}
} // 1.创建对象(此时应该和OC区分开来，实例对象，：后边跟的是类，要初始化对象一定要写初始化构造的方法)
var person1 : Person = Person(name : "卫庄", age : ) // 2.访问类中的属性(对象属性)
print(person1.name!) // 3.访问类属性
Person.introduce = "我是盖聂"
print(Person.introduce) // 4.访问计算属性
person1.value =
print(person1.value) // 5.访问类方法
Person.sayHi()
Person.sayHi1() // 6.访问实例方法
person1.sayHi2() // MARK: - 定义一个子类Student，继承Person
// 在swift中不支持多继承
class Student : Person {
// 重写父类的方法
// 重写父类中的类方法（class修饰的可以重写，static修饰的不可以重写）
override class func sayHi1() {
print("我是子类Student类，重写了父类的类方法")
} // 重写父类中的实例方法
override func sayHi2() {
print("我是子类Student类，重写了父类的对象方法")
}
} // 初始化student对象
var student : Student = Student(name: "天明", age: ) // 调用类方法
Student.sayHi1() // 调用使用方法
student.sayHi2() // MARK: - 值类型和引用值类型的区别
/*
// 值类型
struct animal {
var name : String?
var age : Int? init(name : String, age : Int) {
self.name = name
self.age = age
}
}
var dog = animal(name: "贝贝", age: 3)
var dog1 = dog // 此时将dog的数据拷贝给dog1
dog.name = "欢欢"
print("dog.name : \(dog.name!), dog1.name : \(dog1.name!)")
*/ // 引用值类型
class animal {
var name : String?
var age : Int? init(name : String, age : Int) {
self.name = name
self.age = age
}
}
var dog = animal(name: "贝贝", age: )
var dog1 = dog
dog.name = "欢欢"
print("dog.name : \(dog.name!), dog1.name : \(dog1.name!)") // MARK: - 协议（protocol）
// 当swift中声明协议的时候，协议里有可选方法需要使用@objc关键字修饰
@objc protocol MarrayDelegate {
func cook() // 做饭
func wash() // 洗衣服
optional func hitDoudou() // 打豆豆
} protocol DivorceDelegate {
func diviseMoney() // 分割财产
} // 如果一个类要遵循协议的时候，如果这个类有父类要在：后先写父类，然后用,隔开，后面跟着协议
class Man: Person, MarrayDelegate, DivorceDelegate {
@objc func cook() {
print("我要做饭了")
} @objc func wash() {
print("我要洗衣服了")
} func diviseMoney() {
print("分财产")
}
} // 创建一个男人
let man = Man(name: "韦小宝", age: )
man.cook()
man.wash()
man.diviseMoney() // MARK: - 扩展(Extension)
// 1.扩展协议中的相关方法
extension Man {
@objc func hitDoudou() {
print("嘿嘿嘿")
}
}
man.hitDoudou() // 2.扩展还可以扩展类方法（类似于OC中的Category）以及对象方法
extension Man {
// 扩展一个对象方法
func sing() {
print("唱一首歌")
} // 扩展一个类方法
class func sleep() {
print("多喝水")
}
} man.sing()
Man.sleep() // MARK: - 闭包
// 求两个数的最大值
/*
在OC中使用Block实现
int (^myBlock)(int num1, int num2) = ^int (int num1, int num2) {
return num1 > num2 ? num1 : num2
}
*/ // 使用闭包
var myBlock : ((num1 : Int, num2 : Int) ->Int) // 第一种使用方式
myBlock = {
(num1 : Int, num2 : Int) ->Int in // 切记不能忘记in
return num1 > num2 ? num1 : num2
} // 第二种方式
myBlock = {
num1, num2 in
return num1 > num2 ? num1 : num2
} // 第三种方式
myBlock = {
num1, num2 in
num1 > num2 ? num1 : num2
} // 第四种方式
myBlock = {
$ > $ ? $ : $
} // 第五种方式
myBlock = {
(num1, num2) ->Int in
return num1 > num2 ? num1 : num2
} var max = myBlock(num1: , num2: )
print(max)