类属性

By admin in 4858.com on 2019年4月21日

 

 

仓库储存属性
实质上斯维夫特中的存款和储蓄属性正是之前学习OC中的普通属性,
在结构体或然类中定义的特性, 默许就是储存属性
*/

1).存款和储蓄属性

/*

/*

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

类和结构体中的属性,无特殊处理,都以积存属性,即属性开采了内部存款和储蓄器空间,能够积累值。

 存款和储蓄属性

 存储属性

/*
常量存款和储蓄属性
常量存款和储蓄属性只幸好概念时或协会时修改,
构造好3个目的之后不可能对常量存款和储蓄属性举行修改
*/

存款和储蓄属性分为常量存款和储蓄属性和变量存款和储蓄属性,常量存款和储蓄属性只好够在概念的时候赋初值,后续无法改换

 其实斯威夫特中的存款和储蓄属性就是从前学习OC中的普通属性,
在结构体或许类中定义的性质, 暗许就是累积属性

 其实斯威夫特中的存款和储蓄属性正是此前学习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 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 rect一 : Rect = Rect(height: 十0)   //
常量rect1的height属性能够通过点语法举办持续修改

struct Person {

struct Person {

class Person4 {
var name: String = “lnj”
var age: Int = 30
}
let p4:Person4 = Person4()
// 能够修改类常量中的值, 因为他本着的目标不是2个常量
p4.name = “hm”
// 无法修改类常量的对准
//p4 = Person4()

类常量对象,他本人是一个常量,但他对应的分子属性,能够透过她来进展更动

    var name: String

    var name: String

/*
延迟仓库储存属性
Swift语言中有着的积攒属性必须有开头值, 也正是当组织完一个目的后,
对象中存有的蕴藏属性必须有初始值, 可是也有例外,
在那之中延迟存款和储蓄属性可以将质量的开头化推迟到该属性第1回被调用的时候
懒加载应用场景:
一.有望不会用到
二.依附于其余值
*/


    var age: Int

    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)

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

}

}

/*
计量属性
一.斯威夫特中的总结属性不间接存款和储蓄值, 跟存款和储蓄属性分歧,
未有其余的”后端存款和储蓄与之对应”
二.总计属性用于计算, 能够兑现setter和getter那二种计算方法
叁.枚举不可能有囤积属性, 可是同意有总括属性
setter 对象.属性 = 值
getter var value = 对象.属性
*/

swift中持有的积攒属性必须有开首值,相当于当组织完三个类照旧结构体的目的后,对象中有着的积攒属性必须有开首值。

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

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可以友善传递2个参数, 也得以动用系统暗许的参数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)”)

不过也有分歧,当中,延迟存款和储蓄属性能够将性能的初始化向后推移到该属性第二遍被调用的时候。

print(“name = \(p.name) age = \(p.age)”)

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

  一.属性不合乎壹始发就开始化,取决于外部因素

p.name = “HaRi”

p.name = “HaRi”

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

  二.属性有比非常大恐怕未有会用到,不过他的起初化有亟待较长的光阴

p.age = 28

p.age = 28

/*
性情旁观器,类似OC中的KVO, 能够用来监听属性曾几何时被涂改,
只有品质被修改才会调用
有二种脾气观察器:
一.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

}

print(“name = \(p.name) age = \(p.age)”)

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()
// 类属性是全部目标共用1份
print(“gender = (Person5.gender)”)
p5.show()
// 能够将总计属性设置为类属性
print(“age = (Person5.age)”)

三).计算属性

/*

/*

class Person6 {
// 普通的质量是各个对象1份
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()

一.swift中的总结属性不直接存款和储蓄值,跟存款和储蓄属性差异,未有其余的“后端存款和储蓄与之对应”(不占用存款和储蓄空间)。

 常量存款和储蓄属性

 常量存款和储蓄属性

2.计算属性用于总计,能够兑现setter和getter那三种格局。

 常量存款和储蓄属性只还好概念时或组织时修改,
构造好3个对象之后不能够对常量存款和储蓄属性举办退换

 常量存款和储蓄属性只万幸概念时或组织时修改,
构造好二个目的之后不可能对常量存款和储蓄属性举行修改

三.枚举enum不可能有囤积属性,但足以有总计属性。

 */

 */

对象.属性 = value  — setter方法

 

 

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

