美文网首页
swift-day07-类和结构体

swift-day07-类和结构体

作者: 临川慕容吹雪 | 来源:发表于2016-07-21 17:55 被阅读36次
    • Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体,系统将会自动生成面向其它代码的外部接口,通常一个类的实例被称为对象。然而在 Swift 中,类和结构体的关系要比在其他语言中更加的密切,本章中所讨论的大部分功能都可以用在类和结构体上。因此,我们会主要使用实例而不是对象。
    • 类和结构体对比
      Swift 中类和结构体有很多共同点。共同处在于:
      1.定义属性用于存储值
      2.定义方法用于提供功能
      3.定义附属脚本用于访问值
      4.定义构造器用于生成初始化值
      5.通过扩展以增加默认实现的功能
      6.实现协议以提供某种标准功能
      7.与结构体相比,类还有如下的附加功能:
      8. 继承允许一个类继承另一个类的特征
      9.类型转换允许在运行时检查和解释一个类实例的类型
      10.析构器允许一个类实例释放任何其所被分配的资源
      引用计数允许对一个类的多次引用,结构体总是通过被复制的方式在代 码中传递,不使用引用计数。
      /*
      定义类
      class SomeClass {
      // class definition goes here
      }
      定义结构体
      struct SomeStructure {
      // structure definition goes here
      }
      */
    import UIKit
    
    class ViewController: UIViewController {
    
        override func viewDidLoad() {
            super.viewDidLoad()
            //,Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体,系统将会自动生成面向其它代码的外部接口,通常一个类的实例被称为对象。然而在 Swift 中,类和结构体的关系要比在其他语言中更加的密切,本章中所讨论的大部分功能都可以用在类和结构体上。因此,我们会主要使用实例而不是对象。
            //类和结构体对比
    //        Swift 中类和结构体有很多共同点。共同处在于:
    //        定义属性用于存储值
    //        定义方法用于提供功能
    //        定义附属脚本用于访问值
    //        定义构造器用于生成初始化值
    //        通过扩展以增加默认实现的功能
    //        实现协议以提供某种标准功能
    //        与结构体相比,类还有如下的附加功能:
    //        继承允许一个类继承另一个类的特征
    //        类型转换允许在运行时检查和解释一个类实例的类型
    //        析构器允许一个类实例释放任何其所被分配的资源
    //        引用计数允许对一个类的多次引用,结构体总是通过被复制的方式在代码中传递,不使用引用计数。
            /*
            定义类
            class SomeClass {
            // class definition goes here
            }
            定义结构体
            struct SomeStructure {
            // structure definition goes here
            }
            */
            //**************************结构体***************************
            //定义一个结构体,在 Swift 中,所有的结构体和枚举类型都是值类型。这意味着它们的实例,以及实例中所包含的任何值类型属性,在代码中传递的时候都会被复制。
            //swift的结构体中可以 定义成员变量 和成员变量方法
            //内部有构造函数 但是没有析构函数
            //结构体类型
            //结构体中的成员变量 必须要初始化
            //1.在定义成员变量的时候初始化 2.或者在构造函数中初始化
            struct MYStudents{
                 //在定义的时候可以初始化成员变量
                var age:Int = 0;
                var height:Int = 0;
                 //内部自动会实现一个无参的构造 和 带参数的构造
            }
            //创建一个结构体变量
            var xiaohong:MYStudents = MYStudents();//里面会自动调用 内部的init()无参的构造
            //获取成员变量的值 通过'.'获取
            print("xiaohong_age = \(xiaohong.age) height = \(xiaohong.height)")//xiaohong_age = 0 height = 0
            
            //直接用点操作
            //对成员变量赋值
            xiaohong.age = 24
            xiaohong.height = 170
            print("xiaohong_age = \(xiaohong.age) height = \(xiaohong.height)")//xiaohong_age = 24 height = 170
            
            var xiaohuang:MYStudents = MYStudents(age: 25, height: 180) //会自动调用内部的带参数的构造
            print("xiaohuang_age = \(xiaohuang.age) height = \(xiaohuang.height)")//xiaohuang_age = 25 height = 180
            //下面我们自己实现构造函数
            struct MyStu {
                var age:Int
                var height:Int
                //无参数的构造函数构造函数前不需要加func,一般也不要加要不然会报错系统
                 init() {
                  
                    print("无参数的构造函数");
    //                age = 18;
    //                height = 175;
                    //建议用self.xxx
                    self.age = 18;
                    self.height = 15;
                
                
                }
                //带参数的构造函数
                //有参数的构造函数调用的时候 会自动加标签
                init(age:Int,height:Int){
                    //因为带参数的构造 的参数名 经常和成员变量同名 所以下面在赋值时建议使用self.age
                    //在结构体内部操作成员变量一般都是使用self.xxx
                    self.age = age;
                    self.height = height;
                    print("有参数的构造函数被调用")
                }
                //一个结构体中可以有多个 构造函数
                 /*参数名也可以起其他的名字
                init(newage:Int,newheight:Int){
                    //因为带参数的构造 的参数名 经常和成员变量同名 所以下面在赋值时建议使用self.age
                    //在结构体内部操作成员变量一般都是使用self.xxx
                    self.age = newage;
                    self.height = newheight;
                    print("有参数的构造函数被调用")
                }
               */
                //可以定义其它方法
                func sleep(){
                
                    print("呼呼大睡")
                }
                mutating func jump(){
                    
                    self.age = 10;//在其他函数中默认是不能修改成员变量的值的,如果结构体中的函数要修改成员变量 那么在定义的时候嵌套加mutating 关键字,现在swift版本不加这个关键字改变成员变量的值回报错的,所以这个问题系统就会帮我们提示
                }
            
            }
            var stu1:MyStu = MyStu()//自动调用内部的init()无参的构造
            print("stu1_age=\(stu1.age),stul_height = \(stu1.height)")// stu1_age=18,stul_height = 15
            //有参数的构造函数的调用
            var stu2:MyStu = MyStu(age: 22, height: 175)//有参数的构造函数被调用
            //调用结构体的方法
            stu1.sleep();//呼呼大睡
            stu2.jump()
           print("stu2_age=\(stu2.age),stu2_height = \(stu2.height)")//stu2_age=10,stu2_height = 175
            //**************************************************类**************************************************
            //不需要继承NSObject,类是引用类型
            //类 和 结构体的定义 很像 但是 类 有继承 有析构函数等等
            //swift 中的 成员变量 可以没有setter和getter 函数  就可以直接 通过. 来方法
            //swift 中的setter和getter 是用于计算属性的 (计算属性 不存储 数据 用于计算数据)
            class Person{
            //声明变量
                var age:Int = 0;//可以在这里初始化也可以在构造函数里面
                var score:Double;
                var name:NSString?//可以用可选值
            //类 有无参数的构造函数和有参数的构造函数
            //一个类可以有多个构造函数
                init(){
                   //建议内部访问成员变量用self.xxx
                    self.age = 22;
                    self.score = 100;
                    self.name = "pengpeng";
                    print("无参数的构造函数被调用")
                
                
                }
                //有参数的构造
                init(age:Int,score:Double,name:String){
                    self.age = age;
                    self.score = score;
                    self.name = name;
                    print("有参数的构造函数被调用");
                }
                //获取成员变量的值  实际上这样的函数 可以不用写
                //swift中 对象可以通过点来操作 成员变量
                //这是 和OC 不同的地方
                func getAge() ->Int{
                    return self.age;
                  
                }
                //成员方法
                func writeCode(){
                    print("正在快乐的敲代码")
                
                }
                //修改成员变量
                //普通方法也可以叫实例方法
                func changeScoreToZero(){
                      //类中的普通方法可以 直接修改成员变量 和结构体不一样 结构体需要加 mutating
                    self.score = 0.0;
                    print("score = \(self.score)");
                    
                
                
                }
                //swift 中的类方法 /和OC的类方法 类似/和c++的静态方法类似
                //类方法前 加 class
                //类方法是由类调用的方法 是和对象无关的方法
                class func hh() {
                    print("这是类方法")
                }
                //swift 还有析构函数
                //对象销毁的时候自动调用函数就是析构函数
                deinit{
                        print("对象销毁调用析构")
                
                }
            }
            //设计类的时候 成员变量也必须要初始化
            //全局变量
            var pengpeng:Person = Person();//自动调用无参数的构造
            func test(){
               //类名调用类方法
                Person .hh()
                //局部变量
                //peng变量引用一个Person对象
                ////Person()会创建对象  语句的含义 表示把一个Person类的对象一个引用 给xpeng
                //peng 和 OC中的对象指针类似
                var peng:Person = Person()
                //newPeng和peng引用的是同一个对象
                var newPeng:Person = peng;
                //获取成员变量的值 可以直接用 .操作
                //不需要写 OC中的setter和getter方法
                print("age:\(peng.age) name:\(peng.name!) score = \(peng.score)")
                //修改值
                peng.age = 24
                peng.name = "peng"
                peng.score = 100.0
                print("age:\(peng.age) name:\(peng.name!) score = \(peng.score)")
                
               
                peng.writeCode()
                
                //创建对象 用有参数的构造
                var xiaofen:Person = Person(age: 20, score: 99, name: "xiaofen")
                print("xiaofen_age:\(xiaofen.age) name:\(xiaofen.name!) score = \(xiaofen.score)")
            
            
            }
            test()
            // Do any additional setup after loading the view, typically from a nib.
        }
    
        override func didReceiveMemoryWarning() {
            super.didReceiveMemoryWarning()
            // Dispose of any resources that can be recreated.
        }
    
    
    }
    

    相关文章

      网友评论

          本文标题:swift-day07-类和结构体

          本文链接:https://www.haomeiwen.com/subject/bjibjttx.html