构造方法,相关语法进阶

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

/*

/*

//

/*

 构造方法:

 构造方法:

//  main.swift

 承接与构造方法:

 

 

//  Swift_Other

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

 效用: 对实例对象的始末张开开首化

 效能: 对实例对象的始末打开先导化

//

 */

 斯威夫特供给类可能结构体中的存款和储蓄属性(非lazy在)在目标组织完结后要有初阶化值

 Swift供给类只怕结构体中的存款和储蓄属性(非lazy在)在目的组织落成后要有开始化值

//  Created by 齐彦坤 on 2017/7/21.

 

 

 

//  Copyright © 2017年 KG. All rights reserved.

class Person {

 语法:

 语法:

//

    var name:String

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

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

 

    var age:Int

 

 

// 二.三 与 3.0 迁移相比

    //内定构造方法都以以init先河

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

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

import Foundation

    init(name:String, age:Int)

 2.构造办法的意义只是是措辞先河化属性, 而不是分配内容,
分配内部存储器是系统帮大家做的;

 贰.构造办法的成效只是是措辞开首化属性, 而不是分配内容,
分配内部存款和储蓄器是系统帮大家做的;

 

    {

 3.构造方法是隐式调用的, 通过 类名称() 造成创造二个目的就会隐式调用
init() 构造方法;

 3.构造方法是隐式调用的, 通过 类名称() 产生成立2个目的就会隐式调用
init() 构造方法;

// Swift 与 Objective-C 中的 nil

        self.name = name

构造方法,相关语法进阶。 肆.万一具备的积累属性都有暗中认可值, 能够不提供构造方法,
系统会提供2个隐式的构造方法;

 四.就算持有的积存属性都有暗中认可值, 能够不提供构造方法,
系统会提供三个隐式的构造方法;

// Swift 使用 nil 代表 <#值缺失#>

        self.age = age

 5.假使存款和储蓄属性能够提供缺省, 那么提倡我们利用安装缺省值的章程,
这样能够简化代码(不用自定义构造方法, 不用写存款和储蓄属性类型)

 5.要是存款和储蓄属性能够提供缺省, 那么提倡我们使用安装缺省值的措施,
那样可以简化代码(不用自定义构造方法, 不用写存款和储蓄属性类型)

// Swift 中 nil与 Objective-C 中的 nil 完全两样, 在 Objective-C 中, nil
代表贰个并不次混在的指针对象, 而在 Swift中并不代表指针而是二个规定的值——-他是三个规定的值, 用于代表”值缺失”,
任何 <#可选类型#> 的变量都得以呗赋值为 nil, 如 Int?, Double?
等都足以承受 nil 值.

    }

 */

 */

//  can not recieve nil

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

 

 

// Var age: Int = nil

    //二.然则要是是援引类型报错, 须要在前方加上 convenience关键字;

class Person {

class Person {

// Int? 类型的才得以承受 nil

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

    var name: String = “hjq”

    var name: String = “hjq”

// var age: Int? = nil

    //四.反来讲之, 便利构造器中自然是调用别样构造方法开头化的,
一定要出现self.init

//    var age: Int = 20

//    var age: Int = 20

// var myName : String?

    convenience init()

    var age:Int

    var age:Int

// print(myName ?? “”)

    {

    func description() -> String {

    func description() -> String {

 

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

        return “name = \(name) age = \(age)”

        return “name = \(name) age = \(age)”

var name_prefix = “123456”

    }

    }

    }

var info = name_prefix + “789”

    //类能够享有多少个构造方法

    init() {

    init() {

print(info)

    init(name:String)

        print(“init”)

        print(“init”)

name_prefix.removeAll(keepingCapacity: false) // storge and string —
> falses (released) /  true (NoReleased)

    {

        age = 30

        age = 30

 

        self.name = name

    }

    }

var diamond : Character = “\u{2666}”

        self.age = 0

}

}

var heart : Character = “\u{2663}”

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

// 1.分配内部存款和储蓄器; 2.初叶化name和age; 三.构造方法是隐式调用的

// 一.分配内存; 二.开始化name和age; 三.构造方法是隐式调用的

var club : Character = “\u{2665}”

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

var p = Person()

var p = Person()

var spade : Character = “\u{2660}”

//        self.init()

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

var descripString: String = p.description() //展现调用

print(“\(diamond) \(heart) \(club) \(spade)”) // ♦ ♣ ♥ ♠

    }

print(p.age)

print(p.age)

 

    

 

 

// \n — \u{a}

    convenience init(age:Int)

print(“================================”)

print(“================================”)

 