struct Person2 {

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) {            //总计属性

     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

     }

   }

}

    var name: String

    var name: String


    var age : Int

    var age : Int

4).只读总括属性

    let card: String // 常量 ID Card

    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 p2 = Person2(name: “HaRi”, age: 24, card: “1234”)

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


p2.name = “helloName”

p2.name = “helloName”

五).属性观看器

p2.age = 25

p2.age = 25

考查属性的变迁,在质量被修改时,调用我们事先写好的代码去施行额外的动作,类似于OC中的KVO

// 构造好对象以往无法修改常量存款和储蓄属性

// 构造好对象以往无法改改常量存储属性

属性观看器有三种:

//p2.card = “333” Error!

//p2.card = “333” Error!

  一. willSet 在安装新值时,赋值前调用

 

 

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

/*

/*

能够直接为除lazy性格之外的存款和储蓄属性增添属性阅览器,也能够在承继类中为父类的测算属性提供属性观望期

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

 结构体和类常量与积存属性的涉及

struct MyRect {

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

          willSet {

                print(“\(newValue.x)”)

           }

          didSet {

               print(“\(oldValue.x)”)

          }

     }

}

 结构体和枚举是值类型

 结构体和枚举是值类型


 类是援引类型

 类是引用类型

6).类型属性

 */

 */

一.约等于“类”本身定义属性,那样的质量不依附于某二个“对象”,可以认为全体的靶子公用这脾本性;

 

 

贰.结构体或许枚举能够定义仓库储存或许计算型类属性,而类只好定义计算型类属性,不能够定义存款和储蓄类型

struct Person3 {

struct Person3 {

struct MyRect {

     static var center : (x : Double , y : Double) = (10 ,10)  
//借使在类中  static供给换为class关键字

}

MyRect.center = (10,11)

    var name: String

    var name: String

    var age : Int

    var age : Int

}

}

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

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

// 一.因为结构体是值类型, 所以无法修改结构体常量中的属性;

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

// 2.不可能改改结构体 / 枚举常量对象中的值, 因为她针对的目的是七个常量;

// 2.无法修改结构体 / 枚举常量对象中的值, 因为他针对性的靶子是2个常量;

//p3.name = “hiName”  Error!

//p3.name = “hiName”  Error!

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

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

 

 

 

 

class Person4 {

class Person4 {

    var name: String = “”

    var name: String = “”

    var age: Int = 20

    var age: Int = 20

}

}

let p4:Person4 = Person4()

let p4:Person4 = Person4()

// 能够修改类中常量中的值, 因为他们针对的目的不是一个常量

// 可以修改类中常量中的值, 因为他们针对的靶子不是二个常量

p4.name = “hello xiaohange”

p4.name = “hello xiaohange”

// 不得以修改类常量的指向

// 不得以修改类常量的针对性

//p4 = Person4()  Error!

//p4 = Person4()  Error4858.com,!

 

 

 

 

/*

/*

 延迟存款和储蓄属性

 延迟存款和储蓄属性

 Swift语言中具有的贮存属性必须有发轫值, 相当于当组织完一个对象后,
对象中具备的仓库储存属性必须有开端值, 不过也有不相同,
在那之中延迟存款和储蓄属性能够将质量的起先化推迟到该属性第一遍被调用的时候

 Swift语言中持有的贮存属性必须有先导值, 也正是当组织完一个对象后,
对象中装有的囤积属性必须有开端值, 不过也有不相同,
当中延迟存款和储蓄属性能够将性能的初步化推迟到该属性第二次被调用的时候

 懒加载应用场景:

 懒加载应用场景:

 1.有十分大恐怕不会用到

 1.有非常的大希望不会用到

 2.依附于别的值

 二.借助于任何值

 */

 */

 

 

class Line {

class Line {

    var start:Double = 0.0

    var start:Double = 0.0

    var end:Double = 0.0

    var end:Double = 0.0

    

    

    // 一.万1不是 lazy属性, 定义的时候对象还尚无初叶化,
所以无法访问self;

    // 一.假诺不是 lazy属性, 定义的时候对象还不曾起头化,
所以不能够访问self;

    // 二.万BlackBerry上 lazy, 代表行使时才会加载,
约等于使用到length属性时才会调用self;

    // 贰.倘若加上 lazy, 代表接纳时才会加载,
也正是行使到length属性时才会调用self;

