构造方法,析构方法

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

/*

/*

/*

/*

 析构方法:

 析构方法:

 承继与构造方法:

构造方法,析构方法。 承继与构造方法:

 对象的内部存款和储蓄器被回收前被隐式调用的情势, 对应OC的dealloc方法

 对象的内部存款和储蓄器被回收前被隐式调用的点子, 对应OC的dealloc方法

 钦赐构造与便利构造器方法

 钦赐构造与便利构造器方法

 主要实践一些外加操作, 比如自由部分存有能源, 关闭文件, 断开互连网等

 首要实施一些外加操作, 举个例子自由部分具备财富, 关闭文件, 断开互连网等

 */

 */

 */

 */

 

 

class FileHandle {

class FileHandle {

class Person {

class Person {

    var fd:Int3贰? // 文件讲述符

    var fd:Int3贰? // 文件讲述符

    var name:String

    var name:String

    //内定构造器

    //钦点构造器

    var age:Int

    var age:Int

    init(path:String) {

    init(path:String) {

    //内定构造方法都以以init初始

    //钦命构造方法都以以init开始

        //供给开发的文本路线, 展开药情势(只读)

        //必要开采的文书路线, 打开药格局(只读)

    init(name:String, age:Int)

    init(name:String, age:Int)

        //open方法是UNIX的方法

        //open方法是UNIX的方法

    {

    {

        let ret = open(path, O_RDONLY)

        let ret = open(path, O_RDONLY)

        self.name = name

        self.name = name

        if ret == -1 {

        if ret == -1 {

        self.age = age

        self.age = age

            fd = nil

            fd = nil

    }

    }

        }else{

        }else{

    //1.倘若是值类型没难点, 称之为构造器代理;

    //一.假使是值类型没难题, 称之为构造器代理;

            fd = ret

            fd = ret

    //二.不过倘若是引用类型报错, 需求在后面加上 convenience关键字;

    //2.可是若是是援引类型报错, 需求在眼下加上 convenience关键字;

        }

        }

    //三.被convenience关键字修饰的构造方法称之为便利构造器,
通过调用别的构造方法来早先化;

    //三.被convenience关键字修饰的构造方法称之为便利构造器,
通过调用其余构造方法来起初化;

        print(“对象被创制”)

        print(“对象被创设”)

    //四.反来说之, 便利构造器中势必是调用别的构造方法开始化的,
一定要出新self.init

    //4.反来说之, 便利构造器中一定是调用其余构造方法起始化的,
一定要出新self.init

    }

    }

    convenience init()

    convenience init()

    //析构方法

    //析构方法

    {

    {

    deinit {

    deinit {

        self.init(name: “hjq”, age: 26)

        self.init(name: “hjq”, age: 26)

        //关闭文件

        //关闭文件

    }

    }

        if let ofd = fd {

        if let ofd = fd {

    //类能够具有几个构造方法

    //类能够具有七个构造方法

            close(ofd)

            close(ofd)

    init(name:String)

    init(name:String)

        }

        }

    {

    {

        print(“对象被销毁”)

        print(“对象被销毁”)

        self.name = name

        self.name = name

    }

    }

        self.age = 0

        self.age = 0

}

}

        //不能够再钦定构造方法中调用便利构造器方法

        //无法再钦赐构造方法中调用便利构造器方法

var fh:FileHandle? = FileHandle(path:
“/Users/hanjunqiang/Desktop/Study伊芙ryDay/H5/第1阶段/随笔.html”)
//测试地址, 换到你和谐路线地址文件就能够

var fh:FileHandle? = FileHandle(path:
“/Users/hanjunqiang/Desktop/Study伊芙ryDay/H5/第一阶段/小说.html”)
//测试地址, 换来你自个儿路线地址文件就能够

        //换言之,内定构造方法中不能够冒出self.init

        //换言之,内定构造方法中不能够冒出self.init

fh = nil

fh = nil

//        self.init()

//        self.init()

 

 

    }

    }

 

 

    

    

/*

/*

    convenience init(age:Int)

    convenience init(age:Int)

 析构方法的自发性接二连三

 析构方法的机动一连

    {

    {

 父类的析构方法会被自动调用, 不供给子类管理

 父类的析构方法会被活动调用, 不须要子类管理

        //能够在便利构造器中调用内定构造器

        //能够在便利构造器中调用钦命构造器

 */

 */

//        self.init(name: “hjq”, age: 24)

//        self.init(name: “hjq”, age: 24)

class Person {

class Person {