    {

 

 

 

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

 

 

// 七.六 属性观望者

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

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

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

// willSet(newValue): 被观察的特性将要被赋值从前自动调用该办法

        self.init()

class Person2 {

class Person2 {

// didSet(oldValue):  被调查的特性就要被赋值达成之后自动调用该措施

    }

    var name:String

    var name:String

// 只要程序对非延迟存款和储蓄的积存属性赋值 — 就算所赋的值与原值相等,
属性观看者也能监听到

    // 便利构造器无法和钦命构造器同名

    var age:Int

    var age:Int

 

    //    convenience init(name:String)

    func description() -> String {

    func description() -> String {

// 属性旁观者监听的界定

    //    {

        return “name = \(name) age = \(age)”

        return “name = \(name) age = \(age)”

// 一. 除了延迟属性之外的享有存储属性

    //    }

    }

    }

// 二. 方可由此重载的点子为一而再获得的习性增加属性观看者

}

    //一.构造方法的内部参数, 暗许也是表面参数;

    //1.构造方法的内部参数, 私下认可也是外表参数;

// 叁. 平时的性情加多属性观望者是从未有过意义的

 

    //二.而函数的内部参数暗中认可不会作为外部参数;

    //二.而函数的里边参数暗许不会作为外部参数;

/*

 

    //3.而艺术的里边参数, 从第一个开头才会作为外部参数;

    //三.而艺术的里边参数, 从第二个起来才会作为外部参数;

// 格式如下

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

    //四.构造方法对品质的次第没有要求,
只要保障对象组织完时全部存款和储蓄属性被起初化就可以.

    //四.构造方法对品质的种种未有需要,
只要保险对象协会完时全数存款和储蓄属性被伊始化就能够.

[修饰符] var 存款和储蓄属性名: 属性类型 [= 初始值]

 

    init(age:Int, name:String)

    init(age:Int, name:String)

{

class Man {

    {

    {

    willSet

    var name:String

        self.name = name

        self.name = name

    {

    //钦点构造方法

        self.age = age

        self.age = age

        // 属性就要赋值以前的代码

    init(name:String)

    }

    }

    }

    {

    func setName(name:String, age:Int)

    func setName(name:String, age:Int)

    didSet

        self.name = name

    {

    {

    {

    }

        self.name = name

        self.name = name

        // 赋值实现之后的代码

    convenience init(){

        self.age = age

        self.age = age

    }

        self.init(name: “hjq”)

    }

    }

}

    }

}

}

*/

}

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

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

 

class SuperMan: Man {

p2.setName(name: “hjq”, age: 30)

p2.setName(name: “hjq”, age: 30)

class Person

