类属性

 

 

仓库储存属性
实则斯维夫特中的存款和储蓄属性就是从前学习OC中的普通属性,
在结构体恐怕类中定义的性质, 暗中认可正是储存属性
*/

一).存款和储蓄属性

/*

/*

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

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

 存款和储蓄属性

 存款和储蓄属性

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

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

 其实斯威夫特中的存款和储蓄属性正是从前学习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)

 */

 */

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

结构体常量对象,他自个儿是2个常量,其次,它对应的靶子也是常量,不得以被涂改

 

 

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: 十0)   //
常量rect一的height属性能够通过点语法进行三番五次修改

struct Person {

struct Person {

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

类常量对象,他本人是二个常量,但她对应的成员属性,能够经过他来拓展修改

    var name: String

    var name: String

/*
推迟囤积属性
Swift语言中享有的仓库储存属性必须有起初值, 也正是当组织完三个指标后,
对象中具有的蕴藏属性必须有早先值, 不过也有两样,
在那之中延迟存储属性能够将质量的早先化推迟到该属性第3次被调用的时候
懒加载应用场景:
一.有不小概率不会用到
贰.依靠于别的值
*/


    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)

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

}

}

/*
测算属性
一.Swift中的总括属性不直接存款和储蓄值, 跟存款和储蓄属性不相同,
未有其它的”后端存款和储蓄与之对应”
二.总结属性用于总括, 能够达成setter和getter那三种总括方式
3.枚举不得以有囤积属性, 不过同意有总括属性
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的值是因此源点和宽高计算出来的,
所以大可不必提供3个储存属性
// 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能够友善传递1个参数, 也得以利用系统暗中同意的参数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, 能够用于监听属性曾几何时被修改,
唯有总体性被更改才会调用
有三种本性观望器:
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

}

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

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

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


 

 

struct Person5 {
// 普通的质量是每个对象1份
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)”)

三).总计属性

/*

/*

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()

一.swift中的计算属性不间接存款和储蓄值,跟存款和储蓄属性分歧,没有其余的“后端存款和储蓄与之对应”(不占用存款和储蓄空间)。

 常量存款和储蓄属性

 常量存款和储蓄属性

贰.总计属性用于总计,能够完成setter和getter那三种办法。

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

 常量存款和储蓄属性只辛亏概念时或协会时修改,
构造好三个对象之后不能对常量存储属性实行退换

三.枚举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

四).只读计算属性

    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”

5).属性观看器

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)”)

          }

     }

}

 结构体和枚举是值类型

 结构体和枚举是值类型


 类是援引类型

 类是援引类型

陆).类型属性

 */

 */

一.也便是“类”自己定义属性,那样的习性不依附于某贰个“对象”,能够觉得颇具的靶子公用那几个天性;

 

 

二.结构体可能枚举能够定义储存只怕计算型类属性,而类只好定义计算型类属性,不得以定义存储类型

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.不可能修改结构体 / 枚举常量对象中的值, 因为她针对性的靶子是一个常量;

// 二.无法修改结构体 / 枚举常量对象中的值, 因为他本着的目的是一个常量;

//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()

// 能够修改类中常量中的值, 因为她俩针对的对象不是三个常量

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

p4.name = “hello xiaohange”

p4.name = “hello xiaohange”

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

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

//p4 = Person4()  Error!

//p4 = Person4()  Error!

 

 

 

 

/*

/*

 延迟存款和储蓄属性

 延迟存款和储蓄属性

 斯维夫特语言中享有的仓库储存属性必须有初叶值, 也正是当组织完三个对象后,
对象中具有的储存属性必须有起始值, 不过也有两样,
个中延迟存款和储蓄属性能够将品质的伊始化推迟到该属性第二遍被调用的时候

 Swift语言中全部的积存属性必须有早先值, 也便是当协会完多少个目的后,
对象中享有的仓库储存属性必须有开端值, 然而也有分裂,
在那之中延迟存储属性能够将品质的开端化推迟到该属性第一遍被调用的时候

 懒加载应用场景:

 懒加载应用场景:

 1.有不小或许不会用到

 一.有异常的大可能率不会用到

 二.凭借于任何值

 二.重视于别的值

 */

 */

 

 

class Line {

class Line {

    var start:Double = 0.0

    var start:Double = 0.0

    var end:Double = 0.0

    var end:Double = 0.0

    

    

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

    // 1.壹旦不是 lazy属性, 定义的时候对象还一向不早先化,
所以无法访问self;

    // 贰.一旦加上 lazy, 代表采用时才会加载,
也正是选取到length属性时才会调用self;

    // 二.要是加上 lazy, 代表选取时才会加载,
也便是应用到length属性时才会调用self;

    // 3.而访问多个类的性质必须透过对象方法,
所以访问时对象已经初步化完毕了, 能够行使self

    // 三.而访问3个类的性质必须通过对象方法,
所以访问时对象已经开头化达成了, 能够接纳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]

 

 

 

 

/*

/*

 总计属性

 计算属性

 1.Swift中的总括属性不直接存款和储蓄值, 跟存款和储蓄属性差别,
未有其余的”后端存款和储蓄与之对应”

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

 二.总括属性用于计算, 可以兑现setter和getter那三种总括办法

 二.总计属性用于计算, 能够完毕setter和getter那三种计算方法

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

 三.枚举不可能有囤积属性, 可是同意有总括属性

 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的值是经过起源和宽高总括出来的,
所以完全没有供给提供叁个仓库储存属性

    // 由于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能够自个儿传递3个参数,
也得以使用系统暗中认可的参数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) / 2, (r.origion.y + r.size.h) /
2)    // 可以一直在结构体中得到, 此处能够简单

//r.center = ((r.origion.x + r.size.w) / 二, (r.origion.y + r.size.h) /
2)    // 可以直接在结构体中得到, 此处能够归纳

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, 在安装新值在此以前调用

 二.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份

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

    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 {

    //普通的习性是种种对象一份

    //普通的质量是每种对象1份

    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()

 

 

相关文章

发表评论

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

*
*
Website