    // 三.而访问三个类的质量必须透过对象方法,
所以访问时对象已经早先化落成了, 能够利用self

    // 叁.而访问1个类的品质必须经过对象方法,
所以访问时对象已经初阶化实现了, 可以接纳self

    lazy var length: Double = self.getLength()

    lazy var length: Double = self.getLength()

    

    

    // 通过闭包懒加载

    // 通过闭包懒加载

    lazy var container: Array<AnyObject> = {

    lazy var container: Array<AnyObject> = {

        print(“懒加载”)

        print(“懒加载”)

        

        

        var arrrM:Array<Int> = []

        var arrrM:Array<Int> = []

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

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

        return arrrM as [AnyObject]

        return arrrM as [AnyObject]

    }()

    }()

    

    

    func getLength() -> Double

    func getLength() -> Double

    {

    {

        print(“懒加载”)

        print(“懒加载”)

        return end – start

        return end – start

    }

    }

}

}

var line = Line()

var line = Line()

line.end = 200.0

line.end = 200.0

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

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

print(“创立对象达成”)

print(“创造对象完结”)

print(line.length)

print(line.length)

var arrM = line.container

var arrM = line.container

arrM.append(“1” as AnyObject)

arrM.append(“1” as AnyObject)

arrM.append(5 as AnyObject)

arrM.append(5 as AnyObject)

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

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

 

 

 

 

/*

/*

 总结属性

 总括属性

 一.斯威夫特中的计算属性不直接存款和储蓄值, 跟存储属性不一致,
未有其余的”后端存款和储蓄与之对应”

 一.Swift中的总结属性不直接存款和储蓄值, 跟存款和储蓄属性分裂,
未有任何的”后端存储与之对应”

 二.总结属性用于总括, 能够兑现setter和getter那二种总括方法

 二.总括属性用于总括, 能够落成setter和getter那二种总结情势

 三.枚举不得以有囤积属性, 可是允许有总括属性

 3.枚举不得以有囤积属性, 不过同意有总括属性

 setter 对象.属性 = 值

 setter 对象.属性 = 值

 getter var value = 对象.属性

 getter var value = 对象.属性

 */

 */

 

 

struct Rect {

struct Rect {

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

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

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

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

    

    

    // 由于center的值是透过起源和宽高计算出来的,
所以完全没要求提供3个存款和储蓄属性

    // 由于center的值是因此源点和宽高计算出来的,
所以完全没有要求提供贰个积存属性

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

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

        

        

        get{

        get{

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

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

        }

        }

        

        

        set{

        set{

            // 注意: 总结属性不具有存款和储蓄功用, 所以无法给总计属性赋值,
假如赋值会发出运转时不当

            // 注意: 总括属性不抱有存款和储蓄效率, 所以不可能给总计属性赋值,
如若赋值会生出运转时不当

            // 注意: setter能够和煦传递几个参数,
也能够行使系统默许的参数newValue

            // 注意: setter能够团结传递1个参数,
也足以选用系统暗中同意的参数newValue

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

            // 即使要使用系统自带的参数, 必须删除自定义参数

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

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

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

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

        }

        }

    }

    }

}

}

var r = Rect()

var r = Rect()

r.origion = (0, 0)

r.origion = (0, 0)

r.size = (100, 100)

r.size = (100, 100)

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

//r.center = ((r.origion.x + r.size.w) / 二, (r.origion.y + r.size.h) /
二)    // 能够直接在结构体中赢得, 此处能够轻便

print(“center.x = \(r.center.x) , center.y = \(r.center.y)”)

print(“center.x = \(r.center.x) , center.y = \(r.center.y)”)

r.center = (100, 100)

r.center = (100, 100)

print(“origion.x = \(r.origion.x) , origion.y = \(r.origion.y)”)

print(“origion.x = \(r.origion.x) , origion.y = \(r.origion.y)”)

print(“center.x = \(r.center.x) , center.y = \(r.center.y)”)

print(“center.x = \(r.center.x) , center.y = \(r.center.y)”)

 

 

 

 

/*

/*

 只读总结属性

 只读计算属性

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

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

 */

 */

class Line2 {

class Line2 {

    var start: Double = 0.0

    var start: Double = 0.0

    var end: Double = 0.0

    var end: Double = 0.0

    

    

    // 只读属性, 只读属性必须是变量var, 不可能是常量let

    // 只读属性, 只读属性必须是变量var, 不能够是常量let