    var age:Int

print(p2.description())

print(p2.description())

{

    

 

 

    var name : String = “”

    // 注意:

p2.setName(name: “hjq”, age: 23)

p2.setName(name: “hjq”, age: 23)

    {

    // 1.默认情况下构造方法不会被连续

print(p2.description())

print(p2.description())

        willSet

    // 2.基类的蕴藏属性只好通过基类的构造方法初步化

 

 

        {

    // 三.开始化存款和储蓄属性时务必先初始化当前类再早先化父类

print(“================================”)

print(“================================”)

            if (name as NSString).length > 6 || (name as
NSString).length < 2

    // 4.不能够通过方便人民群众构造方法开头化父类,
只好经过调用钦赐构造方法伊始化父类

 

 

            {

    //钦定构造器

/*

/*

                print(“no”)

    init(age:Int) {

 常量存款和储蓄属性与构造方法

 常量存款和储蓄属性与构造方法

            }else{

        self.age = age

 常量存储属性只好通过缺省值或在构造方法中被涂改, 其余任哪儿方都不可能修改

 常量存款和储蓄属性只可以通过缺省值或在构造方法中被涂改, 其余任哪里方都不可能修改

                print(“yes”)

        super.init(name: “han”)

 */

 */

            }

//        super.init()

class Person3 {

class Person3 {

        }

    }

    var name:String = “hjq”

    var name:String = “hjq”

        

}

    var age:Int

    var age:Int

        didSet

 

    init(age:Int, name:String)

    init(age:Int, name:String)

        {

/*

    {

    {

            print(“didSetName: \(name)”)

 构造器间的调用规则:

        self.name = name

        self.name = name

        }

 一.内定构造器必须调用其一贯父类的”钦赐构造器”

        self.age = age

        self.age = age

    }

 二.便利构造器必须调用同类中的别的便利构造器(钦命或许福利)

    }

    }

}

 三.便利构造器必须最后调用两个钦命构造器甘休(无论钦命依然方便,
最后必将调用2个钦点构造器)

    func description() -> String {

    func description() -> String {

 

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

        return “name = \(name) age = \(age)”

        return “name = \(name) age = \(age)”

var p = Person()

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

    }

    }

p.name = “小黄人”

 */

}

}

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

 

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

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

 

class Man2 {

print(p3.description())

print(p3.description())

// 七.7.陆 属性和格局的联结

    var name:String

//p3.name = “hello” //常量存款和储蓄属性初叶化之后不允许被修改!
虽没报错,可是不一样意,那一点在后边开拓中开采验证!

//p三.name = “hello” //常量存款和储蓄属性开端化之后分裂意被涂改!
虽没报错,但是不允许,那一点在末端开拓中挖潜验证!

// 全局函数

    //钦赐构造器

 

 

func factorial(n:Int) -> Int

    init(name:String) {

 

 

{

        self.name = name

print(“================================”)

print(“================================”)

    var result = 1

    }

 

 

    for idx in 1…n {

    convenience init(){

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

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

        result *= idx

        self.init(name: “HaRi”)

 

 

    }

    }

class Car {

class Car {

    return result

}

    let name:String

    let name:String

}

class SuperMan2: Man2 {

    init(name:String)

    init(name:String)

 

    var age:Int

    {

    {

struct SomeStruct

    //钦赐构造器

        self.name = name

        self.name = name

{

    init(age:Int) {

    }

    }

    // 将2个布闭包函数作为 info 存款和储蓄属性的开端值

        self.age = age

}

}

    var info:() -> Void = {

        super.init(name: “xiaohange”)

class Person4 {

class Person4 {

        print(“info 方法”)

    }

    let name:String

    let name:String

    }

    convenience init()

    var age:Int

    var age:Int

    // factorial全局函数作为 fact 存款和储蓄属性的初步值

    {

    var car:Car?

    var car:Car?

    static var fact:(Int) -> Int = factorial

        self.init(age: 25)

    

    

}

    }

    //壹.可选值存款和储蓄属性能够不再构造方法中开头化;

    //一.可选值存储属性能够不再构造方法中伊始化;

var sc = SomeStruct()

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

    //二.也正是说可选值在目的组织完结后不要开首化;

    //二.也正是说可选值在目的协会完成后不要开始化;

sc.info()

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

    //③.其实假设不对可选存款和储蓄属性举办起初化, 默许正是nil

    //三.其实如若不对可选存款和储蓄属性实行发轫化, 默许即是nil

sc.info = {

//        self.init(age: 30)

    init(age:Int, name:String)

    init(age:Int, name:String)

    print(“其它二个闭包”)

        //便利构造器中只可以通过self.init来开始化, 不可能使用 super.init

    {

    {

}

        //因为调用父类构造器不自然完全起头化全体属性(子类持有)

        self.age = age

        self.age = age

sc.info()

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

        self.name = name

        self.name = name

var n =  6

        self.init()

    }

    }

print(“\(n)的阶乘: \(SomeStruct.fact(6))”)

    }

    func description() -> String {

    func description() -> String {

 

}

        return “name = \(name) age = \(age)”

        return “name = \(name) age = \(age)”

// 7.8 下标

 

    }

    }

/*

/*

}

}

subscript(形参列表) -> 下表再次来到值

 两段式构造—-构造进度能够分开为七个阶段:

 

 

{

 一.承接保险当前类和父类全部存款和储蓄属性都被开端化;

 

 

    get

 二.做一些别样初始化操作.

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

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

    {

 好处:

struct Rect {

struct Rect {

        // getter 施行部分, 必须有重回值

 1.方可堤防属性在被开始化前走访;

    //此时既未有提供缺省值, 也尚未提供构造方法, 可是编写翻译通过

    //此时既未有提供缺省值, 也从没提供构造方法, 可是编写翻译通过

    }

 二.方可防卫属性被此外其余3个结构器意外赋值.

    //因为暗中认可情状下, 结构体会给结构体提供一个私下认可的分子相继构造器

    //因为私下认可景况下, 结构体会给结构体提供八个暗中同意的成员相继构造器

    

 注意:

    var width:Double = 0.0

    var width:Double = 0.0

    set

 构造器的初步化恒久是在全部类的率先品级初步化完成后才会起始第二阶段.

    var height:Double = 0.0

    var height:Double = 0.0

    {

 

    /*

    /*

        // setter 部分举办代码, 该部分不必然有重回值

 编写翻译器安检:

    // 系统默许会提供三个近似的措施

    // 系统暗中同意会提供二个接近的不二秘籍

    }

 壹.须求先初叶化子类特有质量, 再升华代理父类钦定构造方法早先化父类属性;

    init(width:Double, height:Double)

    init(width:Double, height:Double)

}

 二.只辛亏调用完父类内定构造器后技艺访问父类属性;

    {

    {

*/

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

        self.width = width

        self.width = width

 

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

        self.height = height

        self.height = height

struct FKRect

 */

    }

    }

{

 

    */

    */

    var x : Int

class Man3 {

    /*

    /*

    var y : Int

    var name:String

    init() {

    init() {

    var width : Int

    //钦赐构造方法

        self.width = 0.0

        self.width = 0.0

    var height : Int

    init(name:String) {

        self.height = 0.0

        self.height = 0.0

    subscript(idx : Int) -> Int

        self.name = name

    }

    }

    {

    }

    */

    */

        get

    //便利构造方法

}

}

        {

    convenience init(){

// 注意: 1.在类中默许是不曾各种构造器的

// 注意: 一.在类中私下认可是未曾各类构造器的

            switch(idx)

        self.init(name: “hello world”)

// 二.比方在结构体中自定义了构造方法, 那么系统不会扭转暗许的各样构造器

// 二.就算在结构体中自定义了构造方法, 那么系统不会变卦暗中认可的相继构造器

            {

    }

// 叁.一旦给存款和储蓄属性提供了缺省值, 系统可能会提供暗中认可的依次构造器

// 三.比如给存储属性提供了缺省值, 系统或许会提供默许的各种构造器

                case 0:

}

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

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

                    return self.x

 

// 四.倘诺给存款和储蓄属性提供了缺省值, 能够采纳不带参数的办法起初化结构体

// ④.壹旦给存款和储蓄属性提供了缺省值, 能够使用不带参数的措施早先化结构体

                case 1:

class SuperMan3: Man3 {

var r = Rect()

var r = Rect()

                    return self.y

    var age:Int

 

 

                case 2:

    init(age:Int) {

 

 

                    return self.width

        print(“SuperMan第二等级伊始”)

/*

/*

                case 3:

        //对子类引进的特性初叶化

 “值类型”的构造器代理

 “值类型”的构造器代理

                    return self.height

        self.age = age

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

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

                default:

        

 构造方法能够调用其余构造方法来成功实例的布局, 称之为构造器代理

 构造方法能够调用其他构造方法来成功实例的社团, 称之为构造器代理

                    print(“unSupport type”)

        //代码会报错, 因为调用self.name此前还不曾对父类的name举办开头化

 好处: 收缩构造方法之间的双重代码

 好处: 裁减构造方法之间的再一次代码

                    return 0

        //尽管在那几个地点修改, 也会被前边的开头化语句覆盖

 */

 */

            }

//        if age > 30 {

 

 

        }

//            self.name = “hjq”

struct Rect2 {

struct Rect2 {

        

//        }

    var width:Double, height:Double

    var width:Double, height:Double

        set

        //对父类引进的属性举行初步化

    init(width:Double, height:Double)

    init(width:Double, height:Double)

        {

        super.init(name: “han”)

    {

    {

            switch(idx)

        

        self.width = width

        self.width = width

            {

        print(“SuperMan第二阶段早先”)

        self.height = height

        self.height = height

                case 0:

        if age > 30 {

    }

    }

                    self.x = newValue

            self.name = “hello xiaohange”

    init()

    init()

                case 1:

        }

    {

    {

                    self.y = newValue

    }

//        self.width = 0.0

//        self.width = 0.0

                case 2:

}

//        self.height = 0.0

//        self.height = 0.0

                    self.width = newValue

class MonkeyMan: SuperMan3 {

        //构造器代理

        //构造器代理

                case 3:

    var height:Double

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

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

                    self.height = newValue

    init(height:Double) {

    }

    }

                default:

        print(“MokeyMan第叁等第开首”)

    func show()

    func show()

                    print(“unSupport type”)

        //对子类引进的习性初始化

    {

    {

            }

        self.height = 100.0

        print(“width = \(width) height = \(height)”)

        print(“width = \(width) height = \(height)”)

 

        //对父类引进的属性举办初阶化

    }

    }

        }

        super.init(age: 40)

}

}

    }

        

var r2 = Rect2()

var r2 = Rect2()

}