        self.init()

        self.init()

    var name:String

    var name:String

    }

    }

    init(name:String) {

    init(name:String) {

    // 便利构造器不可能和钦定构造器同名

    // 便利构造器不可能和点名构造器同名

        self.name = name

        self.name = name

    //    convenience init(name:String)

    //    convenience init(name:String)

        print(“Person init”)

        print(“Person init”)

    //    {

    //    {

    }

    }

    //    }

    //    }

    deinit {

    deinit {

}

}

        print(“Person deinit”)

        print(“Person deinit”)

 

 

    }

    }

 

 

}

}

/** 派生类的构造方法 **/

/** 派生类的构造方法 **/

 

 

 

 

class SuperMan: Person {

class SuperMan: Person {

class Man {

class Man {

    var age:Int

    var age:Int

    var name:String

    var name:String

    init(age:Int) {

    init(age:Int) {

    //钦定构造方法

    //内定构造方法

        self.age = age

        self.age = age

    init(name:String)

    init(name:String)

        super.init(name: “hjq”)

        super.init(name: “hjq”)

    {

    {

    }

    }

        self.name = name

        self.name = name

    deinit {

    deinit {

    }

    }

        //假设父类的析构方法不会被活动调用, 那么大家还索要关切父类

        //假诺父类的析构方法不会被机关调用, 那么大家还亟需关爱父类

    convenience init(){

    convenience init(){

        //但是一旦如此做对子类是相当苦逼的

        //可是若是如此做对子类是相当苦逼的

        self.init(name: “hjq”)

        self.init(name: “hjq”)

        print(“SuperMan deinit”)

        print(“SuperMan deinit”)

    }

    }

    }

    }

}

}

}

}

class SuperMan: Man {

class SuperMan: Man {

var sm:SuperMan? = SuperMan(age: 25)

var sm:SuperMan? = SuperMan(age: 25)

    var age:Int

    var age:Int

sm = nil

sm = nil

    

    

 

 

    // 注意:

    // 注意:

    // 一.暗中认可境况下构造方法不会被再而三

    // 壹.暗许意况下构造方法不会被接续

    // 二.基类的累积属性只好通过基类的构造方法初步化

    // 二.基类的积攒属性只可以通过基类的构造方法开端化

    // 叁.伊始化存款和储蓄属性时务必先开始化当前类再开端化父类

    // 三.伊始化存款和储蓄属性时必须先开端化当前类再起先化父类

    // 四.不能够经过有利于构造方法起先化父类,
只可以经过调用钦命构造方法初叶化父类

    // 四.不能通过有利于构造方法初始化父类,
只可以经过调用内定构造方法初步化父类

    //钦赐构造器

    //钦命构造器

    init(age:Int) {

    init(age:Int) {

        self.age = age

        self.age = age

        super.init(name: “han”)

        super.init(name: “han”)

//        super.init()

//        super.init()

    }

    }

}

}

 

 

/*

/*

 构造器间的调用规则:

 构造器间的调用规则:

 一.钦点构造器必须调用其平素父类的”钦点构造器”

 一.钦赐构造器必须调用其直接父类的”钦命构造器”

 二.便利构造器必须调用同类中的别的便利构造器(内定大概福利)

 贰.便利构造器必须调用同类中的其余便利构造器(钦命也许福利)

 三.便利构造器必须最后调用3个点名构造器结束(无论钦命依然有益于,
最后必将调用二个点名构造器)

 3.便利构造器必须最终调用1个钦赐构造器截止(无论钦命仍旧有利于,
最后分明调用一个点名构造器)

 肆.内定构造器总是横向代理(父类)

 4.钦定构造器总是横向代理(父类)

 5.便利构造器总是横向代理(子类)

 伍.便利构造器总是横向代理(子类)

 */

 */

 

 

class Man2 {

class Man2 {

    var name:String

    var name:String

    //钦定构造器

    //钦赐构造器

    init(name:String) {

    init(name:String) {

        self.name = name

        self.name = name

    }

    }

    convenience init(){

    convenience init(){

        self.init(name: “HaRi”)

        self.init(name: “HaRi”)

    }

    }

}

}

class SuperMan2: Man2 {

class SuperMan2: Man2 {

    var age:Int

    var age:Int

    //钦定构造器

    //内定构造器

    init(age:Int) {

    init(age:Int) {

        self.age = age

        self.age = age

        super.init(name: “xiaohange”)

        super.init(name: “xiaohange”)

    }

    }

