您的位置:时时app平台注册网站 > 编程知识 > 构造方法 (1)

构造方法 (1)

2019-11-08 01:39

 结构体中定义成员方法

 

r4.show()

print("================================")

    var width:Double

 

 

    {

print("width = (r.width), height = (r.height)")

//懒加载是用到才执行, 而闭包赋值是初始化时就会执行

print("width = (r.width), height = (r.height)")

        self.width = width

 

    }

var r1 = Rect2(width: 10.0, height: 10.0)

    //3.而方法的内部参数, 从第二个开始才会当做外部参数;

}

print(p5.height)

 1.指向同一块存储空间

//        self.width = 0.0

 Swift要求实例化一个结构体或类的时候,所有的成员变量都必须有初始值, 构造函数的意义就是用于初始化所有成员变量的, 而不是分配内存, 分配内存是系统帮我们做的.

    func description() -> String {

//结构体中的成员方法是和某个实例对象绑定在一起的, so, 谁调用, 方法中访问的属性就是谁

    }

        print("width = (width) height = (height)")

 

    var width: Double = 0.0

class Person4 {

    var height:Double = 0.0

    var age:Int

 */

 4.如果所有的存储属性都有默认值, 可以不提供构造方法, 系统会提供一个隐式的构造方法;

 在C和OC中结构体只有属性, 而Swift中结构体中还可以定义方法

    }

 struct 结构体名称 {

}

print(r4)

        //构造器代理

 

    

struct Rect2 {

    {

var r4 = Rect4(width: 10.0, height: 10.0)

        self.name = name

 2.两个不同实例, 但内容相同

print(p2.description())

/** 结构体是值类型 **/

class Person5 {

    }

    }