        print(“MokeyMan第1阶段初叶”)

r2.show()

r2.show()

 

        if height < 110.0 {

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

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

var rect = FKRect(x: 20, y: 12, width: 200, height: 300)

            self.age = 40

r3.show()

r3.show()

// 通过下表对 rect 的质量赋值

        }

 

 

rect[0] = 40

    }

 

 

rect[1] = 67

}

print(“================================”)

print(“================================”)

print(“rect 的 x 的坐标为: \(rect[0]), y 的坐标为 \(rect[1])”)

var m = MonkeyMan(height: 31)

 

 

 

 

 

 

// 7.9 可选链

 

/*

/*

 

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

 通过闭包只怕全局函数/类方式 设置存款和储蓄属性的缺省值

 通过闭包或许全局函数/类措施 设置存款和储蓄属性的缺省值

class Company

class Man4 {

 假如需求通过计量,
只怕要求打开一些额外的操作才具鲜明开头值时就足以由此闭包或全局函数设置存款和储蓄属性的缺省值

 借使要求通过总结,
或然供给开展局地杰出的操作手艺明确开端值时就能够透过闭包或全局函数设置存款和储蓄属性的缺省值

{

    var name:String

 */

 */

    var name = “crazy”

    init(name:String) {

 

 

    var addr = “home”

        self.name = name

func getValue() ->Int

func getValue() ->Int

    init(name : String, addr : String)

    }

{

{

    {

}

    print(“getValue”)

    print(“getValue”)

        self.name = name

class SuperMan4: Man4 {

    return 55

    return 55

        self.addr = addr

    var age:Int

}

}

    }

    init() {

class Person5 {

class Person5 {

}

        self.age = 25

    var name:String

    var name:String

 

        super.init(name: “xiaohange”)

    

    

class Employee

    }

    //系统在初步化的时候会隐式试行闭包, 将闭包的施行结果赋值给存款和储蓄属性

    //系统在开始化的时候会隐式试行闭包, 将闭包的施行结果赋值给存款和储蓄属性

{

    

    //注意: 闭包前面鲜明要有(), 代表试行闭包

    //注意: 闭包后边必然要有(), 代表实施闭包

    var name = ” 白骨精”

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

    var age:Int = {

    var age:Int = {

    var title = “发售客服”

    convenience override init(name: String) {

        () -> Int in  // 这1行能够省略,
重回值是足以归纳的,暗中认可重临值的连串就是积累属性的体系

        () -> Int in  // 那壹行能够归纳,
重返值是能够大致的,私下认可重临值的品种正是累积属性的花色

    var company : Company!

        self.init(name: name)

       print(“age 闭包”)

       print(“age 闭包”)

    init(name : String, title : String)

        self.age = 50

        return 30

        return 30

    {

    }

    }()

    }()

        self.name = name

}

    

4858.com,    

        self.title = title

 

    lazy var height:Double = {

    lazy var height:Double = {

    }

 

      print(“lzay 闭包”)

      print(“lzay 闭包”)

}

/** 便利构造方法不存在重写 **/

        return 180.0

        return 180.0

 

class Man5 {

    }()

    }()

class Customer

    var name:String

    

    

{

    init(name:String) {

    var age2:Int = getValue()

    var age2:Int = getValue()

    var name = “”

        self.name = name

    var age3:Int = Person5.getValue2()

    var age3:Int = Person5.getValue2()

    var emp : Employee?

    }

    

    

    // “_” 撤消构造器参数的表面形参名

    convenience init(){

    //一.不能够如此写, 因为调用方法时对象还尚未初叶化落成;

    //1.不能这么写, 因为调用方法时对象还并未有起首化实现;

    init(_ name : String)

        self.init(name:”hello”)

    //贰.self唯有当有着的囤积属性都初步化完成之后才得以用.

    //贰.self唯有当有着的囤积属性都起头化完成之后才能够用.

    {

    }

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

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

        self.name = name

}

    

    

    }

 

    init(name:String) {

    init(name:String) {

    

class SuperMan5: Man5 {

        self.name = name

        self.name = name

}

    var age:Int

    }

    }

 

    init(age:Int) {

    class func getValue2() ->Int {

    class func getValue2() ->Int {

var  c3 = Customer(“唐僧”)

        self.age = age

        print(“class getValue2”)

        print(“class getValue2”)

//print(“为\(c③.name)服务的公司: \(String(describing:
c3.emp!.company?.name))”) // fatal error: unexpectedly found nil while
unwrapping an Optional value

        super.init(name: “hi”)

        return 100

        return 100

print(“为\(c3.name)服务的小卖部: \(String(describing:
c3.emp?.company?.name))”) // fatal error: unexpectedly found nil while
unwrapping an Optional value

    }

    }

    }

 

    //1.Swift中有益构造方法不设有重写, 如若加上override关键字,
系统会去寻觅父类中有没有和有利构造方法一样的内定构造方法, 有旧不报错,
没有就报错

    func getValue3() -> Int {

    func getValue3() -> Int {

// 7.1一.4 使用闭包后函数为属性设置开头值

    //2.为啥便利构造器不可能重写吗? 因为便利构造器只好横向代理,
只可以调用当前类的此外构造方法或内定方法, 不容许调用super. 所以不存在重写

        return 99

        return 99

// 用于作为存款和储蓄属性伊始值的函数或闭包的回到值类型必要与该属性的类型相称

    //3.也正是说子类的便宜构造方法不能够间接待上访问父类的便宜构造方法,
所以不设有重写的概念

    }

    }

struct closurenit

    convenience init(){

}

}

{

        self.init(age: 30)

var p5 = Person5(name: “hjq”)

var p5 = Person5(name: “hjq”)

    var test : Int = {

    }

//懒加载是用到才施行, 而闭包赋值是起头化时就会施行

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

        return 6

}

print(p5.height)

print(p5.height)

    }()

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

 

 

}

var sm = SuperMan5()

var ci = closurenit()

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

print(ci.test)

 

 

 

// 构造器

 

// 对于值类型, 斯威夫特 允许使用
self,init(实参)在自定义在构造器中调用其余重载的构造器,
而且只同意在构造器内部使用self.init(实参)

/*

struct Apple

 构造方法的自行再三再四:

{

 一.只要子类中从不定义构造器, 且子类全体的贮存属性都有缺省值,
会传承父类中有着的构造方法(包蕴便利构造器);

    var name : String

 ②.壹旦子类中只是重写全体的钦赐构造器, 不管敬仲类中的存款和储蓄属性是不是有缺省值,
都不会继续父类的别的构造方法;

    var color : String

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

    var weight : String!

 */

    

class Person6 {

    init(_ name : String, color  : String)

    var name:String

    {

    var age:Int

        self.name = name

    init(name:String, age:Int) {

        self.color = color

        self.name = name

    }

        self.age = age

    

    }

    init(name : String, color : String)

    init(name:String) {

    {

        self.name = name

//        name = “trmp” // 推行 self.init 以前,
不允许对人何以实例睡醒赋值, 也不容许访问任何其余实例属性, 不被允许采取self. 而2个构造器中不得不有一行 self.init(实参)

        self.age = 0

        self.init(name, color: color)

    }

    }

    convenience init()

    

    {

    init(name : String, color : String, weight : String)

        self.init(name: “HaRi”)

    {

    }

        self.init(name, color: color) // 构造器代理 –>
在构造器中调用别的构造器来推行协会的历程被誉为构造器代理

}

        self.weight = weight

class SuperMan6: Person6 {

    }

    var height:Double

}

    init(height:Double) {

 

        self.height = height

var ap1 = Apple(“红富士”, color: “粉红色”)

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

var ap2 = Apple(name: “青苹果”, color: “绿色”)

    }

var ap3 = Apple(name: “红苹果”, color: “红色”, weight: “1.0 kg”)

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

 

        self.height = 178.0

// 八.二 类的结构

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

// 八.二.一 便利构造器

    }

// 定义便利构造器必要早 init 前增多 convenience

    override init(name: String) {

// convenience init(形参) {  }

        self.height = 178.0

// 唯有类中才有构造器的概念, 结构体 / 枚举 不扶助便利构造器

        super.init(name: name)

class Apple_one

    }

{

}

    var name : String!

// 假诺子类中向来不定义任何构造器, 且子类中兼有的蕴藏属性都有缺省值,
会承袭父类中具有的构造方法(包涵便利构造器)

    var weight : Double

// 父类的蕴藏属性是由父类的组织器初阶化,
子类的积累属性是由缺省值起先化的

    // 定义内定构造器

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

    init(name : String, weight : Double) {

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

        self.name = name

//var sm = SuperMan6()

        self.weight = weight

//print(sm.height)

    }

 

    // 定义便利构造器

// 固然子类中只是重写了父类中的有些内定构造器,
不管敬仲类中的存款和储蓄属性是或不是有缺省值, 都不会持续父类中的其余构造方法

    convenience init(n name : String, w  weight  : Double)

//var sm = SuperMan(height: 198.0)

    {

 

        self.init(name : name, weight : weight)

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

        self.name = name

var sm6 = SuperMan6()

    }

 

}

 

