Swift语言(二)

?和!的区别

?是可选类型.其实是枚举类型,里边有None和Some两种类型,其实nil值相当于OPtional.None,如果有值相当于OPtional.Some

!强制解包

//如果对没有值得变量进行强制解包的情况下会造成崩溃

Var number : Int? = 6

var number = number!

print(number1)

//可选绑定.不用强制解包

if var number2 = number{
    print(number2)   

}

//! 隐士解析可选类型,有值,没值(nil)

//如果!强制解析没值的变量也会造成崩溃

var intNumber : Int! = 10

var intNumber1 = intNumber

     print|(intNumber1)

//可选绑定

if var intNumber2 - intNumber{

       print(intNumber2)

}

//MARK - 结构体
//声明结构体
struct Rect{
    //生名结构体变量的属性(存储属性)
    var x:Float
    var y:Float
    var 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{
        get{
            return y/2
        }
    }
    //声明方法:结构体变量方法(相当于oc里的实例方法)
    func frameInfor(){
        print("x:(x),y:(y),(width),height:(height)")
    }
    //声明一个结构体方法(相当于OC中的类方法)使用stati修饰
    static func infor(){
        print("结构体方法")
    }
    
}

//1.根据结构体去定义一个结构体变量
var frame = Rect(x: 11.1, y: 12.1, 100, height: 100)
//2.访问结构体变量中的属性
//注意在;结构体变量的属性可以使用let去修饰，只不过访问的时候不能frame.x = 20
print(frame.x)

//3.访问结构体属性
Rect.description = "哈哈哈哈"
print(Rect.description)

//4.访问计算属性
frame.centerX = 200 //这句话就相当于在调用centerx的setter方法
let value = frame.centerX //这句话相当于调用centerX的getter方法
print(value)

//5,调用结构体变量方法
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
    }
    //声明类属性
    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: "MBBboy", age: 20)

//访问类中的属性(对象属性)
print(person1.name!)

//3.访问类属性
Person.introduce = "啊啊啊啊"

//4.访问计算属性
person1.value = 23
print(person1.value)

//5.访问类方法
Person.sayHi()
Person.sayHi1()

//6.访问实例方法
person1.sayHi2()

//定义一个子类,继承Person
//在swift中不支持多继承
class Student:Person{
    //重写父类的方法
    //重写父类中的类方法
    override class func sayHi1(){
        print("子类,重写了父类的类方法")
    }
    //重写父类中的实例方法
    override func sayHi2() {
        print("我是子类,重写了父类中的对象放法")
    }
}

//初始化Student对象
var student = Student(name: "噶的我", age: 31)
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: 23)
var dog1 = dog
print("dog1.name:(dog1.name!)")
dog.name = "欢欢"
print("dog.name:(dog.name!),dog1.name:(dog1.name!)")




//MARK - 协议(protocol)

//当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: "韦小宝", age: 22)
man.cook()
man.wash()
man.divideMoney()


//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
}

let max = myBlock(num1: 23, num2: 45)
print(max)