    // 比方想赢得length, 只可以由此测算得到, 而不须求外界设置,
能够设置为只读总括属性

    // 举个例子想赢得length, 只可以经过测算获得, 而不须求外界设置,
能够安装为只读总计属性

    var leghth: Double {

    var leghth: Double {

        //只读属性能够简单get{}

        //只读属性能够大致get{}

//        get{

//        get{

            return end – start

            return end – start

//        }

//        }

    }

    }

}

}

var line2 = Line()

var line2 = Line()

line2.end = 100

line2.end = 100

print(line2.length)

print(line2.length)

 

 

/*

/*

 属性观看器,类似OC中的KVO, 可以用于监听属性几时被涂改,
只有总体性被修改才会调用

 属性观察器,类似OC中的KVO, 能够用来监听属性曾几何时被退换,
唯有品质被涂改才会调用

 有两种属性观望器:

 有两种性情旁观器:

 一.willSet, 在安装新值从前调用

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

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

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

 可以一向为除总计属性和lazy属性之外的积累属性增添属性观望器,
然而能够在承继类中为父类的推断属性提供属性观看器

 能够平昔为除总结属性和lazy属性之外的储存属性加多属性观看器,
但是足以在承袭类中为父类的妄图属性提供属性观看器

 因为在妄想属性中也得以监听到属性的改造,
所以给总计属性增添属性观看器未有别的意义

 因为在计算属性中也得以监听到属性的改换,
所以给总括属性增加属性观察器未有此外意义

 */

 */

 

 

class Line3{

class Line3{

    var start: Double = 0.0{

    var start: Double = 0.0{

        willSet{

        willSet{

            print(“willSet newValue = \(newValue)”)

            print(“willSet newValue = \(newValue)”)

        }

        }

        didSet{

        didSet{

            print(“didSet oldValue = \(oldValue)”)

            print(“didSet oldValue = \(oldValue)”)

        }

        }

    }

    }

    

    

    var end: Double = 0.0

    var end: Double = 0.0

}

}

var l = Line3()

var l = Line3()

l.start = 10.0

l.start = 10.0

 

 

 

 

/*

/*

 类属性

 类属性

 在结构体和枚举中用static

 在结构体和枚举中用static

 在类中应用class, 并且类中不容许将积累属性设置为类属性

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

 */

 */

struct Person5 {

struct Person5 {

    //普通的特性是各种对象的1份

    //普通的习性是各种对象的1份

    var name: String = “hjq”

    var name: String = “hjq”

    //类属性是有史以来对象共用一份

    //类属性是历来对象共用壹份

    static var gender: String = “Man”

    static var gender: String = “Man”

    static var age: Int{

    static var age: Int{

        return 25

        return 25

    }

    }

    func show()

    func show()

    {

    {

        print(“gender = \(Person5.gender) name = \(name)”)

        print(“gender = \(Person5.gender) name = \(name)”)

    }

    }

}

}

var p5 = Person5()

var p5 = Person5()

//print(“gender = \(p5.gender)”)  Error!

//print(“gender = \(p5.gender)”)  Error!

 

 

Person5.gender = “women”

Person5.gender = “women”

 

 

print(“p5 gender = \(Person5.gender)”)

print(“p5 gender = \(Person5.gender)”)

 

 

var p6 = Person5()

var p6 = Person5()

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

// 类属性是富有目标共用一份

print(“p6 gender = \(Person5.gender)”)

print(“p6 gender = \(Person5.gender)”)

p5.show()

p5.show()

 

 

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

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

print(“age = \(Person5.age)”)

print(“age = \(Person5.age)”)

 

 

 

 

class Person6 {

class Person6 {

    //普通的习性是各样对象一份

    //普通的性能是各样对象一份

    var name: String = “hjq”

    var name: String = “hjq”

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

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

//    class var gender: String = “man”   Error!

//    class var gender: String = “man”   Error!

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

    //类中只好将计算属性定义为类属性

    class var age: Int {

    class var age: Int {

        return 26

        return 26

    }

    }

    func show() {

    func show() {

        print(“age = \(Person6.age)”)

        print(“age = \(Person6.age)”)

    }

    }

}

}

var p7 = Person6()

var p7 = Person6()

print(“p7 age = \(Person6.age)”)

print(“p7 age = \(Person6.age)”)

p7.show()

p7.show()

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有