var APP1 = Apple_one(n : “红富士”, w : 1.2)

 

var APP2 = Apple_one(name : “花牛果”, weight : 2.4)

/*

// 钦点的构造器总是必须进步代理(调用父类的构造器)

 必须构造器:

// 钦赐的构造器总是必须横向代理(调用当前类的其余构造器)

 只要在构造方法的目前加上三个 required 关键字,
那么富有的子类(后续子类)只要定义了构造方法都必须落成该构造方法

 

 */

// 安全检查

class Person7 {

// 一. 点名构造器必须先起首化当前类定义的实例存款和储蓄属性,
然后才能向上调用父类构造器

    var name:String

// 贰. 点名的构造器必须先向上调用父类构造器, 然后才干对两次三番赚取的性质赋值

    required init(name:String){

// 三. 便利构造器必须先调用1个类的别的构造器, 然后技术对质量赋值.

        self.name = name

// 肆. 构造器在率先品级落成从前, 不能够调用实例方法,
无法读取实例属性(建议为实例属性都钦点开端值)

    }

 

}

class Fruit {

class SuperMan7: Person7 {

    var name : String

    var age:Int

    init(name : String) {

    init() {

        self.name = name

        self.age = 24

    }

        super.init(name: “hjq”)

}

    }

class Apple_two : Fruit  {

    required init(name: String) {

    var color : String

        self.age = 24

    init(color : String) {

        super.init(name: name)

//        print(self.color) //
在初步化从前不可能利用本类定义的实例存款和储蓄属性, 编写翻译错误

    }

        self.color  = color

}

        print(self.color)

var sm7 = SuperMan7(name: “hjq”)

        self.color = “红色”

 

//        print(super.name) // 不可使用父类定义的实例存款和储蓄属性

        super.init(name: “花牛果”)

        print(super.name)

        super.name = “红富士”

    }

    convenience init(name: String, color : String) {

        // 安检 三

//        print(self.color)

//        super.name = name

        

        self.init(color: “红色”)

        self.name = name

    }

}

 

var a = Apple_two(color : “绿色”)

 

// 八.二.4 构造器的继续和重写

// 一. 1旦子类未有提供任何钦点构造器,
那么他将自动延续父类的具有钦点构造器及全部方便人民群众构造器

 

// 只要子类的构造珍视写了父类的钦赐的构造器, 则必须在子类构造器前增加override 修饰符, 即便构造器只是一个便宜构造器

 

// 8.二.伍 类与可能停业的构造器

// 条件:

// 一. 此类中的全部实例存款和储蓄属性都已被赋初叶值,  (就能够档期的顺序显著内定开头值,
也可有系统隐式分配暗中认可的起首值)

// 二. 持有的构造器都已被施行 (即: return nil 不可能放在 self.init(参数)或
super.init(参数)代码以前)

// 只怕倒闭的构造器可以调用同一个类中的普通构造器, 反过来则不能.,
但在类中得以调用支持隐式解析或然倒闭的结构器.

// 在结构体中. 普通的构造器却可以调用同一个结构体中或然倒闭的构造器

 

// 捌.2.八 之类必须带有的构造器

// required 关键字只是要求有所子类必须含有 required 构造器

// 重新父类的required的内定构造器, 无需增添 override

 

// 8.3

// is 与 as

// 在运用 is 运算符是亟需留意, is
运算符前边操作数的编写翻译时类型要么与后边的类一样,
要么与背后的类具备老爹和儿子承接关系, 否则会唤起编写翻译错误

// as  强制将运算符前边的引用变量转变为前面包车型地铁门类, 假使调换失利,
程序将促成运营时不当

// as? 可选形式的向下调换.
该运算符也希图将运算符前边的引用变量调换为前面包车型地铁类型.该运算符总再次来到已个可选值,
尽管抓换来功, 则可选值中包涵转变结果; 若是转换退步, 则可选值中带有 nil.

// 推荐用法

/*

if obi is NSString

{

    let str : NSString = obj as NSString

    

}

*/

// Any 和 AnyObject

// AnyObject: 可代表任何类的实例

// Any: 可代表任何项目, 包含 Int, Double 等值类型

 

// 八.四 嵌套类型

// 在先后外部使用嵌套类型时,则需求充分被嵌套类型前缀.

// 嵌套类型不容许利用 static 或 class 修饰, 嵌套类型未有所谓的
“类型相关的嵌套类型”

class User_nest

{

    var holiday: [weekDay]

    var location : Point

    init(holiday:[weekDay], location:Point) {

        self.holiday = holiday

        self.location = location

    }

    struct Point {

        var latitude : Double

        var longitude : Double

        var position : Orientation

        // 嵌套枚举

        enum Orientation {

            case Up, Left, Bottom, Right

        }

    }

    // 定义3个嵌套类型, 枚举 weekDay

    enum weekDay {

        case Monday, Tuesday, Wednesday, Thursday, Friday, Staturday,
Sunday

    }

}

 

var user_nest = User_nest(holiday: [], location:
User_nest.Point(latitude:-23.33, longitude: 122.11, position:
User_nest.Point.Orientation.Up))

user_nest.holiday.append(User_nest.weekDay.Monday)

 

// 8.5 扩展

/*

extension String {

    // add new function

}

*/

 

// 扩张不能够增加实例存款和储蓄属性

// 使用扩张增加方法

// 只是加多类型方法时要求在品种方法前增加 static 或 class
(为品种加多类型方法天机 class, 为枚举或结构体天机类型方法增多 static)

 

