标签:
1.?和!的区别
在swift中,可选类型(?)其实质是一个枚举类型,里面有None和Some两种类型,其实nil的值相当于optional.None,没有值就相当于optional.None,如果有值就相当于optional.Some
//MARK: - !和?区别
1.解包
?:有值,没值(nil)
!:强制解包
eg: var number : Int? = 8
var number1 = number
print(number1)
注意:如果对没有值的变量进行强制解包的情况下回造成崩溃
2.可选绑定,不用强制解包
if var number2 = number {
print(number2)
}
//隐式解析可选类型:有值,没值
var intNumber :Int != 10
var intNumber1 = intNumber
print(intNumber1)
注意:如果!强制解析没值的变量,也会造成崩溃
可选绑定:
if var intNumber2 = number {
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
}
}
//声明方法
//声明一个结构体变量的方法(相当于oc中的实例方法)
func frameInfor () {
print ("x:\(x),y:\(y),width:\(width),height:\(height)")
}
//声明一个结构体方法(相当于oc中的类方法,使用static方法修饰)
static func infor() {
print("这是结构体方法")
}
}
//1.根据结构体去定义一个结构体变量
var frame = Rect (x:10,y:10,width:100,height:100)
//2.访问结构体变量中的属性
//注意:结构体变量的属性类型可以使用let去修饰,只不过访问的时候不能对其进行修改
print(frame.x)
frame.x = 20
print(frame.x)
//3.访问结构体属性
Rect.description = "我是结构体属性"
print(Rect.description)
//4.访问计算属性
frame.centerX = 200
//这句话就相当于在调用centerX的setter方法
let value = frame.centerX //这句话相当于在调用center中的set方法
print(value) //这句话就相当于调用center中的get方法
frame.frameInfor() //调用结构体变量的方法
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
self.age = age
}
//自定义初始化方法
init(name : String) {
self.name = name
}
//声明类属性
static var introduce : String?
//计算属性
var lalue : 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,我是实例方法")
}
}
//创建对象[此时应该注意和oc区别开,实例对象,:后边跟的是类(注意:要初始化对象一定要写初始化构造的方法)]
var person1 : Person = Person(name : "MBBoy",age : 69)
//访问类中的属性
print(person.name!)
//属性后+?和不加+的区别就是输出的时候,是否用解包,带?的不用optional里的东西,就要用!解包,而不加问号的直接输出就可以
//3.访问类属性
Person.introduce = "我是xxxx"
//4.访问计算属性
person1.value = 28
print(person1.value)
//5.访问类方法
Person.sayHi()
Person.sayHi1()
//6.访问实例方法
person1.sayHi2()
//声明一个子类方法
class Student : Person {
//重写父类的方法
//重写类方法
override class func sayHi() {
print("我同桌是肉丝")
}
//重写父类中的实例方法
override func sayHi2() {
print("我同桌是肉丝的子类,重写了父类中的对象方法")
}
}
var student = Student (name : "rose",age : 38)
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)")
//结果:dog.name = "欢欢",dog1.name = "贝贝"
//引用值类型(可以用dog改变dog1)
class animal {
var name : String?
var age : Int?
init (name : String,age : Int) {
self.name = name
self.age = age
}
}
var dog = animal (name : "flower",age : 0)
var dog1 = dog
print ("dog.name :\(dog.name) , dog1.name : \(dog1.name)")
//MARK: - 协议
//当swift中声明协议的时候,协议里有可选方法需要使用@objc关键字修饰
@objc protocol MarryDelegate {
func cook() //吃饭
func wash() //洗衣服
optional func hitDouDou() //打豆豆
}
protocol DivorceDelegate {
func divideMoney() //分割财产
}
//如果一个类要遵循协议的时候,如果这个类有父类,要在:后先写父类,然后要遵循的协议
class Man : Person,MarryDelegate,DivorceDelegate {
@objc func cook() {
print("还好去新东方学了几年厨师,终于可以大展身手了")
}
@objc func wash() {
print("还好有全自动洗衣机")
}
func divideMoney() {
print("分财产")
}
}
//创建一个男人
let man = Man(name :"fu",age :10)
man.cook()
man.wash()
man.divideMoney()
//MARK: - 扩展(extension)
//扩展协议中的相关方法(打豆豆)
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: - 闭包
//求两个数的最大值
//使用闭包
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
}
let max = myBlock(num1 : 88,num2 : 66)
标签:
原文地址:http://www.cnblogs.com/zhoulina/p/5521054.html