    convenience init()

    convenience init()

    {

    {

        self.init(age: 25)

        self.init(age: 25)

    }

    }

    convenience  init(name: String, age: Int) {

    convenience  init(name: String, age: Int) {

        //调用子类构造器一定能够起初化全部属性

        //调用子类构造器一定能够起先化所有属性

//        self.init(age: 30)

//        self.init(age: 30)

        //便利构造器中只好透过self.init来开头化, 无法选择 super.init

        //便利构造器中只可以经过self.init来伊始化, 不可能选取 super.init

        //因为调用父类构造器不明确完全开头化全部属性(子类持有)

        //因为调用父类构造器不必然完全初始化全部属性(子类持有)

//        super.init(name: “han”)

//        super.init(name: “han”)

        self.init()

        self.init()

    }

    }

}

}

 

 

/*

/*

 两段式构造—-构造进程能够分开为多少个等第:

 两段式构造—-构造进度能够划分为四个等级:

 壹.承接保险当前类和父类全部存款和储蓄属性都被发轫化;

 1.保险当前类和父类全部存储属性都被起头化;

 二.做一些任何伊始化操作.

 2.做一些其余早先化操作.

 好处:

 好处:

 一.可防止卫属性在被开首化前走访;

 一.足避防备属性在被初阶化前走访;

 2.得以幸免属性被其余别的二个组织器意外赋值.

 二.能够幸免属性被其余别的3个构造器意外赋值.

 注意:

 注意:

 构造器的开头化长久是在全部类的率先品级起先化完成后才会初始第一阶段.

 构造器的初始化永久是在全数类的第3阶段初阶化达成后才会起先第3阶段.

 

 

 编写翻译器安检:

 编写翻译器安检:

 一.必须先起先化子类特有总体性, 再发展代理父类钦赐构造方法初阶化父类属性;

 一.亟须先早先化子类特有总体性, 再升高代理父类内定构造方法开始化父类属性;

 2.只幸而调用完父类钦命构造器后才具访问父类属性;

 二.只可以在调用完父类钦赐构造器后才干访问父类属性;

 三.在便利构造器中, 必须先调用通类别的构造方法后本事访问属性;

 叁.在便利构造器中, 必须先调用通类其余构造方法后技能访问属性;

 四.首先等第达成前不可能访问父类属性, 也不可能引用 self 和调用任何实例方法

 4.首先品级完毕前无法访问父类属性, 也不能够引用 self 和调用任何实例方法

 */

 */

 

 

class Man3 {

class Man3 {

    var name:String

    var name:String

    //钦定构造方法

    //钦赐构造方法

    init(name:String) {

    init(name:String) {

        self.name = name

        self.name = name

    }

    }

    //便利构造方法

    //便利构造方法

    convenience init(){

    convenience init(){

        self.init(name: “hello world”)

        self.init(name: “hello world”)

    }

    }

}

}

 

 

class SuperMan3: Man3 {

class SuperMan3: Man3 {

    var age:Int

    var age:Int

    init(age:Int) {

    init(age:Int) {

        print(“SuperMan第3阶段开首”)

        print(“SuperMan第1阶段初步”)

        //对子类引入的习性开首化

        //对子类引进的品质开首化

        self.age = age

        self.age = age

        

        

        //代码会报错, 因为调用self.name在此之前还并未有对父类的name实行伊始化

        //代码会报错, 因为调用self.name此前还未曾对父类的name进行开首化

        //固然在那么些地点修改, 也会被后边的开首化语句覆盖

        //就算在那个地方修改, 也会被前面的开头化语句覆盖

//        if age > 30 {

//        if age > 30 {

//            self.name = “hjq”

//            self.name = “hjq”

//        }

//        }

        //对父类引进的性质实行早先化

        //对父类引入的属性举办开端化

        super.init(name: “han”)

        super.init(name: “han”)

        

        

        print(“SuperMan第二阶段起首”)

        print(“SuperMan第二阶段起头”)

        if age > 30 {

        if age > 30 {

            self.name = “hello xiaohange”

            self.name = “hello xiaohange”

        }

        }

    }

    }

}

}

class MonkeyMan: SuperMan3 {

class MonkeyMan: SuperMan3 {

    var height:Double

    var height:Double

    init(height:Double) {

    init(height:Double) {

        print(“MokeyMan第二阶段起始”)

        print(“MokeyMan第二阶段开端”)

        //对子类引进的性子起首化

        //对子类引进的质量早先化

        self.height = 100.0

        self.height = 100.0

        //对父类引进的天性举办开头化

        //对父类引进的性质举行开首化

        super.init(age: 40)

        super.init(age: 40)

        

        

        print(“MokeyMan第壹等第伊始”)

        print(“MokeyMan第三等第早先”)

        if height < 110.0 {

        if height < 110.0 {

            self.age = 40

            self.age = 40

        }

        }

    }

    }

}

}

var m = MonkeyMan(height: 31)

var m = MonkeyMan(height: 31)

 

 

 

 

/** 重写内定构造方法:子类的构造方法和父类的壹模一样 **/

/** 重写钦赐构造方法:子类的构造方法和父类的一模同样 **/

class Man4 {

class Man4 {

    var name:String

    var name:String

    init(name:String) {

    init(name:String) {

        self.name = name

        self.name = name

    }

    }

}

4858.com,}

class SuperMan4: Man4 {

class SuperMan4: Man4 {

    var age:Int

    var age:Int

    init() {

    init() {

        self.age = 25

        self.age = 25

        super.init(name: “xiaohange”)

        super.init(name: “xiaohange”)

    }

    }

    

    

    //将父类的钦命构造重视写成三个便利构造器, 必须抬高override关键字,
表示重写父类方法

    //将父类的钦赐构造器重写成1个有利于构造器, 必须抬高override关键字,
表示重写父类方法

    convenience override init(name: String) {

    convenience override init(name: String) {

        self.init(name: name)

        self.init(name: name)

        self.age = 50

        self.age = 50

    }

    }

}

}

 

 

 

 

/** 便利构造方法不设有重写 **/

/** 便利构造方法不设有重写 **/

class Man5 {

class Man5 {

    var name:String

    var name:String

    init(name:String) {

    init(name:String) {

        self.name = name

        self.name = name

    }

    }

    convenience init(){

    convenience init(){

        self.init(name:”hello”)

        self.init(name:”hello”)

    }

    }

}

}

 

 

class SuperMan5: Man5 {

class SuperMan5: Man5 {

    var age:Int

    var age:Int

    init(age:Int) {

    init(age:Int) {

        self.age = age

        self.age = age

        super.init(name: “hi”)

        super.init(name: “hi”)

    }

    }

    //一.Swift中有益构造方法不设有重写, 假诺加上override关键字,
系统会去搜求父类中有未有和便利构造方法同样的钦定构造方法, 有旧不报错,
未有就报错

    //壹.斯维夫特中有益构造方法不存在重写, 如果加上override关键字,
系统会去查究父类中有未有和惠及构造方法同样的内定构造方法, 有旧不报错,
未有就报错

    //贰.为啥便利构造器不可能重写啊? 因为便利构造器只好横向代理,
只好调用当前类的其余构造方法或指定方法, 不恐怕调用super. 所以不设有重写

    //二.为何便利构造器不可能重写吗? 因为便利构造器只能横向代理,
只可以调用当前类的别的构造方法或钦命方法, 不容许调用super. 所以不存在重写

    //三.也正是说子类的造福构造方法没办法直接待上访问父类的造福构造方法,
所以不设有重写的概念

    //叁.也正是说子类的便宜构造方法无法一直访问父类的方便人民群众构造方法,
所以不设有重写的定义

    convenience init(){

    convenience init(){

        self.init(age: 30)

        self.init(age: 30)

    }

    }

}

}

//早期版本中只要字符类中有同名便利构造器会报错, 现在则不会.

//早期版本中一经字符类中有同名便利构造器会报错, 今后则不会.

var sm = SuperMan5()

var sm = SuperMan5()

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

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

 

 

 

 

 

 

/*

/*

 构造方法的机关一连:

 构造方法的自行延续:

 一.如若子类中并未有概念构造器, 且子类全部的仓储属性都有缺省值,
会承接父类中存有的构造方法(包涵便利构造器);

 一.壹旦子类中从未定义构造器, 且子类全部的囤积属性都有缺省值,
会承继父类中享有的构造方法(蕴含便利构造器);

 2.即便子类中只是重写所有的钦点构造器, 不管仲类中的存款和储蓄属性是还是不是有缺省值,
都不会一而再父类的其它构造方法;

 2.如果子类中只是重写全部的钦命构造器, 不管敬仲类中的存款和储蓄属性是还是不是有缺省值,
都不会持续父类的别样构造方法;

 三.假如子类重写了父类中的钦点构造器, 不管仲类中的存款和储蓄属性是或不是有缺省值,
都会同时继续父类中的全数方便人民群众方法.

 三.如若子类重写了父类中的钦命构造器, 不管仲类中的存款和储蓄属性是还是不是有缺省值,
都会同时继续父类中的全体方便人民群众方法.

 */

 */

class Person6 {

class Person6 {

    var name:String

    var name:String

    var age:Int

    var age:Int

    init(name:String, age:Int) {

    init(name:String, age:Int) {

        self.name = name

        self.name = name

        self.age = age

        self.age = age

    }

    }

    init(name:String) {

    init(name:String) {

        self.name = name

        self.name = name

        self.age = 0

        self.age = 0

    }

    }

    convenience init()

    convenience init()

    {

    {

        self.init(name: “HaRi”)

        self.init(name: “HaRi”)

    }

    }

}

}

class SuperMan6: Person6 {

class SuperMan6: Person6 {

    var height:Double

    var height:Double

    init(height:Double) {

    init(height:Double) {

        self.height = height

        self.height = height

        super.init(name: “han”, age: 25)

        super.init(name: “han”, age: 25)

    }

    }

    override init(name: String, age: Int) {

    override init(name: String, age: Int) {

        self.height = 178.0

        self.height = 178.0

        super.init(name: name, age: age)

        super.init(name: name, age: age)

    }

    }

    override init(name: String) {

    override init(name: String) {

        self.height = 178.0

        self.height = 178.0

        super.init(name: name)

        super.init(name: name)

    }

    }

}

}

// 假诺子类中从未定义任何构造器, 且子类中具备的囤积属性都有缺省值,
会承袭父类中享有的构造方法(包含便利构造器)

// 假如子类中从不定义任何构造器, 且子类中有所的贮存属性都有缺省值,
会承继父类中有着的构造方法(包蕴便利构造器)

// 父类的蕴藏属性是由父类的构造器初阶化,
子类的积存属性是由缺省值开端化的

// 父类的积攒属性是由父类的构造器开端化,
子类的囤积属性是由缺省值开头化的

//var sm = SuperMan6(name: “han”, age: 30)

//var sm = SuperMan6(name: “han”, age: 30)

//var sm = SuperMan6(name: “hjq”)

//var sm = SuperMan6(name: “hjq”)

//var sm = SuperMan6()

//var sm = SuperMan6()

//print(sm.height)

//print(sm.height)

 

 

// 假如子类中只是重写了父类中的有个别钦点构造器,
不管仲类中的存款和储蓄属性是还是不是有缺省值, 都不会持续父类中的其余构造方法

// 假若子类中只是重写了父类中的有些钦定构造器,
不管敬仲类中的存款和储蓄属性是不是有缺省值, 都不会继续父类中的别的构造方法

//var sm = SuperMan(height: 198.0)

//var sm = SuperMan(height: 198.0)

 

 

// 若是子类重写了父类中享有的钦赐构造器,
不管敬仲类中的存款和储蓄属性是还是不是有缺省值, 都会同时继续父类中的全数方便人民群众方法

// 假使子类重写了父类中装有的内定构造器,
不管仲类中的存款和储蓄属性是不是有缺省值, 都会同时继续父类中的全体方便人民群众方法

var sm6 = SuperMan6()

var sm6 = SuperMan6()

 

 

 

 

 

 

/*

/*

 必须构造器:

 必须构造器:

 只要在构造方法的先头加上一个 required 关键字,
那么拥有的子类(后续子类)只要定义了构造方法都不能够不贯彻该构造方法

 只要在构造方法的前方加上二个 required 关键字,
那么全部的子类(后续子类)只要定义了构造方法都必须兑现该构造方法

 */

 */

class Person7 {

class Person7 {

    var name:String

    var name:String

    required init(name:String){

    required init(name:String){

        self.name = name

        self.name = name

    }

    }

}

}

class SuperMan7: Person7 {

class SuperMan7: Person7 {

    var age:Int

    var age:Int

    init() {

    init() {

        self.age = 24

        self.age = 24

        super.init(name: “hjq”)

        super.init(name: “hjq”)

    }

    }

    required init(name: String) {

    required init(name: String) {

        self.age = 24

        self.age = 24

        super.init(name: name)

        super.init(name: name)

    }

    }

}

}

var sm7 = SuperMan7(name: “hjq”)

var sm7 = SuperMan7(name: “hjq”)

 

 

发表评论

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

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