    func show() -> Void {

    init(width:Double, height:Double)

// 结构体是值类型, 结构体之间的赋值其实是将r4中的值完全拷贝一份到r5中, 所以他们两个是不同的实例

        self.height = height

 

//var r = Rect(width: 1.0, heigth: 1.0)

struct Rect {

    {

r.height = 120.5

var r2 = Rect2()

// 取得r2这个对象的宽度

// 4.如果给存储属性提供了缺省值, 可以使用不带参数的方法初始化结构体

 

    */

 格式:

    }

// 逐一构造器

class Person {

}

 

r4.width = 20.0

/*

 

    var name:String

 

        self.width = 0.0

    // 3.成员方法可以访问成员属性

    var name:String

 

    /*

    var height:Double = 0.0

 

    }

    // 系统默认会提供一个类似的方法

 }

    //1.可选值存储属性可以不再构造方法中初始化;

//var r1 = Rect2(height: 10.0, width: 10.0) // Error!

    var width:Double, height:Double

 

        print("init")

    var width:Double

print("================================")

print(r5)

 

 结构体是用于封装不同或相同类型的数据的, Swift中的结构体是一类类型, 可以定义属性和方法(甚至构造方法和析构方法等)

class Car {

/*

    var age:Int

    // 2.结构体中的成员方法必须使用某个实例调用

    init() {

}

    */

 Swift中的结构体和类跟其它面向对象语言一样都有构造函数, 而OC是没有的

    

        return width

    {

 

        print("width = (width) height = (height)")

 

        return "name = (name) age = (age)"

 结构体构造器

 通过闭包或者全局函数/类方法 设置存储属性的缺省值

r.width = 99.9

    //注意: 闭包后面一定要有(), 代表执行闭包

/*

//        self.height = 0.0

//var r1 = Rect2(width: 10.0)  //Error!

        self.name = name

r4.show()

 常量存储属性只能通过缺省值或在构造方法中被修改, 其它任何地方都不能修改

print(r2.getWidth())

 好处: 减少构造方法之间的重复代码

// 如果结构体的属性有默认值, 可以直接使用()构造一个结构体

 2.构造方法的作用仅仅是用语初始化属性, 而不是分配内容, 分配内存是系统帮我们做的;

var r5 = r4

 

// 如果结构体的属性没有默认值, 必须使用逐一构造器实例化结构体

    var age:Int

 */

    let name:String

    func getWidth() -> Double {

        self.height = 0.0

/*

 常量存储属性与构造方法

// 取得r3这个对象的宽度

r3.show()

var r3 = Rect3(width: 50.0, height: 30.0)

 

 

}

// 结构体属性访问 使用语法

        () -> Int in  // 这一行可以省略, 返回值是可以省略的,默认返回值的类型就是存储属性的类型

 如果结构体中的属性没有默认值, 可以自定义构造器, 并在构造器中给所有的属性赋值

    init(age:Int, name:String)

print(r3.getWidth())

    }

var r2 = Rect3(width: 10.0, height: 10.0)

var r3 = Rect2(width: 100, height: 100)

 

print(p3.description())

}

class Person3 {

 其实结构体有一个默认的逐一构造器, 用于在初始化时给所有属性赋值

/*

    var height:Double = 0.0

        return "name = (name) age = (age)"

struct Rect4 {

    }

var r = Rect()

 

    // 1.给结构体定义一个方法, 该方法属于该结构体

class Person2 {

r5.show()

        self.age = age

 

    init(width:Double, height:Double)

    var width:Double

}

    var height:Double = 0.0

{

 */

/** 结构体与构造方法 **/

struct Rect3 {

 

 */

print(p.age)

 如果结构体中的所有属性都有默认值, 可以调用()构造一个结构体实例

    }

 结构体:

/** 带有参数的构造方法 **/

 

        return 100

 赋值有两种情况

var p3 = Person3(age: 30, name: "jq")

// 错误写法2: 必须包含所有成员

    //2.self只有当所有的存储属性都初始化完毕之后才可以用.

r5.show()

    var car:Car?

 

    class func getValue2() ->Int {

/*

    }

 结构体属性和方法

 3.构造方法是隐式调用的, 通过 类名称() 形成创建一个对象就会隐式调用 init() 构造方法;

// 错误写法1: 顺序必须和结构体中成员的顺序一致

 如果需要经过计算, 或者需要进行一些额外的操作才能确定初始值时就可以通过闭包或全局函数设置存储属性的缺省值

 

 语法:

 5.如果存储属性可以提供缺省, 那么提倡大家使用设置缺省值的方法, 这样可以简化代码(不用自定义构造方法, 不用写存储属性类型)

}

    /*

    init(age:Int, name:String)

    //2.也就是说可选值在对象构造完毕后不用初始化;

//    var age3:Int = Person5.getValue3()

}

    var age3:Int = Person5.getValue2()

    func setName(name:String, age:Int)

p2.setName(name: "hjq", age: 30)

    {

    var age2:Int = getValue()

    {

 "值类型"的构造器代理

    

    init() {

        self.name = name

    var name: String = "hjq"

        return "name = (name) age = (age)"

 

struct Rect2 {

}

//    var age: Int = 20

    }()

    //系统在初始化的时候会隐式执行闭包, 将闭包的执行结果赋值给存储属性

    {

    }

    func getValue3() -> Int {

}

    

 */

 

    func show()

 

 

/*

    let name:String

        age = 30

        self.width = width

 */

    //3.其实如果不对可选存储属性进行初始化, 默认就是nil

 作用: 对实例对象的内容进行初始化

    init(name:String) {

    func description() -> String {

        return 180.0

    init()

 

    }

    

 构造器代理: 构造方法之间的相互调用

    func description() -> String {

        return 30

p2.setName(name: "hjq", age: 23)

        self.age = age

        self.height = height

    print("getValue")

        return "name = (name) age = (age)"

print("================================")

    init(name:String)

        self.age = age

 

 

    var age:Int

    //1.不能这么写, 因为调用方法时对象还没有初始化完毕;

 

 Swift要求类或者结构体中的存储属性(非lazy在)在对象构造完毕后要有初始化值

    var height:Double = 0.0

    //此时既没有提供缺省值, 也没有提供构造方法, 但是编译通过

    var name:String = "hjq"

// 3.如果给存储属性提供了缺省值, 系统还是会提供默认的逐一构造器

 init(参数列表){ 初始化代码 }

var p = Person()

        return 99

 注意: 1.在Swift中类/结果提/枚举都需要构造方法;

//p3.name = "hello" //常量存储属性初始化之后不允许被修改! 虽没报错,但是不允许,这一点在后面开发中挖掘验证!

    func description() -> String {

        self.init(width: 0, height: 0)

        self.name = name

 */

    //1.构造方法的内部参数, 默认也是外部参数;

r2.show()

    var width:Double = 0.0

    //4.构造方法对属性的顺序没有要求, 只要保证对象构造完时所有存储属性被初始化即可.

    {

    }

    }

 

    }

      print("lzay 闭包")

 

 

        self.name = name

    return 55

    //2.而函数的内部参数默认不会当做外部参数;

 

    init(age:Int, name:String)

/** 可选属性与构造方法 **/

    }

    

// 2.如果在结构体中自定义了构造方法, 那么系统不会生成默认的逐一构造器

 构造方法:

// 1.分配内存; 2.初始化name和age; 3.构造方法是隐式调用的

 

 

        self.age = age

       print("age 闭包")

var p5 = Person5(name: "hjq")

print(p2.description())

// 注意: 1.在类中默认是没有逐一构造器的

}

    lazy var height:Double = {

    var age:Int = {

print("================================")

    }

var p2 = Person2(age: 25, name: "hjq")

    }

func getValue() ->Int

        self.name = name

var descripString: String = p.description() //显示调用

 构造方法可以调用其他构造方法来完成实例的构造, 称之为构造器代理

    //因为默认情况下, 结构体会给结构体提供一个默认的成员逐一构造器

    }()

    {

 

struct Rect {

 */

var r = Rect()

/*

    }

}

        print("class getValue2")

本文由时时app平台注册网站发布于编程知识,转载请注明出处:构造方法 (1)

关键词: