构造方法,相关语法进阶

/*

/*

//

/*

 构造方法:

 构造方法:

//  main.swift

 承继与构造方法:

 

 

//  Swift_Other

 内定构造与便利构造器方法

 效率: 对实例对象的剧情开始展览开首化

 功用: 对实例对象的内容进行开首化

//

 */

 Swift必要类可能结构体中的存款和储蓄属性(非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

 

 

// 二.叁 与 三.0 迁移相比

    //钦定构造方法都是以init发轫

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

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

import Foundation

    init(name:String, age:Int)

 2.构造主意的效益只是是措辞初阶化属性, 而不是分配内容,
分配内部存款和储蓄器是系统帮大家做的;

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

 

    {

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

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

// Swift 与 Objective-C 中的 nil

        self.name = name

 4.假诺持有的贮存属性都有暗许值, 可以不提供构造方法,
系统会提供3个隐式的构造方法;

 四.要是具有的储存属性都有暗许值, 能够不提供构造方法,
系统会提供二个隐式的构造方法;

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

        self.age = age

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

 伍.如若存款和储蓄属性能够提供缺省, 那么提倡大家利用安装缺省值的措施,
这样能够简化代码(不用自定义构造方法, 不用写存款和储蓄属性类型)

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

    }

 */

 */

//  can not recieve nil

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

 

 

// 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}”

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

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

// 1.分配内部存款和储蓄器; 二.起始化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.构造方法的个中参数, 默许也是表面参数;

// 三. 常见的属性增添属性旁观者是从未意思的

 

    //2.而函数的里边参数暗中同意不会作为外部参数;

    //二.而函数的中间参数默许不会作为外部参数;

/*

 

    //3.而艺术的当中参数, 从首个起来才会作为外部参数;

    //叁.而艺术的中间参数, 从第2个初叶才会作为外部参数;

// 格式如下

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

    //四.构造方法对品质的依次未有须求,
只要保险对象协会完时全体存款和储蓄属性被早先化就能够.

    //四.构造方法对质量的1一未有要求,
只要保证对象组织完时全数存款和储蓄属性被起首化就可以.

[修饰符] 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)

    {

    // 一.暗中认可情形下构造方法不会被延续

print(p2.description())

print(p2.description())

        willSet

    // 贰.基类的仓库储存属性只可以通过基类的构造方法初阶化

 

 

        {

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

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

    }

 二.便利构造器必须调用同类中的其余便利构造器(钦定或然福利)

    }

    }

}

 3.便利构造器必须最终调用一个钦定构造器停止(无论钦点依然有利,
最后必然调用多少个钦命构造器)

    func description() -> String {

    func description() -> String {

 

 四.钦赐构造器总是横向代理(父类)

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

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

var p = Person()

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

    }

    }

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

// 七.柒.6 属性和措施的联合

    var name:String

//p叁.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) {

    }

    }

    // 将1个布闭包函数作为 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) {

    //2.相当于说可选值在对象组织实现后并非初步化;

    //贰.也即是说可选值在对象组织完成后并非开首化;

sc.info()

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

    //三.其实若是不对可选存款和储蓄属性举办开头化, 暗中同意正是nil

    //三.其实若是不对可选存款和储蓄属性举行开头化, 默许正是nil

sc.info = {

//        self.init(age: 30)

    init(age:Int, name:String)

    init(age:Int, name:String)

    print(“此外3个闭包”)

        //便利构造器中只好经过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

 2.做壹些此外早先化操作.

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

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

    {

 好处:

struct Rect {

struct Rect {

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

 一.得以免备属性在被初始化前走访;

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

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

    }

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

    //因为默许处境下, 结构体会给结构体提供1个暗中同意的积极分子相继构造器

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

    

 注意:

    var width:Double = 0.0

    var width:Double = 0.0

    set

 构造器的开头化永世是在全体类的第贰阶段初阶化达成后才会开端第3阶段.

    var height:Double = 0.0

    var height:Double = 0.0

    {

 

    /*

    /*

        // setter 部分举办代码, 该有的不自然有再次来到值

 编写翻译器安检:

    // 系统暗许会提供三个近似的法子

    // 系统暗许会提供1个接近的主意

    }

 1.亟须先初阶化子类特有总体性, 再升高代理父类钦命构造方法起首化父类属性;

    init(width:Double, height:Double)

    init(width:Double, height:Double)

}

 二.只可以在调用完父类钦命构造器后技巧访问父类属性;

    {

    {

*/

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

        self.width = width

        self.width = width

 

 四.第3阶段完毕前无法访问父类属性, 也无法引用 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(){

// 注意: 一.在类中暗许是一向不各种构造器的

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

            switch(idx)

        self.init(name: “hello world”)

// 二.比方在结构体中自定义了构造方法, 那么系统不会生成暗中同意的一一构造器

// 贰.若是在结构体中自定义了构造方法, 那么系统不会扭转暗许的次第构造器

            {

    }

// 叁.比方给存款和储蓄属性提供了缺省值, 系统或许会提供私下认可的各种构造器

// 3.假如给存款和储蓄属性提供了缺省值, 系统可能会提供暗中同意的顺序构造器

                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第叁品级初阶”)

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 = ” 白骨精”

    //将父类的内定构造重视写成二个福利构造器, 必须抬高override关键字,
表示重写父类方法

    var age:Int = {

    var age:Int = {

    var title = “出售客服”

    convenience override init(name: String) {

        () -> Int in  // 那一行能够省略,
重临值是足以总结的,默许重临值的项目正是储存属性的品种

        () -> Int in  // 那1行能够总结,
重返值是足以大约的,私下认可重临值的品类就是储存属性的类型

    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

}

    

    

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

    //2.self唯有当有着的储存属性都开首化达成之后才足以用.

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

    }

    }

    }

 

    //一.Swift中有益构造方法不设有重写, 假使加上override关键字,
系统会去找寻父类中有未有和有益构造方法一样的内定构造方法, 有旧不报错,
未有就报错

    func getValue3() -> Int {

    func getValue3() -> Int {

// 七.1壹.4 使用闭包后函数为属性设置初步值

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

        return 99

        return 99

// 用于作为存款和储蓄属性早先值的函数或闭包的回来值类型须要与该属性的体系相称

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

    }

    }

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)

    }()

//早期版本中1旦字符类中有同名便利构造器会报错, 未来则不会.

 

 

}

var sm = SuperMan5()

var ci = closurenit()

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

print(ci.test)

 

 

 

// 构造器

 

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

/*

struct Apple

 构造方法的电动三番五次:

{

 1.1旦子类中从未定义构造器, 且子类全体的囤积属性都有缺省值,
会承继父类中享有的构造方法(包罗便利构造器);

    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. 而1个构造器中不得不有1行 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

// 捌.2 类的构造

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

// 八.2.壹 便利构造器

    }

// 定义便利构造器需求早 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

// 2. 钦定的构造器必须先向上调用父类构造器, 然后才干对一而再获得的属性赋值

    required init(name:String){

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

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

        // 安检 3

//        print(self.color)

//        super.name = name

        

        self.init(color: “红色”)

        self.name = name

    }

}

 

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

 

// 8.二.四 构造器的延续和重写

// 1. 固然子类未有提供别的钦赐构造器,
那么她将自动再而三父类的具有钦命构造器及全部便民构造器

 

// 只要子类的结构重视写了父类的钦命的构造器, 则必须在子类构造器前丰盛override 修饰符, 纵然构造器只是3个便利构造器

 

// 八.二.伍 类与或许倒闭的构造器

// 条件:

// 一. 此类中的全数实例存款和储蓄属性都已被赋起首值,  (就能够井井有序钦定开头值,
也可有系统隐式分配私下认可的初阶值)

// 贰. 兼有的构造器都已被实践 (即: return nil 无法放在 self.init(参数)或
super.init(参数)代码之前)

// 大概停业的构造器能够调用同一个类中的普通构造器, 反过来则不可能.,
但在类中得以调用援助隐式解析恐怕停业的结构器.

// 在结构体中. 普通的构造器却能够调用同三个结构体中只怕停业的构造器

 

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

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

        }

    }

    // 定义一个嵌套类型, 枚举 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()

 

// 八.陆.四 协议钦赐的可变方法供给

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

 

// 八.陆.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: “”)

 

// 八.陆.十 为类协议

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

 

// 捌.捌.二 循环引用

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

 

// 八.八.四 闭包的弱引用

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

}

 

// 玖.5.① 关联类型

 

// 9.6 where 句子

 

相关文章

发表评论

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

*
*
Website