extension String

{

    func substringFromStart(start: Int, toEnd: Int) ->  String{

        var count = 0

        var tmp = “”

        for ch in self.characters

        {

            if count > start {

                tmp = “\(tmp)\(ch)”

            }

            if count > toEnd – 1 {

                break

            }

            count += 1

        }

        return tmp

    }

    static func valueOf(value: Bool) -> String

    {

        return “\(value)”

    }

}

 

var str = “fkit.originsfsfsfsf”

var subStr = str.substringFromStart(start: 2, toEnd: 10)

var length_1 = subStr.lengthOfBytes(using: String.Encoding.utf8)

var length_2 = (subStr as NSString).length

// 8

print(subStr)

print(String.valueOf(value: true))

 

// 扩大加多构造器

struct Some_Struct_other

{

    var name : String

    var count : Int

}

 

extension Some_Struct_other

{

    init(name:String)

    {

        self.name = name

        self.count = 0

    }

    init(count : Int) {

        self.name = “”

        self.count = count

    }

    

}

 

var sc1 = Some_Struct_other(name: “fsfsf”, count: 5)

var sc2 = Some_Struct_other(name: “adad”)

var sc3 = Some_Struct_other(count: 23)

 

// 使用扩扩张增加嵌套类型

extension String

{

    enum Suit : String {

        case Diamond = “方”

        case Club = “梅花”

        case Heart = “红桃”

        case Spade = “黑桃”

    }

    

    static func judgeSuit(s: String) -> Suit?

    {

        switch s {

        case “方”:

            return  .Diamond

        case “梅花”:

            return  .Club

        case “红桃”:

            return  .Heart

        case “黑桃”:

            return  .Spade

        default:

            return nil

        }

    }

}

 

var S_1: String.Suit? = String.judgeSuit(s: “方”)

var S_2: String.Suit? = String.judgeSuit(s: “J”)

print(S_1?.rawValue ?? “nil”)

print(S_2 ?? “nil”)

// 输出结果

// 方

// nil

 

// 8.6 协议

// class ; 该重大字可有可无. 假诺使用 class
关键字,则证实须求定义类型属性, 不然表明供给定义实例属性. 吃出不可用
ststic 代替 class

 

protocol Storkable

{

    var storkeWidth : Double{ get set }

}

 

protocol Fullable {

    var fullcolor : Color? { get set }

}

enum Color {

    case Red, Green, Blue, Yellow, Cyan

}

 

protocol HasArea : Fullable, Storkable {

    var area : Double {get}

}

 

protocol Mathable {

   static  var pi : Double {get}

   static  var e  : Double {get}

}

 

struct Rect : HasArea, Mathable {

    var width : Double

    var height :Double

    init(width : Double, height : Double) {

        self.width = width

        self.height = height

    }

    var  fullcolor: Color?

    var storkeWidth: Double = 0.0

    var area: Double

    {

        get

        {

            return width * height

        }

    }

    

    static var pi: Double = 3.1415926

    static var e: Double = 2.7118

}

 

class Circle : HasArea, Mathable

{

    var radius : Double

    init(radius : Double)

    {

        self.radius = radius

    }

    var  fullcolor: Color?

    var storkeWidth: Double = 0.0

    var area: Double

    {

        get

        {

            return Circle.pi * radius * radius

        }

    }

    

    static var pi: Double = 3.1415926

    static var e: Double = 2.7118

}

 

var rect_ = Rect(width: 4.5, height: 4.0)

print(rect_.area)

rect_.fullcolor = Color.Red

rect_.storkeWidth = 1.0

print(rect_.fullcolor ?? Color.Red, rect_.storkeWidth)

 

var circle = Circle(radius: 2.0)

circle.fullcolor = Color.Green

circle.storkeWidth = 0.5

print(circle.fullcolor ?? Color.Green, circle.storkeWidth)

// 协议钦点的方法必要

protocol Eatable

{

    // 实例方法

    func taste()

    // 类方法

    static func test (masgs : String…)

}

 

struct Pie : Eatable

{

    var weight : String

    func taste() {

        print(“\(weight) 饼干吃起来可口可脆”)

    }

    

    // 结构体使用 static 修饰类型方法

    static func test(masgs: String…) {

        print(“implement test method”)

        for msg in masgs {

            print(“\(msg)”)

        }

    }

}

 

class Apple_fruit : Eatable

{

    var name : String

    init(name: String) {

        self.name = name

    }

    func taste() {

        print(“\(name) 水分充足, 有养分”)

    }

    // 类使用 class 修饰类型方法

    class func test(masgs: String…) {

        print(“implement test method”)

        for msg in masgs {

            print(“\(msg)”)

        }

    }

}

 

Pie.test(masgs: “1”, “2”, “3”)

var pie = Pie(weight: “3.4”)

pie.taste()

 

Apple_fruit.test(masgs: “apple_1”, “apple_2”, “apple_3”)

var apple_fruit = Apple_fruit(name: “红富士”)

apple_fruit.taste()

 

// 捌.6.肆 协议钦命的可变方法须求

// “枚举 / 结构体” 中可变方法用 mutating 修饰, 而类中的可变方法则不加
mutating 修饰

 

// 八.6.5 协议钦点的下表须要

protocol Mathable_one

{

    subscript(idx : Int) -> Int {get}

    subscript(a:Int, b:Int) -> Int {get}

}

 

