标签：
import Foundation
// MARK: - ?和！的区别
// ?代表可选类型，实质上是枚举类型，里面有None和Some两种类型，其实nil相当于OPtional.None，如果非nil相当于OPtional.Some
// !强制解包
//var number : Int? // 此时解包会崩溃
var number : Int? = 8 // 此时解包不会崩溃
// 如果对没值（nil）的变量进行强制解包的情况下会造成崩溃
var number1 = number!
print(number1)
// 可选绑定，不用强制解包
if var number2 = number {
print(number2)
}
// !隐式解析可选类型：有值，没值（nil）
// 如果！强行解析没值的变量，也会造成崩溃
//var intNumber : Int! // 此时解包会崩溃
var intNumber : Int! = 6 // 此时解包不会崩溃
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 / 2
}
}
var centerY : Float {
// 可以不写set方法，只写get方法
get {
return y / 2
}
}
// 声明方法
// 声明一个结构体变量方法(相当于OC中的实例方法)
func frameInfor() {
print("x : \(x), y : \(y), width : \(width), height : \(height)")
}
// 声明一个结构体方法(相当于OC中的类方法)，使用static修饰
static func inFor() {
print("这是结构体方法")
}
}
// 2.根据结构体去定义一个结构体变量
var frame = Rect(x: 10, y: 10, width: 100, height: 100)
// 3.访问结构体变量中的属性
// 注意：结构体变量的属性类型可以使用let去修饰，只不过访问的时候不能进行修改
frame.x = 20
print(frame.x)
// 4.访问结构体属性
Rect.description = "我是结构体属性"
print(Rect.description)
// 5.访问计算属性
frame.centerX = 200 // 这句话相当于在调用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 : 20)
// 2.访问类中的属性(对象属性)
print(person1.name!)
// 3.访问类属性
Person.introduce = "我是盖聂"
print(Person.introduce)
// 4.访问计算属性
person1.value = 28
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: 12)
// 调用类方法
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: 3)
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: 22)
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 = {
$0 > $1 ? $0 : $1
}
// 第五种方式
myBlock = {
(num1, num2) ->Int in
return num1 > num2 ? num1 : num2
}
var max = myBlock(num1: 66, num2: 88)
print(max)
标签：
原文地址：http://www.cnblogs.com/dongbaoyue/p/5524132.html
