Swift中的结构体,类,协议,扩展和闭包的用法以及? 和 !的区别

// MARK: - 1.结构体

//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 {
        get {
            return y / 2
        }
    }
    // 声明方法
    // 声明一个结构体变量方法 (相当于OC中的实例方法)
    func frameIntfor() {
        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去修饰,但是访问的时候不能修改
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.frameIntfor()
// 6.调用结构体方法
Rect.infor()

// MARK: - 2.类 (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 sayHello() {
        print(introduce)
    }
    // 声明一个实例(对象)方法
    func sayHi2() {
        print("hell,我是实例方法")
    }
}

// 1.创建对象 [此时应该注意和OC区分开,实例对象名,: 后边跟的是类] (注意: 要初始化对象一定要写初始化构造的方法)
var person1:Person = Person(name:"MBBoy", age:20)

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

// 3.访问类中的属性(对象属性)
Person.introduce = "我是XXX"
print(Person.introduce!)

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

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

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

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

// 初始化Student对象
var student = Student(name: "张三", age: 25)

Student.sayHello()
student.sayHi2()

// MARK: - 3.值类型和引用值类型的区别

// 值类型
/*
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: - 4.协议(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: - 5.扩展 (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: - 6.闭包

// 求两个数的最大值
/*
在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: 88, num2: 66)
print(max)

// MARK: - 7.?和! 的区别
// ? 代表可选类型,其实质是一个枚举类型,里边有None和Some两种类型,其实nil值相当于Optional.None,如果有值相当于Optional.Some
// ? 有值, 没值 (nil)

// ! 强制解包

var number : Int? = 8

// 如果对没值 (nil)的变量进行强制解包的情况下会造成崩溃
var number1 = 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)
}

时间： 2024-10-27 09:01:47

Swift中的结构体,类,协议,扩展和闭包的用法以及? 和 !的区别的相关文章

5.Swift枚举|结构体|类|属性|方法|下标脚本|继承

1. 枚举: ->在Swift中依然适用整数来标示枚举值,需搭配case关键字 enum  Celebrity{  case DongXie,XiDu,Nandi,BeiGai }  // 从左到右对应0,1,2,3 enum CompassPoint { case North case South case East case West //enum中可以定义方法 func show(){ print(self) } } //定义enum 变量 var p = CompassPoint.Nor

[转]C#中的结构体与类的区别

C#中的结构体与类的区别 经常听到有朋友在讨论C#中的结构与类有什么区别.正好这几日闲来无事,自己总结一下,希望大家指点. 1. 首先是语法定义上的区别啦,这个就不用多说了.定义类使用关键字class 定义结构使用关键字struct.在语法上其实类和结构有着很多相似的地方. 定义类的语法 1 class Person 2 { 3 private string name; 4 private int age; 5 6 public void SayHi() 7 { 8 Console.WriteL

浅析C#中的结构体和类

类和结构是 .NET Framework 中的常规类型系统的两种基本构造. 两者在本质上都属于数据结构.封装着一组总体作为一个逻辑单位的数据和行为. 数据和行为是该类或结构的"成员",它们包括各自的方法.属性和事件等 对于C/C++程序员来说.结构体和类的差别非常小.仅仅是结构体的默认成员变量为public,类的默认成员变量为private. 可是对于C#来说,结构体和类有非常多的不同. 首先来谈一谈为何须要结构体: 最主要的原因就是结构体有能力去管理.使用不同数据类型的组合. .NE

Swift中类和结构体

1. 类和结构体对比 Swift 中类和结构体有很多共同点: 定义属性用于存储值 定义方法用于提供功能 定义附属脚本用于访问值 定义构造器用于生成初始化值 通过扩展以增加默认实现的功能 符合协议以对某类提供标准功能 与结构体相比,类还有如下的附加功能: 继承允许一个类继承另一个类的特征 类型转换允许在运行时检查和解释一个类实例的类型 解构器允许一个类实例释放任何其所被分配的资源 引用计数允许对一个类的多次引用 2. 类和结构体的定义语法 类和结构体有着类似的定义方式.我们通过关键字class和s

Swift入门篇-结构体

前面主要是介绍swift语言中基本类型的用法,今天给大家介绍的是swift的结构体的用法,swift中结构体的用法和其他语言的用法,还有不太一样,不过您多敲几遍,就可以理解结构体,结构体在ios开发中是灰常重要的一部分,如果您很好的掌握结构体,在后面ios开发中,会理解的更加清楚. 一:结构体声明 格式: struct 结构体名 { } 说明: 1: struct 是定义结构体的关键字 例子 /* 1:struct 是结构体的关键字 2:student 结构体名称 3:student() 创建一

C语言中的结构体和Ｃ＋＋中的结构体以及Ｃ＋＋中类的区别

c++中结构体可以定义一个函数 C中的结构体和C++中结构体的不同之处:在C中的结构体只能自定义数据类型,结构体中不允许有函数,而C++中的结构体可以加入成员函数. C++中的结构体和类的异同: 一.相同之处:结构体中可以包含函数:也可以定义public.private.protected数据成员:定义了结构体之后,可以用结构体名来创建对象.但C中的结构体不允许有函数:也就是说在C++当中,结构体中可以有成员变量,可以有成员函数,可以从别的类继承,也可以被别的类继承,可以有虚函数. 二.不同之处

C++中的结构体

http://zhidao.baidu.com/link?url=8OYQSKV9mvSBc6Hkf9NsLQmipSge9VCZDJQGAZZs5PCBQ54UTmK98VRmAklEEAFYu7dHi9yhLhWeLsP4EwFW5_ c++中结构体可以定义一个函数 C中的结构体和C++中结构体的不同之处:在C中的结构体只能自定义数据类型,结构体中不允许有函数,而C++中的结构体可以加入成员函数. C++中的结构体和类的异同: 一.相同之处:结构体中可以包含函数:也可以定义public.pr

x264中重要结构体参数解释,参数设置,函数说明 <转>

x264中重要结构体参数解释http://www.usr.cc/thread-51995-1-3.htmlx264参数设置http://www.usr.cc/thread-51996-1-3.html x264中重要结构体参数解释typedef struct x264_param_t{/* CPU 标志位 */unsigned int cpu;int         i_threads;       /* 并行编码多帧 */int         b_deterministic; /*是否允许非

C++中的结构体，C管理进程代码，C++管理进程代码，C语言中的联合体

 1.C++中的结构体 #include<iostream> struct lstruct { int num; }; struct MyStruct { int num; double db = 10.8;//可以有默认的值 //MyStruct sx;//拒绝内部定义自己,也就是说不能够内部指向自己 MyStruct *pnext; MyStruct *phead; lstruct  l1; void boss()  //可以有方法 { } }; struct MyStructA {