您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:结构体和类

新葡亰496net:结构体和类

发布时间:2019-07-05 12:55编辑:奥门新萄京娱乐场浏览(174)

     

    仓库储存属性
    骨子Rees维夫特中的存款和储蓄属性正是以前学习OC中的普通属性, 在结构体可能类中定义的属性, 暗中认可就是积累属性
    */

    1).存款和储蓄属性

    //*---------------------结构体-------------*/

    /*

    struct Person {
    var name: String
    var age: Int
    }
    var p:Person = Person(name: "lnj", age: 30)
    p.name = "hm"
    p.age = 50

    类和结构体中的属性,无差异样管理,都以积累属性,即属性开拓了内存空间,能够积攒值。

    //swift结构体也负有封装的定义

     存款和储蓄属性

    /*
    常量存款和储蓄属性
    常量存款和储蓄属性只好在概念时或结构时修改, 构造好一个指标之后不可能对常量存款和储蓄属性实行改换
    */

    仓库储存属性分为常量存款和储蓄属性和变量存款和储蓄属性,常量存款和储蓄属性只可以够在概念的时候赋初值,后续不得以转移

    //swift结构体比OC C语言里面包车型地铁结构体越发进了一步,里面能够有主意,更就如我们的类

     其实Swift中的存款和储蓄属性就是从前学习OC中的普通属性, 在结构体只怕类中定义的性质, 默许便是储存属性

    struct Person2 {
    var name: String
    var age: Int
    let card: String // 身份证
    }
    var p2: Person2 = Person2(name: "lnj", age: 30, card: "123456")
    p2.name = "hm"
    p2.age = 50
    // 构造好对象之后不可能修改常量存款和储蓄属性
    //p2.card = "56789"

    struct Rect {

       let width : Double = 10

       var height : Double

    }

    var _ = Rect(height: 100)

    //结构体的定义格式 struct结构体名{成员变量}

     */

    /*
    结构体和类常量与积存属性的关系
    结构体和枚举是值类型
    类是引用类型
    */

    布局体常量对象,他自家是贰个常量,其次,它对应的靶子也是常量,不可能被退换

    struct rect {

     

    struct Person3 {
    var name: String
    var age: Int
    }
    let p3: Person3 = Person3(name: "lnj", age: 30)
    // 因为结构体是值类型, 所以无法修改结构体常量中的属性
    // 无法修改结构体/枚举常量对象中的值, 因为她针对的对象是三个常量
    //p3.name = "hm"
    // 无法修改结构体常量对象的值
    //p3 = Person(name: "hm", age: 50)

    let rect1 : Rect = Rect(height: 100)   // 常量rect1的height属性可以经过点语法实行后续修改

        var width:Double //按构造方法赋初值

    struct Person {

    class Person4 {
    var name: String = "lnj"
    var age: Int = 30
    }
    let p4:Person4 = Person4()
    // 能够修改类常量中的值, 因为她本着的目的不是二个常量
    p4.name = "hm"
    // 无法修改类常量的指向
    //p4 = Person4()

    类常量对象,他自身是两个常量,但她对应的成员属性,能够因此他来开始展览修改

        var height:Double

        var name: String

    /*
    推迟囤积属性
    Swift语言中有所的寄存属性必须有初步值, 也等于当组织完三个对象后, 对象中颇具的存款和储蓄属性必须有开首值, 可是也可以有两样, 当中延迟存款和储蓄属性能够将质量的起先化推迟到该属性第2回被调用的时候
    懒加载应用场景:
    1.有异常的大概率不会用到
    2.依附于另外值
    */


        //方法

        var age: Int

    class Line {
    var start:Double = 0.0
    var end: Double = 0.0
    // 假如不是lazy属性, 定义的时候对象还尚未伊始化, 所以不可能访问self
    // 假若加上lazy, 代表采用时才会加载, 也正是选择到length属性时才会调用self,
    // 而访问二个类的属性必须透过对象方法, 所以访谈时对象已经伊始化完结了, 能够采用self
    lazy var length: Double = self.getLenght()
    // 通过闭包懒加载
    lazy var container: Array<AnyObject> = {
    print("懒加载")
    // return self.end - self.start
    var arrM = []
    return arrM as [AnyObject]
    }()
    func getLenght() ->Double
    {
    print("懒加载")
    return end - start
    }
    }
    var line = Line()
    line.end = 150.0
    //print(line.getLenght())
    print("成立对象实现")
    print(line.length)
    var arrM = line.container
    arrM.append("1")
    arrM.append(5)
    print(arrM)

    2).延迟存款和储蓄属性

        func getHeightWidth() -> (x:Double,y:Double)//->再次来到类型位元组

    }

    /*
    测算属性
    1.斯维夫特中的计算属性不直接存款和储蓄值, 跟存款和储蓄属性区别, 没有另外的"后端存款和储蓄与之对应"
    2.总结属性用于总结, 能够兑现setter和getter那二种总结方法
    3.枚举不可能有囤积属性, 但是同意有计算属性
    setter 对象.属性 = 值
    getter var value = 对象.属性
    */

    swift中具备的囤积属性必须有开首值,也正是当组织完一个类依旧结构体的目的后,对象中装有的囤积属性必须有开端值。

        {

    var p = Person(name: "xiaohange", age: 26)

    struct Rect {
    var origion: (x: Double, y: Double) = (0, 0)
    var size: (w: Double, h: Double) = (0, 0)
    // 由于center的值是经过源点和宽高计算出来的, 所以没有需求提供二个存款和储蓄属性
    // var center: (x: Double, y: Double) = (0, 0)
    var center: (x: Double, y: Double) {
    get{
    // print("get")
    return (origion.x size.w/2, origion.y size.h/2)
    }
    // set(newCenter){
    set{
    // print("set (newCenter)")
    // 注意: 总括属性不具备存款和储蓄功用, 所以无法给总结属性赋值, 假若赋值会生出运维时不当
    // 注意: setter能够协调传递贰个参数, 也能够利用系统暗中认可的参数newValue
    // 若是要使用系统自带的参数, 必须删除自定义参数
    // origion.x = newCenter.x - size.w / 2
    // origion.y = newCenter.y - size.h / 2
    origion.x = newValue.x - size.w / 2
    origion.y = newValue.y - size.h / 2
    }
    }
    }
    var r = Rect()
    r.origion = (0, 0)
    r.size = (100, 100)
    //r.center = ((r.origion.x r.size.w) / 2, (r.origion.y r.size.h) / 2)
    print("center.x = (r.center.x) center.y = (r.center.y)")
    r.center = (100, 100)
    print("origion.x = (r.origion.x) origion.y = (r.origion.y)")
    print("center.x = (r.center.x) center.y = (r.center.y)")

    不过也是有两样,在那之中,延迟存款和储蓄属性能够将质量的初阶化向后推移到该属性第贰遍被调用的时候。

            return(width,height)

    print("name = (p.name) age = (p.age)")

    /*
    只读总结属性
    对应OC中的readonly属性, 所谓的只读属性正是只提供了getter方法, 未有提供setter方法
    */

    推迟囤积属性适用场景:

        }

     

    class Line2 {
    var start:Double = 0.0
    var end: Double = 0.0
    // 只读属性, 只读属性必须是变量var, 无法是常量let
    // 举例想获得长度, 只好经过计算获得, 而不供给外部设置, 能够安装为只读总计属性
    var length: Double{
    // 只读属性的简写, 能够简轻松单get{}
    // get{
    return end - start
    // }
    }
    }

      1.属性不适合一上马就开首化,取决于外界因素

        func sumHeightWidth() -> (Double)

    p.name = "HaRi"

    var line2 = Line2()
    line2.end = 100
    print(line2.length)

      2.属性有望没有会用到,不过他的初叶化有亟待较长的年月

        {

    p.age = 28

    /*
    天性阅览器,类似OC中的KVO, 能够用来监听属性何时被修改, 唯有总体性被改换才会调用
    有二种属性观望器:
    1.willSet, 在设置新值在此之前调用
    2.didSet, 在安装新值之后调用
    能够一直为除总计属性和lazy属性之外的贮存属性增多属性观看器, 可是足以在承袭类中为父类的乘除属性提供属性观望器
    因为在计算属性中也足以监听到属性的更换, 所以给计算属性增加属性观望器未有任何意义
    */
    class Line3 {
    var start:Double = 0.0{
    willSet{
    print("willSet newValue = (newValue)")
    }
    didSet{
    print("didSet oldValue = (oldValue)")
    }
    }
    var end: Double = 0.0
    }
    var l = Line3()
    l.start = 10.0

    class student {

       var name : NSString = ""

       lazy var averageScore : Double = 0

    }

            return(width height)

    print("name = (p.name) age = (p.age)")

    /*
    类属性
    在结构体和枚举中用static
    在类中接纳class, 况兼类中不一致意将积存属性设置为类属性
    */


        }

     

    struct Person5 {
    // 普通的质量是各类对象一份
    var name: String = "lnj"
    // 类属性是根本对象共用一份
    static var gender:String = "man"
    static var age:Int{
    return 30
    }
    func show()
    {
    print("gender = (Person5.gender) name = (name)")
    }
    }
    var p5 = Person5()
    //print("gender = (p.gender)")
    print("gender = (Person5.gender)")
    var p6 = Person5()
    // 类属性是装有目的共用一份
    print("gender = (Person5.gender)")
    p5.show()
    // 能够将总结属性设置为类属性
    print("age = (Person5.age)")

    3).总结属性

    }

    /*

    class Person6 {
    // 普通的天性是各类对象一份
    var name: String = "lnj"
    // 类中不允许将积存属性定义为类属性
    // class var gender:String = "man"
    // 类中不得不将总计属性定义为类属性
    class var age:Int{
    return 30
    }
    func show()
    {
    print("age = (Person6.age)")
    }
    }
    var p7 = Person6()
    print("age = (Person6.age)")
    p7.show()

    1.swift中的总结属性不直接存款和储蓄值,跟存款和储蓄属性分化,没有任何的“后端存款和储蓄与之对应”(不占用存款和储蓄空间)。

     

     常量存款和储蓄属性

    2.总计属性用于总括,能够兑现setter和getter那三种艺术。

    //评释结构体对象 var 变量名:结构体类型=结构体类型(参数)

     常量存储属性只可以在概念时或组织时修改, 构造好三个对象之后不可能对常量存款和储蓄属性实行改换

    3.枚举enum不得以有囤积属性,但能够有总括属性。

    //swift要求当定义一个结构体对象的时候,必定要对里面包车型大巴变量赋多少个牢固的值

     */

    对象.属性 = value  --- setter方法

    //结构体的构造方法(正是创制了叁个结构体对象,首先她要分配内部存款和储蓄器空间(这一步由系统自动帮大家做到),分配完内部存款和储蓄器就能够即时调用大家的开头化方法(构造方法)来对变量赋初值)

     

    let value = 对象.属性 --- getter方法

     

    struct Person2 {

    struct MyRect {

       var origin : (x : Double , y : Double) = (0 , 0)  // 存款和储蓄属性

       var size : (w : Double , h : Double) = (0 , 0)    // 存款和储蓄属性

       var center : (x : Double , y : Double) {            //总计属性

    新葡亰496net:结构体和类。     get {

              return (origin.x size.w / 2, origin.y size.h / 2)

          }

         set (n) {

           //origin是积累属性 能够被赋值

          //center是总括属性 不得以被赋值

           //newValue是系统提供的私下认可setter值 : set �{ origin.x = newValue.x - size.w / 2 }

          origin.x = n.x - size.w / 2

           origin.y = n.y - size.h / 2

         }

       }

    }

    //swift的结构体早先化方法有三种 一种是成员相继协会器var rect1:rect=rect(width: 100, height: 100) 一种是系统暗中认可的不带别的参数的初步化方法struct rect {

        var name: String


    //var width:Double=0.0 //按构造方法赋初值

        var age : Int

    4).只读总计属性

    //var height:Double=0.0

        let card: String // 常量 ID Card

    只提供get方法,不提供set方法的属性,称为只读总结属性

    //}

    }

    struct MyRect {

        var size : (w : Double , h : Double) = (0 , 0) // 存款和储蓄属性

        var center : (x : Double , y : Double) { //计算属性

       //    get {

                return (size.w / 2,  size.h / 2)

       //     }

     }

    }      // 只读总括属性  get方法的关键字get和括号能够省略掉

    //var rect1:rect=rect()

    var p2 = Person2(name: "HaRi", age: 24, card: "1234")


    var rect1:rect=rect(width: 100, height: 100)

    p2.name = "helloName"

    5).属性阅览器

    println("(rect1.width),(rect1.height)")

    p2.age = 25

    入眼属性的变化,在质量被涂改时,调用大家先行写好的代码去施行额外的动作,类似于OC中的KVO

     

    // 构造好对象以往不可能改改常量存款和储蓄属性

    品质观察器有二种:

    //调用

    //p2.card = "333" Error!

      1. willSet 在装置新值时,赋值前调用

    var c_n=rect1.getHeightWidth()

     

      2. didSet 在新值被赋之后调用

    println(c_n)

    /*

    能够直接为除lazy质量之外的存款和储蓄属性增添属性观望器,也能够在承接类中为父类的企图属性提供属性观看期

     

     结构体和类常量与仓库储存属性的关系

    struct MyRect {

        var center : (x : Double , y : Double) {

              willSet {

                    print("(newValue.x)")

               }

              didSet {

                   print("(oldValue.x)")

              }

         }

    }

    var w_h=rect1.sumHeightWidth()

     结构体和枚举是值类型


    println(w_h)

     类是援用类型

    6).类型属性

     

     */

    1.也正是“类”本人定义属性,那样的天性不依据于某贰个“对象”,能够以为具有的靶子公用那性子格;

    //结构体的总体赋值

     

    2.结构体也许枚举能够定义储存恐怕计算型类属性,而类只可以定义计算型类属性,不得以定义存款和储蓄类型

    var rect3 = rect1

    struct Person3 {

    struct MyRect {

         static var center : (x : Double , y : Double) = (10 ,10)   //假诺在类中  static要求换为class关键字

    }

    MyRect.center = (10,11)

    //全体赋值后的可能有三种(1)rect3与rect1指向同七个内部存款和储蓄器空间(2)rect3与rect1内容一律,内存空间不均等

        var name: String

    //验证措施有三种能够一贯打字与印刷内部存款和储蓄器地址还应该有一种是更换值假如指向统一内部存款和储蓄器空间则赋值后的也相应改动成同样

        var age : Int

    rect1.width = 20

    }

    println(rect1.width)

    let p3 = Person3(name: "hjq", age: 26)

    println(rect3.width)

    // 1.因为结构体是值类型, 所以不可能修改结构体常量中的属性;

    //值未变能够知晓是第三种 即赋值后内容一样,内部存款和储蓄器空间不均等

    // 2.无法改改结构体 / 枚举常量对象中的值, 因为她本着的指标是一个常量;

     

    //p3.name = "hiName"  Error!

    /*----------------------类-----------------*/

    //p3 = Person3(name: "hiName", age: 27)   Error!

    //类与结构体在概念的格式上未曾太大的不一致,类在创设的时候须求求给内部的变量附一个初步值,因为类与结构体不均等,它未有成员相继构造器

     

    class rectww {

     

        var width:Double=0.0

    class Person4 {

        var height:Double=0.0

        var name: String = ""

    }

        var age: Int = 20

    var re:rectww=rectww()

    }

    println("(re.width),(re.height)")

    let p4:Person4 = Person4()

     

    // 能够修改类中常量中的值, 因为他们本着的对象不是贰个常量

    //类的欧洲经济共同体赋值

    p4.name = "hello xiaohange"

    //指向同一内部存款和储蓄器空空间

    // 不可以修改类常量的针对

    var ss = re

    //p4 = Person4()  Error!

    re.width = 200

     

    println(re.width)

     

    println(ss.width)

    /*

    //===恒等 !==不等 只好用类

     延迟存款和储蓄属性

    if ss===re{

     Swift语言中装有的仓库储存属性必须有开端值, 也正是当协会完两个指标后, 对象中具有的积攒属性必须有伊始值, 不过也会有不一样, 在那之中延迟存储属性可以将品质的初步化推迟到该属性第4回被调用的时候

        println("同一个类")

     懒加载应用场景:

    }

     1.有望不会用到

    else

     2.依赖于任何值

    {

     */

        println("不同")

     

    }

    class Line {

     

        var start:Double = 0.0

     

        var end:Double = 0.0

     

        

    //存款和储蓄属性

        // 1.假若不是 lazy属性, 定义的时候对象还从未伊始化, 所以无法访问self;

    //常量存款和储蓄属性 :只好在布局对象的时候退换值之后不被允许改动

        // 2.只要加上 lazy, 代表行使时才会加载, 也等于选用到length属性时才会调用self;

    //延迟存款和储蓄属性

        // 3.而访问二个类的属性必须透过对象方法, 所以访谈时对象已经起首化完毕了, 能够使用self

     

        lazy var length: Double = self.getLength()

    //结构体常量和类常量与仓库储存属性的关系

        

    //结构体常量常量对象,本身是二个常量,对应的习性不得以通过修改它更换

        // 通过闭包懒加载

    struct person{

        lazy var container: Array<AnyObject> = {

        let name:NSString = "张三"//常量

            print("懒加载")

        var age:Int = 10//变量

            

    }

            var arrrM:Array<Int> = []

    let per:person=person(name: "李四", age: 20)//在结构对象的时候可以改造值之后不被允许更改 举个例子会报错//per.name = "王五" //per.age = 39

    //        return self.end - self.start   Error!

    println(per.name)

            return arrrM as [AnyObject]

     

        }()

    //类自个儿是多个常量,属性能够透过修改它改造

        

    class person1{

        func getLength() -> Double

        let name1:NSString = "张三"//常量

        {

        var age1:Int = 10//变量

            print("懒加载")

    }

            return end - start

    let per1:person1=person1()//在结构对象的时候能够变动值之后不被允许改造举例会报错

        }

    //per1.name1 = "王五"

    }

    per1.age1 = 39

    var line = Line()

    println(per1.name1)

    line.end = 200.0

     

    //print(line.length())  Error!

    //延迟存储属性

    print("创造对象达成")

    /*

    print(line.length)

    swift语言中具有的寄放属性都不能够不要有初阶值,也正是当调用完构造方法后对象中的全数变量都应该有二个开始值,可是延迟存款和储蓄属性比很差异,它的赋值并不都在调用构造方法的时候被初始化,而是在首先次被调用的时候伊始化

    var arrM = line.container

    */

    arrM.append("1" as AnyObject)

     

    arrM.append(5 as AnyObject)

    struct student {

    print(arrM)    // [1, 2, 3, 1, 5]

        var name:String

     

        var chinese:Double

     

        var math:Double

    /*

        func showMyStudent(){

     计算属性

            println("姓名:(name),语文战绩:(chinese),数学战绩:(math)")

     1.Swift中的总结属性不间接存款和储蓄值, 跟存储属性区别, 未有其余的"后端存储与之对应"

        }

     2.总计属性用于计算, 能够兑现setter和getter那二种总计方法

    }

     3.枚举不可能有囤积属性, 不过允许有总计属性

    class myClass {

     setter 对象.属性 = 值

        var array:[student]=[]

     getter var value = 对象.属性

        lazy var score :Double = self.getScore()//延迟

     */

        func getScore()->Double{

     

            println("888888")

    struct Rect {

            var t:Double = 0

        var origion:(x: Double, y: Double) = (0, 0)

            for i in array

        var size:(w: Double, h: Double) = (0, 0)

            {

        

                t =i.chinese

        // 由于center的值是通过起源和宽高总计出来的, 所以没有供给提供一个仓库储存属性

                t =i.math

        var center:(x: Double, y:Double){

            }

            

            if array.count == 0

            get{

            {

                return (origion.x size.w/2, origion.y size.h/2)

                return 0

            }

            }

            

            else

            set{

            {

                // 注意: 计算属性不享有存款和储蓄成效, 所以无法给总结属性赋值, 借使赋值会发生运维时不当

                //swif里面唯有隐式类型估算,没有隐式类型转变

                // 注意: setter能够友善传递贰个参数, 也能够接纳系统暗中认可的参数newValue

                return t/Double (array.count)

                // 假诺要运用系统自带的参数, 必须删除自定义参数

            }

                origion.x = newValue.x - size.w / 2

        }

                origion.y = newValue.y - size.h / 2

        func show(){

            }

            for i in array

        }

            {

    }

                i.showMyStudent()//直接调用方法

    var r = Rect()

            }

    r.origion = (0, 0)

        }

    r.size = (100, 100)

    }

    //r.center = ((r.origion.x r.size.w) / 2, (r.origion.y r.size.h) / 2)    // 能够直接在结构体中得到, 此处能够省略

     

    print("center.x = (r.center.x) , center.y = (r.center.y)")

    let stu1 = student(name: "张三", chinese: 100, math: 100)

    r.center = (100, 100)

    let stu2 = student(name: "李四", chinese: 100, math: 100)

    print("origion.x = (r.origion.x) , origion.y = (r.origion.y)")

    //创造类的目的

    print("center.x = (r.center.x) , center.y = (r.center.y)")

    let c0 = myClass()

     

    c0.array.append(stu1)//加到数组

     

    c0.array.append(stu2)

    /*

    c0.show()

     只读总括属性

    println(c0.getScore())

     对应OC中的readonly属性, 所谓的只读属性便是只提供了getter方法, 未有提供setter方法

    println("********")

     */

     

    class Line2 {

    //总括属性

        var start: Double = 0.0

    /*

        var end: Double = 0.0

    1.swift中的总结属性无法一向存款和储蓄数据,与我们的囤积属性不一样,未有其他的"后端存款和储蓄与之对应",轻松的话便是在对指标中种种不占用存款和储蓄空间

        

    2.总结属性用于计算,能够兑现setter和getter二种艺术

        // 只读属性, 只读属性必须是变量var, 无法是常量let

    */

        // 举个例子想获得length, 只可以因而测算获得, 而没有须要外部设置, 能够设置为只读总括属性

     

        var leghth: Double {

    struct myRect {

            //只读属性能够归纳get{}

        var origin:(x:Double,y:Double)=(0,0)//坐标

    //        get{

        var size:(w:Double,h:Double)=(10,10)

                return end - start

        var center:(x:Double,y:Double)//中心点

    //        }

            {

        }

                //getter方法 当唯有getter方法为只读 能够简写为一句return (origin.x size.w/2,origin.y size.h/2)

    }

                get{

    var line2 = Line()

                    return (origin.x size.w/2,origin.y size.h/2)

    line2.end = 100

                }

    print(line2.length)

               //setter方法

     

                set(n){

    /*

                    //当sette未有传递参数时用newValue来替代n

     属性观望器,类似OC中的KVO, 能够用来监听属性哪天被更改, 唯有总体性被涂改才会调用

                     origin.x=n.x-size.w/2

     有三种属性观望器:

                     origin.y=n.y-size.h/2

     1.willSet, 在安装新值以前调用

                }

     2.didSet, 在设置新值之后调用

        }

     能够平素为除总结属性和lazy属性之外的存放属性加多属性观望器, 可是能够在承袭类中为父类的计量属性提供属性观望器

    }

     因为在测算属性中也能够监听到属性的更换, 所以给总括属性增添属性观望器未有其余意义

    var rect4 = myRect()

     */

    rect4.size=(100,100)

     

    rect4.origin=(10,10)

    class Line3{

    //rect4.center=(rect4.origin.x rect4.size.w/2,rect4.origin.y rect4.size.h/2)

        var start: Double = 0.0{

    println(rect4.center)

            willSet{

     

                print("willSet newValue = (newValue)")

     

            }

    //属性观看器

            didSet{

    //用于观望属性别变化化,是指属性的值被修改时得以调用大家事先写好的一对代码段 类似oc中的kvo

                print("didSet oldValue = (oldValue)")

    //swift存在几种性子观望器

            }

    //1.willset 在安装新值的时候被调用的

        }

    //2.didset 在新值设置之后被调用

        

    //不得以给延迟属性增加观看器 别的的都足以

        var end: Double = 0.0

     

    }

    class rr {

    var l = Line3()

        var a:String="nihao"{

    l.start = 10.0

            willSet{

     

                println("willSet,退换以前的值:(a)")

     

                println(newValue)

    /*

            }

     类属性

            didSet{

     在结构体和枚举中用static

                println("didSet,改换之后的值:(a)")

     在类中央银行使class, 并且类中不允许将积累属性设置为类属性

                println(oldValue)

     */

            }

    struct Person5 {

        }

        //普通的品质是各类对象的一份

        

        var name: String = "hjq"

    }

        //类属性是常有对象共用一份

    //改动值 先成立类的靶子

        static var gender: String = "Man"

    var ass=rr()

        static var age: Int{

    ass.a="hehe"

            return 25

     

        }

    //总计 结构体为值传递 类为引用

        func show()

     

        {

            print("gender = (Person5.gender) name = (name)")

        }

    }

    var p5 = Person5()

    //print("gender = (p5.gender)")  Error!

     

    Person5.gender = "women"

     

    print("p5 gender = (Person5.gender)")

     

    var p6 = Person5()

    // 类属性是全部目的共用一份

    print("p6 gender = (Person5.gender)")

    p5.show()

     

    //能够将总括属性设置为类属性

    print("age = (Person5.age)")

     

     

    class Person6 {

        //普通的属性是每一种对象一份

        var name: String = "hjq"

        //类中不允许将累积属性定义为类属性

    //    class var gender: String = "man"   Error!

        //类中不得不将总括属性定义为类属性

        class var age: Int {

            return 26

        }

        func show() {

            print("age = (Person6.age)")

        }

    }

    var p7 = Person6()

    print("p7 age = (Person6.age)")

    p7.show()

     

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:结构体和类

    关键词:

上一篇:主要教学pyinstaller的用法,学员肖杰

下一篇:没有了