类属性

 

 

积存属性
实际上斯威夫特中的存款和储蓄属性便是以前学习OC中的普通属性,
在结构体大概类中定义的属性, 默许就是储存属性
*/

一).存储属性

/*

/*

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)

 */

 */

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

布局体常量对象,他本人是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 rect壹 : 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

/*
延期囤积属性
斯威夫特语言中全数的积存属性必须有开首值, 也便是当协会完三个对象后,
对象中享有的存款和储蓄属性必须有起始值, 不过也有两样,
当中延迟存款和储蓄属性能够将品质的开首化推迟到该属性第三遍被调用的时候
懒加载应用场景:
一.有非常大恐怕不会用到
2.依赖于别的值
*/


    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那三种计算办法
叁.枚举不能有囤积属性, 然则同意有计算属性
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可以协调传递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
// }
}
}

  1.属性不吻合一从头就开首化,取决于外部因素

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 {
// 普通的品质是各类对象1份
var name: String = “lnj”
// 类属性是一直对象共用1份
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 {
// 普通的习性是各种对象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中的总括属性不直接存款和储蓄值,跟存款和储蓄属性差别,未有其它的“后端存储与之对应”(不占用存款和储蓄空间)。

 常量存款和储蓄属性

 常量存款和储蓄属性

二.总计属性用于计算,可以完毕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 / 二 }

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

          }

     }

}

 结构体和枚举是值类型

 结构体和枚举是值类型


 类是引用类型

 类是引用类型

陆).类型属性

 */

 */

壹.也便是“类”自个儿定义属性,那样的习性不依附于某一个“对象”,能够以为具有的靶子公用那性情子;

 

 

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

struct Person3 {

struct Person3 {

struct MyRect {

     static var center : (x : Double , y : Double) = (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.因为结构体是值类型, 所以不可能改改结构体常量中的属性;

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

// 二.不可能修改结构体 / 枚举常量对象中的值, 因为她本着的目的是3个常量;

// 二.不可能修改结构体 / 枚举常量对象中的值, 因为他针对的对象是1个常量;

//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.有十分大可能率不会用到

 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

    

    

    // 1.要是或不是 lazy属性, 定义的时候对象还尚未开头化,
所以无法访问self;

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

    // 二.万金立上 lazy, 代表行使时才会加载,
也正是行使到length属性时才会调用self;

    // 二.借使加上 lazy, 代表行使时才会加载,
也便是采取到length属性时才会调用self;

    // 叁.而访问二个类的本性必须经过对象方法,
所以访问时对象已经起初化实现了, 能够接纳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中的总结属性不直接存款和储蓄值, 跟存款和储蓄属性差别,
没有其余的”后端存款和储蓄与之对应”

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

 2.总结属性用于总括, 能够实现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的值是透过源点和宽高总计出来的,
所以完全没须求提供1个存款和储蓄属性

    // 由于center的值是通过源点和宽高总括出来的,
所以大可不必提供1个仓库储存属性

    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) / 2, (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, 能够用来监听属性曾几何时被涂改,
唯有质量被修改才会调用

 有三种属性观望器:

 有二种属性观看器:

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

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

 二.didSet, 在安装新值之后调用

 2.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”

    //类属性是平昔对象共用1份

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

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

 

 

发表评论

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

网站地图xml地图