struct  /*(class)*/ Linear_Struct : Mathable_one

{

    var factor: Int

    subscript(idx: Int) -> Int

    {

        get {

            return factor * idx

        }

        

        set {

            print(“Linear_Struct 下表赋值”)

        }

    }

    subscript(a: Int, b: Int) -> Int {

        return factor * a + b

    }

}

 

var line = Linear_Struct(factor: 5)

print(line[4])

print(line[4, 6])

 

//  协议钦定的构造器必要

// 使用类落成协议, 并达成协议中的构造器方法时,必须利用 required
修饰该构造器, 除非该类应用的 final 修饰, 吃屎能够省略 , 也得以大约

// 重重写父类额方法时, 必须同时使用 required override 修饰

// 唯有类中贯彻协议构造器是才有此要求, 而枚举 / 结钩体中无此供给

 

// 协议的庞大

protocol Emptyable

{

    var isEmpty : Bool { get }

}

 

extension String : Emptyable {}

func foo(arg: Emptyable) {

 print(“arg 是或不是为空, \(arg.isEmpty)”)

}

 

foo(arg: “fkfkfk”)

foo(arg: “”)

 

// 8.陆.10 为类协议

protocol Moveable : class

{

    func move()

}

class Car : Moveable {

    func move() {

        print(“car is run….”)

    }

}

//   为类协议不协助结构体

//struct Car_one : Moveable {

//    func move() {

//        // ….

//    }

//}

 

// 输出实例与 CustomStringConvertible 协议 (Printable 被放弃了)

class Person_one : CustomStringConvertible

{

    var name : String

    var age : Int

    init(name: String, age : Int) {

        self.name = name

        self.age = age

    }

  

    var description: String {

        return “\(self.name), \(self.age)”

    }

    

    var debugDescription: String {

        return “\(self.name), \(self.age)”

    }

}

 

var person_one = Person_one(name: “sunwukong”, age: 1333)

print(person_one)

print(person_one.description)

print(person_one.debugDescription)

//sunwukong, 1333

//sunwukong, 1333

//sunwukong, 1333

 

// 捌.八.2 循环引用

class Studdent

{

    var name : String

    var age : Int

    // 使用可选属性关联的 Coach 实例

    var coach: Coach?

    init(name : String, age : Int) {

        self.name = name

        self.age = age

    }

    deinit {

        print(“\(self.name) deinit”)

    }

}

class  Coach

{

    var name :String

    var skill : String

    // 使用可选属性关联的 Student 实例,

//    var student : Studdent?  // 强引用

    weak var student : Studdent?  // 弱引用 // ①

//    unowned let student : Studdent  // 弱引用 // ②

 

    init(name: String, skill : String) {

        self.name = name

        self.skill = skill

    }

    deinit {

        print(“\(self.name) coach deinit”)

    }

}

 

var stu: Studdent? = Studdent(name: “sunwukong”, age: 13313)

var coach:Coach? = Coach(name: “tangshng”, skill: “44444”)

stu?.coach = coach

coach?.student = stu

stu = nil

coach = nil

 

// 8.捌.四 闭包的弱引用

class Studdent_func

{

    var name : String

    var age : Int

    lazy var stuInfo:() ->String = {

        // [weak | unowned] 消除闭包的强引用

        [weak self] in

        “\(self!.name), \(self!.age)”

        

    }

    

    init(name : String, age : Int) {

        self.name = name

        self.age = age

    }

    deinit {

        print(“\(self.name) deinit”)

    }

}

 

var stu_func : Studdent_func? = Studdent_func(name: “bajie”, age:
500)

var info__stu: (() -> String)? = stu_func!.stuInfo

stu_func = nil

info__stu = nil

 

 

//  第 9 章 泛型 (函数 / 结构体 / 类)

// 定义泛型函数

func copyArray <T> (src:[T], dest:inout [T])

{

    for  element in src {

        dest.append(element)

    }

}

var arr = [28, 2]

copyArray(src: [12, 5], dest: &arr)

print(arr)      // [28, 2, 12, 5]

 

var strArr = [“android”, “iOS”, “JAVA”]

copyArray(src: [“C”, “C#”], dest: &strArr)

print(strArr) // [“android”, “iOS”, “JAVA”, “C”, “C#”]

 

// 泛型类型

struct FK_Rect <T>

{

    var x : T

    var y : T

    var width : T

    var height : T

    var poston : (T, T){

        return (self.x, self.y)

    }

}

 

let rect_fk = FK_Rect(x: 1.2, y: 2.3, width: 8.4, height: 7.8)

let (x, y) = rect_fk.poston

print(“rect de 位置 \(x), \(y)”)

 

 

let rect_fk_2 = FK_Rect(x: 2, y: 3, width: 4, height: 5)

let (left, top) = rect_fk_2.poston

print(“rect de 位置 \(left), \(top)”)

 

class Apple_other<T>

{

    var info :  T

    init(info:T) {

        self.info = info

    }

}

 

var A1 = Apple_other<String>(info: “sfffss”)

print(“\(A1.info)”)

 

var A2 = Apple_other<Double>(info: 3.44)

print(“\(A2.info)”)

 

// 从泛型派生子类

class AAA<E> : Apple_other<String> {

    var name :String!

}

 

// 类型约束

func bubbleSort <T : Comparable> ( array : inout [T]) {

    // 参考 9.4

}

 

// 玖.五.1 关联类型

 

// 9.6 where 句子

 

发表评论

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

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