swift3.0 基础知识点

//

//  ViewController.swift

//  swift_01

//

//  Created by weiphone on 16/8/26.

//  Copyright © 2016年weiphone. All rights reserved.

//

importUIKit

classViewController:UITabBarController{

   enumDayssofaWeek {//星期

       caseSunday

       caseMonday

       caseTUESDAY

       caseWEDNESDAY

       caseThursday

       caseFriday

       caseSaturday

    }

   enumStudent {//学生

       caseName(String)

       caseMark(Int, Int, Int)

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

           returna+b

        }

    }

   structMarkStruct {//结构体

       varEnglish:Int

       varChines:Int

       varMath:Int

       funcmarkStrDid(English:Int, Math:Int) ->Int{

           returnEnglish+Math

        }

        // (1) mutating可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中

       mutatingfuncsubMarks(english:Int, math:Int) ->Int{ //

           self.English += english //在可变方法中给self赋值:可变方法能够赋给隐含属性self一个全新的实例。

            Math += math//改变它的属性,并且它做的任何改变在方法结束时还会保留在原始结构中

            print("英语：",self.English,self.Math)

           returnself.English-self.Math

        }

        // (2)方法的func关键字之前加上关键字static。类可能会用关键字class来允许子类重写父类的实现方法

       staticfuncminMarks(english:Int, math:Int) ->Int{

           ifenglish < math {

               returnenglish

            }else{

               returnmath

            }

        }

       // (3)下标脚本:  subscript

       subscript(index:Int) ->Int{

           returnEnglish / index

        }

       // (4)下标脚本的重载

       subscript(row:Int, columns:Int) ->Int{

           get{

               return(row * columns) + columns

            }

           set{

            }

        }

    }

   overridefuncviewDidLoad() {

       super.viewDidLoad()

       // Do any additional setup after loading the view, typically from a nib.

       self.view.backgroundColor = UIColor.grayColor()

//        let nav1 = UINavigationController.init(rootViewController: FirstViewController)

//        let nav2 = UINavigationController.init(rootViewController: FirstViewController)

//        

//        self.viewControllers:[nav1, nav2]

       //<!----------- 0.基本语法---------------->

       // (1)swift引入

       // import语句引入OC框架（或C库）到swift程序中，

       // swift应用中可以简单额的混入C、C++语言代码，

        // (2)swift标记: swift程序由多种标记组成，标记可以是单词、标识符、常量、字符串或符号，

        print("test!")//标记是：单词、符号

       // (3)注释

        //与C语言注释极其相似， 不同之处是多行注释可以嵌套在其他的多行注释的内部

       //单行注释:  //    多行注释:  /* */

       /*

         /* 嵌套注释  */

         */

        // (4)分号:不要求每行语句的结尾处使用分号(;)，但是在同一行书写多条语句时要用分号隔开

        print("分号;;;;")

       let_fenhao:NSString="分号"; print(_fenhao)

       // (5)标识符 

        //标识符就是给常量、变量、方法、函数、枚举、结构体、类、协议、等指定的名字

        //命名规则：可由下划线、数字、字母组成，不可以数字开头，区分大小写; 若非要以关键字作为标识符需要在关键字前后添加重音符号(')

       // (6)关键字

        /*   关键字类似于标识符的保留字符序列，除非用重音符号(')将其括起来，不然不可作为标识符。关键字是对编译器具有特殊意义的预定义保留标识符。

            {

               与声明有关的关键字: calss func let public typealias deinit import operator static var enum init private struct

                                  extension internal protocol subscript

               与语句有关的关键字: if else   for in break continue  return   do while switch case where  default  fallthrough

               表达式和类型关键字: is true fale nil as  self super dynamic _COLUMN_  _LINE_  _FILE_  _FUNCTION_

               在特定上下文中使用的关键字:

                                         associativityconveniencedynamicdidSet

                                         finalgetinfixinout

                                         lazyleftmutatingnone

                                         nonmutatingoptionaloverridepostfix

                                         precedenceprefixProtocolrequired

                                         rightsetTypeunowned

                                         weakwillSet

            }

         */

       // (7)swift空格:在swift中，运算符不能直接跟在变量或常量的后面

       //错误例：let aaa= "12344"     let aaa = 1 + 2(1 +语句到此结束，2是下一个语句)

       letaaa =1+2;//规范编码推荐使用

       letbbb =2+3   //也ok

        print(aaa,bbb)

        // (8)swift字面量:指特定的数字、字符串或布尔值这样，能够直接了当的指出自己的类型并为变量进行赋值

       42 //整形字面量

       3.14159 //浮点型字面量

       "hellow swift!" //字符串字面量

       true   //布尔值字面量

//<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 1.常量---------------->

       // (1)常量声明(使用关键字let声明)

       // let constantName = <initial value>

       letconstInt =42

       letconstFloat =2.11

       letconstString ="string"

        print(constInt, constFloat, constString)

        // (2)类型标注(添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称)

       // var constantName:<data type> = <optional initial value>

       letaaInt:Int=2

       letaaFloat:Float=3.1415926

        print(aaInt,"\n", aaFloat)

        // (3)常量命名(由字母，数字和下划线组成,以字母或下划线开始,也可以使用简单的Unicode字符)

       let_const ="hello swift!"

       let你好="你好世界"

        print(_const,"\n",你好)

        print("\(_const) ......\(你好)")

       // (4)常量输出

       //变量和常量可以使用print（swift 2将print替换了println）函数来输出。

        //字符串中可以使用括号与反斜线来插入常量

       letprintName ="菜鸟教程"

       letprintName2 ="http://www.runoob.com"

        print("\(printName)的官网地址为：\(printName2)")

//<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 2.变量---------------->

        //变量是一种使用方便的占位符，用于引用计算机内存地址。

        // Swift每个变量都指定了特定的类型，该类型决定了变量占用内存的大小，不同的数据类型也决定可存储值的范围。

       // (1)变量声明

        //变量声明的意思是告诉编译器在内存中的哪个位置为变量创建多大的存储空间。

       //使用var关键字声明

       // var variableName = <initial value>

       varvarA =42

       varvarB:Float

        varB =3.1415926

        varA +=1

        print(varA, varB)

       // (2)变量命名

        //由字母、数字、下划线组成，以字母或下划线开始，也可以使用简单的Unicode字符

       var_varA ="hellow swift!"

        _varA ="ni hao!"

        print(_varA)

       // (3)变量输出

       //变量和常量可以使用print（swift 2将print替换了println）函数来输出。

        //字符串中可以使用括号与反斜线来插入常量

       var_varB:NSString="菜鸟教程"

        _varB ="菜鸟教程"

       var_varC:NSString="http://www.runoob.com"

        _varC =" http://www.runoob.com "

        print("\(_varB)的官网是：\(_varC)")

//<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 3.数据类型---------------->

        //使用数据类型存储不同的信息

       // (1)内置数据类型

       //常用数据类型：Int   UInt 浮点数 布尔值   字符串 字符 可选类型

       /**

                Int   : 长度与当前平台的原生字长相同,在32(64)位平台上，Int和Int32(Int64)长度相同，

                        在32位平台上，Int可以存储的整数范围-2,147,438,648~2,147,483,647

                UInt  : 无符号整形，

               浮点数:  {

                            double : 64位浮点数,最少15位

                            float  : 32位浮点数,最少6位

                         }

               布尔值:  true , false

               字符串: 字符串是字符的序列集合"hellow swift!"

               字符  :  指单个字母，“C”

               可选类型:使用可选类型(optionals)来处理值可能缺失的情况，可选类型表示有值或没值

         */

       // (2)数值范围

       /**

           类型       大小（字节）         区间值

            Int8          1字节            -127 ~ 127

            UInt8         1字节            0 ~ 255

            Int32         4字节            -2^31 ~ 2^31

            UInt32        4字节            0 ~ 2^32

            Int64         8字节            -9223372036854775808 ~ 9223372036854775807

            UInt64        8字节            0 ~ 18446744073709551615

            Float         4字节            1.2E-38 ~ 3.4E+38 (~6 digits)

            Double        8字节            2.3E-308 ~ 1.7E+308 (~15 digits)

         */

        // (3)类型别名:类型别名对当前的类型定义了另一个名字，类型别名通过使用typealias关键字来定义

       //语法格式  typealias newsname = type

       typealiaszhengxing =Int

       letcccInt:zhengxing=3

        print(cccInt)

        // (4)类型安全:会在编译代码时进行类型检查（type checks），把不匹配的类型标记为错误，可以在开发时尽早发现修复错误

       varvarCC =42

       // varCC = "hellow swift!"  //报错：cannot assign value of type 'String' to type 'Int'

        varCC =43

        print(varCC)

       // (5)类型推断:如果没有显式的指定类型，swift会使用推断类型（type inference）来选择适合的类型

       letddInt =42  // ddInt会被推断为Int类型

       letpi =3.14159 // pi会被推断为double类型，浮点数的类型会推断为double,不是float

       letpipi =3+ 0.14159;//表达式中同时出现整形和浮点数，会被推断为double类型

        print(ddInt,pi,pipi)

       //<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 4.字面量---------------->

        //所谓字面量，就是指特定的数字、字符串或者布尔值这样，能够直接的指出自己的类型并为变量进行赋值的值

        // (1)整型字面量:可以是十进制、八进制、二进制或十六进制常量，二进制前缀0b,八进制前缀0o,十六进制前缀0x

       letdecimalInteger =17       //17十进制

       letbinaryInteger =0b10001   //17二进制

       letoctalInteger =0o021       //17八进制

       lethexadecimalInteger =0x11 //17十六进制

        print(decimalInteger,binaryInteger,octalInteger,hexadecimalInteger)

        // (2)浮点型字面量:有整数部分，小数点，小数部分及指数部分

        //浮点型字面量的默认推到类型为Double，表示64位浮点数

       //十进制指数:   1.25e2表示1.25*10^2 ,   1.25e-2表示1.25*10^-2 （e或E）10^

       //十六进制:     0xFp2表示15*2^2  ,     (p或P) 2^

       letdecimalDouble =12.1875     //十进制浮点型字面量

       letexpontDouble =1.21875e1   //十进制浮点型字面量

       lethexadecimalDouble =0xC.3p0 //十六进制浮点型字面量

        print(decimalDouble,expontDouble,hexadecimalDouble)

       // (3)字符串型字面量:由被包在双引号中的一串字符串组成"charaters"

        //字符型字面量中不能包含未转义的双引号(“)、未转义的反斜线（\）、回车符或换行符

       /**

            转移字符             含义

             \0                空字符

             \\                反斜线\

             \b                退格(BS)，将当前位置移到前一列

             \f                换页(FF)，将当前位置移到下页开头

             \n                换行符

             \r                回车符

             \t                水平制表符

             \v                垂直制表符

             \'                单引号

             \"                双引号

             \000               1到3位八进制数所代表的任意字符

             \xhh...            1到2位十六进制所代表的任意字符

        */

       letstringL ="Hello\tWorld\n\n菜鸟教程官网：\'http://www.runoob.com\'"

        print(stringL)

       /**输出

             HelloWorld

            菜鸟教程官网：'http://www.runoob.com'

         */

       // (4)布尔型字面量:默认类型是Bool 

       //布尔值字面量有三个值，是swift的保留关键字：true：表示真，  false：表示假，nil:表示没有值

       //<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 5.可选类型---------------->

        // swift的可选（optional）类型，用于处理值缺失的情况，swift语言定义后缀问号?作为命名类型optional的简写，例如以下两种声明相等

       /**

               var optionalInteger: Int?

               var optionalInteger: Optional<Int>

         */

        //声明一个可选类型时，要确保用括号给?操作符一个适合的范围，例如，声明可选整数数组:(Int[])?, 不是Int[]?

        //声明一个可选变量或者可选属性的时候没有提供初始值，它的值默认为nil

        //如果一个可选类型的实例包含一个值，可以用后缀操作符！来访问这个值， 

        //使用操作符！去获取值为nil的可选变量会有运行时错误,可以用可选链接和可选绑定选择性执行可选表达式上的操作。如果值为nil，任何操作都不会执行，也不会有运行报错。

       /**

                optionalInteger = 42

                optionalInteger!  //42

                 var optionalInteger: Int?

                 optionalInteger = 42

                 print(optionalInteger!)

         */

       letccString:String? =nil

       ifccString !=nil{

            print(ccString)

        }else{

            print("字符串为nil")

        }

        //可选类型类似于OC中的指针的nil值，但是nil只针对类（class）有用，而可选类型对所有类型都可用，且更安全。

        // (1)强制解析:当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个感叹号表示"我知道这个可选有值，请使用它。"这被称为可选值的强制解析（forced unwrapping）

       varcccStr:String?

        cccStr ="hellow swift!"

       ifcccStr !=nil{

            print(cccStr!,"\n",cccStr)//强制解析

        }else{

            print("字符串为nil")

        }

       /**输出

         hellow swift!    //强制解析结果

         Optional("hellow swift!")

        注意：

        使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前，一定要确定可选包含一个非nil的值。

         */

        // (2)自动解析:你可以在声明可选变量时使用感叹号（!）替换问号（?）。这样可选变量在使用时就不需要再加一个感叹号（!）来获取值，它会自动解析

       varccccString:String!

        ccccString ="自动解析。。。";

       ifccccString !=nil{

            print(ccccString)

        }else{

            print("字符串为nil")

        }

       /**输出

           自动解析。。。

         */

        // (3)可选绑定:使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。

       /**

             if let constantName = someOptional {

             statements

             }

         */

       varcccccString:String?

        cccccString ="kexuanbangding...."

       ifletCCCCString = cccccString {

            print(CCCCString)

        }else{

            print("字符串没有值");

        }

       //<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 6.运算符---------------->

        //运算符是一个符号，用于告诉编译器执行一个数学或逻辑运算。

       /**

           算数运算符: +   -   *   /   %   ++  --

           比较运算符号: ==    !=   >    <    >=    <=    (结果为true, false)

           逻辑运算符: &&      ||      !         (结果为true, false)

           位运算符:位运算符用来对二进制位进行操作，~   &   |   ^   <<    >>

                     &(按位与，都为1时才为1，其他为0)     |（按位或，有一个为1就为1）  ^(按位异或，相同为0，不同为1)

                     ~(按位取反)     <<(按位左移，将操作数的所有位向左移指定的位数，空位用0补充)     >>(按位右移，)

           赋值运算符: =   +=   -=   *=    /=  %=  <<=   >>=   &=    ^=    |=

           区间运算符:闭区间运算符(a...b)     半开区间运算符(a...

           其他运算符: swift提供了其他类型的的运算符，如一元、二元和三元运算符.

         */

       //区间运算符

        print("闭区间运算符：")

       forindexin1...5{

            print("\(index) * 2 =\(index *2)")

        }

        print("半开区间运算符：")

       forindexin1..<5{

            print("\(index) * 3 =\(index *3)")

        }

       //运算符优先级

       /**

            指针最优，单目运算优于双目运算。如正负号。

            先乘除（模），后加减。

            先算术运算，后移位运算，最后位运算。请特别注意：1 << 3 + 2 & 7等价于(1 << (3 + 2))&7

            逻辑运算最后计算

         */

       //<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 7.条件语句---------------->

       /**条件语句

            if语句

            if...else语句

            if...else if...else语句

           内嵌if语句

            switch语句

            ? :运算符

         */

       //<!----------- 8.循环---------------->

       /**循环类型

            for-in

            for循环

            while循环

            repeat...while循环: 类似while语句区别在于判断循环条件之前，先执行一次循环的代码块

         */

       /**循环控制语句

            continue语句 

            break语句

            fallthrough语句: 如果在一个case执行完后，继续执行下面的case，需要使用fallthrough(贯穿)关键字

         */

       //<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 9.字符串---------------->

       // swift字符串是一系列字符的集合。例如"Hello, World!"这样的有序的字符类型的值的集合，它的数据类型为String

       // (1)创建字符串

       //是有字符串字面量

       letstringA ="hellow CJstring"

        print(stringA)

       // String实例化

       letstringB = String("hellow shilihua...")

        print(stringB)

       // (2)空字符串

        //可以使用空的字符串字面量赋值给变量或初始化一个String类的实例来初始值一个空的字符串。可以使用字符串属性isEmpty来判断字符串是否为空：

       letstringAA =""//是有字符串字面量创建空字符串

       ifstringAA.isEmpty {

            print("stringAA is empty....")

        }else{

            print("stringAA is not empty...")

        }

       letstringBB = String()//实例化String类来创建空字符串

       ifstringBB.isEmpty {

            print("stringBB is empty....")

        }else{

            print("stringBB is not empty...")

        }

       // (3)字符串常量

        //你可以将一个字符串赋值给一个变量或常量，变量是可修改的，常量是不可修改的。

       varstringAAA ="stringAAA is mutable..." // stringAAA可被修改

        stringAAA +="http://www.runoob.com"

        print(stringAAA)

       letstringBBB = String("stringBBB is can not mutable...")//

//        stringBBB += "http://www.runoob.com"   //报错：left side of mutating operator isn't mutable:'stringBBB' is a 'let' constant

        print(stringBBB)

       // (4)字符串中插入值

        //字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中

       letvarAaAA =20

       letconstaAAA =100

       letvarAaAAA:Float=20.0

       letstringAaAA ="\(varAaAA)乘以\(constaAAA)等于\(varAaAAA *100)"

        print(stringAaAA)

       // (5)字符串连接

       //字符串可以通过+号来连接

       letlianjieA ="连接A..."

       letlianjieB ="连接B..."

       letlianjieC = lianjieA + lianjieB;

        print(lianjieC)

       // (6)字符串长度

       // String.characters.count 

       letchangduA ="12345678"

        print("字符串长度为 \(changduA.characters.count)")

       // (7)字符串比较

        //你可以使用==来比较两个字符串是否相等

       iflianjieA == lianjieB {

        }else{

        }

       // (8)Unicode字符串

       // Unicode是一个国际标准，用于文本的编码，Swift的String类型是基于Unicode建立的。你可以循环迭代出字符串中UTF-8与UTF-16的编码

       letunicodeA ="你好吗!"

        print("UTF-8编码：")

       forcodeinunicodeA.utf8 {

            print("\(code)","\n")

        }

        print("UTF-16编码：")

       forcodeinunicodeA.utf16 {

            print("\(code)","\n")

        }

       // (9)字符串函数及运算符

       /**

            isEmpty : 判断字符串是否为空，返回布尔值

            hasPrefix(prefix: String) : 检查字符串是否拥有特定前缀

            hasSuffix(suffix: String) : 检查字符串是否拥有特定后缀。

            Int(String) : 转换字符串数字为整型

            String.characters.count  : 计算字符串的长度

            utf8  : 您可以通过遍历String的utf8属性来访问它的UTF-8编码

            utf16  : 您可以通过遍历String的utf16属性来访问它的UTF-16编码

            unicodeScalars : 您可以通过遍历String值的unicodeScalars属性来访问它的Unicode标量编码

            +  :  连接两个字符串，并返回一个新的字符串

            +=  : 连接操作符两边的字符串并将新字符串赋值给左边的操作符变量

            ==  : 判断两个字符串是否相等

            <  :  比较两个字符串，对两个字符串的字母逐一比较

            !=  : 比较两个字符串是否不相等

         */

       ifCFStringHasPrefix(unicodeA,"你") {

            print("CFStringHasPrefix.....YES")

        }else{

            print("CFStringHasPrefix.....NO")

        }

       ifCFStringHasSuffix(unicodeA,"!") {

            print("CFStringHasSuffix.....YES")

        }else{

            print("CFStringHasSuffix.....NO")

        }

       letzhuanhuanInt:Int! = Int(changduA)

        print(zhuanhuanInt)

        print("标量编码：")

       forcodeinunicodeA.unicodeScalars {

            print("\(code)","\n")

        }

       //<!----------- 10.字符---------------->

       // Swift的字符是一个单一的字符字符串字面量，数据类型为Character

       letcharA:Character="A"

        print(charA)

       // (1)空字符变量: Swift中不能创建空的Character（字符）类型变量或常量

//        let charAA:Character = ""   // ""被推断为String类型

       // (2)遍历字符串中的字符

       forcharin"hellow swift".characters {

            print(char)

        }

       // (3)字符串连接字符

       varcharAA:String="连接。。。"

        charAA.append(charA)

        print(charAA)

       //<!----------- 11.数组---------------->

        // Swift数组使用有序列表存储同一类型的多个值

       // (1)创建数组

       // var someArray = [SomeType]()

       vararrayA = [String]()

       vararrayB = [String](count:3,repeatedValue: "arrayB...  ")

       vararrayC = [10,20,30]

       // (2)访问数组:可以根据数组的索引来访问数组的元素  var someVar = someArray[index]

       varindexB = arrayB[0]

       varindexC = arrayC[1]

        indexB ="indexBBBB....."

        indexC +=40

       // (3)修改数组:可以使用append()方法或者赋值运算符+=在数组末尾添加元素

        arrayA.append("arrayA... ")

        arrayA += [indexB]

        arrayA += ["\(indexC)"]

        arrayB[0] ="arrayBBBBB....."

       // (3)遍历数组:使用for-in循环来遍历所有数组中的数据项

       //同时需要每个数据项的值和索引值，可以使用String的enumerate()方法来进行数组遍历

       foriteminarrayB {

            print(item)

        }

       for(index, item)inarrayB.enumerate() {

            print(index, item,"\n")

        }

        // (4)合并数组:使用加法操作符（+）来合并两种已存在的相同类型数组

       vararrayD = [String]()

        arrayD = arrayA + arrayB

        print("输出arrayD : ", arrayD)

       // (5)count属性

        print("arrayD的元素个数是：\(arrayD.count)")

       // (6)isEmpty属性

        print("arrayD是否为空：\(arrayD.isEmpty)")

       //<!----------- 12.字典---------------->

        //字典:用来存储无序的相同类型数据的集合, 

       // (1)创建字典:   

       /**

            var someDict =  [KeyType: ValueType]()  创建一个特定类型的空字典

         */

       vardicA = [String: String]()

       vardicB = [Int: String]()

        dicA = ["a":"1","b":"2","c":"3"]

        dicB = [0:"a1",1:"b2",2:"c3"]

        print(dicA, dicB)

       letdicC:[Int:String] = [5:"five...",6:"six...",0:"a1"]

        print(dicC)

       // (2)访问字典:   var someVar = someDict[key]

       letkeyA:String! = dicA["a"]

        print(keyA)

       // (3)修改字典:使用updateValue(forKey:)增加或更新字典的内容。如果key不存在，则添加值，如果存在则修改key对应的值

        dicA.updateValue("d", forKey:"4")

        dicA["a"] ="11111"

        print(dicA)

       // (4)移除Key-Value对:可以使用removeValueForKey()方法来移除字典key-value对。如果key存在该方法返回移除的值，如果不存在返回nil

       //可以通过指定键的值为nil来移除key-value（键-值）对

        dicB.removeValueForKey(1)

        dicB[0] =nil

        print(dicB)

       // (5)遍历字典: 

//        for (key, value) in dicB {   //两种都可以

       for(key, value)indicB.enumerate() {

            print("字典：key :\(key),   value:\(value)")

        }

       // (6)字典转换为数组:可以提取字典的键值(key-value)对，并转换为独立的数组

       letdicKeyA = [String](dicA.keys)

       letdicValueA = [String](dicA.values)

        print("dicA的键key :\(dicKeyA)")

        print("dicA的值Value :\(dicValueA)")

       // (7)属性: count , isEmpty

        print("字典dicB的元素个数:\(dicB.count)......")

        print("字典dicB是否为空：\(dicB.isEmpty).....")

//<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 13.函数---------------->

        // Swift函数用来完成特定任务的独立的代码块,使用一个统一的语法来表示简单的C语言风格的函数到复杂的Objective-C语言风格的方法

       /**

            函数声明:告诉编译器函数的名字，返回类型及参数。

            函数定义:提供了函数的实体。

         */

       // Swift函数包含了参数类型及返回值类型

       // (1)函数定义  (2)函数调用

       /**定义函数使用关键字func语法

             func funcname(形参) -> returntype

             {

                 Statement1

                 Statement2

                 ……

                 Statement N

                 return parameters

             }

         */

       funcresetNickname(userName:String) ->String{//定义函数

           varname:String! = userName

            name.appendContentsOf("...........")

           returnname

        }

        print(resetNickname("phoebe_zhang"))//调用

        // (3)函数参数:函数可以接受一个或者多个参数，我们也可以使用元组（tuple）向函数传递一个或多个参数

       funcrefreshDidView(model1:Int, model2:Int) ->Int{

           returnmodel1 * model2

        }

        print(refreshDidView(3, model2:5))

       // (4)不带参数函数

       /**语法

             func funcname() -> datatype {

                 return datatype

             }

         */

       funcrefreshNoti() {

        }

        refreshNoti()

       // (5)元组作为函数返回值:

        //元组与数组类似，不同的是，元组中的元素可以是任意类型，使用的是圆括号,你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回

       funcminMax(arrayA:[Int]) -> (minA:Int, maxA:Int)? {

           ifarrayA.isEmpty { 

               returnnil

            }

           varmin = arrayA[0]

           varmax = arrayA[0]

           foriteminarrayA {

               ifitem < min {

                    min = item

                }elseif(max < item) {

                    max = item

                }

            }

           return(min, max)

        }

       letminArray:[Int] = [1,6,8,3,12,45,78,0]

       letvalueArrayy = minMax(minArray)!

        print("数组arrayA中min : ", valueArrayy.minA,"\n","数组arrayA中max: ", valueArrayy.maxA)

        print("min :\(valueArrayy.minA) ,  max :\(valueArrayy.maxA)")

        //可选元组类型 如(Int, Int)?与元组包含可选类型如(Int?, Int?)是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。

       // (6)没有返回值函数: 

       funcreadMyName(myName:String) {

            print(myName)

        }

        readMyName("phoebe_zhangxiaoping...")

        // (7)函数参数名称:函数参数都有一个外部参数名和一个局部参数名

       /**

           局部参数名称:在函数内部使用,（例如myName为局部参数名，只能在函数体内使用

           外部参数名称:可以在局部参数名前指定外部参数名，中间以空格分隔，外部参数名用于在函数调用时传递给函数的参数

         */

       funcreadName(name myName:String, nickName myNickmane:String) {

            print(myName, myNickmane)

        }

        readName(name:"zhangxiaoping", nickName:"phoebe")

        // (8)可变参数:可变参数可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数，其数量是不确定的

        //可变参数通过在变量类型名后面加入（...）的方式来定义

       funcreadNickName(yourNicknam:String...) {

            print(yourNicknam)

        }

        readNickName("你的昵称  ","Phoebe", "nickname") //输出:  ["你的昵称  ", "Phoebe", "nickname"]

       // (9)常量，变量及I/O参数

        // 一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值

        //一般默认的参数传递都是传值调用的，而不是传引用。所以传入的参数在函数内改变，并不影响原来的那个参数。传入的只是这个参数的副本

       /**

            (* swift 3中要删除此方法)  func  getName(var id:String).......   :如果想要声明一个变量参数，可以在前面加上var，这样就可以改变这个参数的值了

            inout关键字:  In-Out Parameters输入输出参数,如果你想要一个函数可以修改参数的值，且想要在这些修改在函数调用结束后仍然存在，则定义为输入输出参数

         */

       /** swift 3中将要删除此方法

             func addAB(var a:Int, var b:Int) {

             a *= 2

             b *= 2

             print("\(a) * \(b) = \(a*b)")

             }

             addAB(10, b: 10)

         */

       varinoutA =10

       varinoutB =20

       funcinoutAB( a:inoutInt, b:inoutInt) {

            a *=2

            b *=2

           letc = a + b

            print("a*2 + b*2 = \(c)")

        }

        print("原始值：",inoutA, inoutB)

        inoutAB(&inoutA, b: &inoutB)

        print("改变后：", inoutA, inoutB)

        // (10)函数类型及使用:每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成

        //使用函数类型:你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它

       /**

            var addition: (Int, Int) -> Int = sum  

           解析: 定义一个叫addition的变量，参数与返回的类型均为Int，并让这个新变量指向sum函数。

            sum和addition有同样的类型，所以以上操作是合法的

         */

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

           returna+b

        }

       letaddAABB:(Int,Int) ->Int= sum

        print(addAABB(10,20))

        // (11)函数类型作为参数类型、函数类型作为返回类型: 

        //可以将函数作为参数传递给另外一个参数

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

           returna-b

        }

       // var subB:(Int, Int) -> Int = subA

       letsubB = subA

        print("20 - 10 = ", subB(20,b:10))

       funcsubC(subA: (_a:Int,_b:Int)->Int, c:Int, d:Int) {

            print("30 - 20 = ", subA(a: c, b: d))

        }

        subC(subA, c:30, d:20)

        // (12)函数嵌套:函数嵌套指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数

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

           funcnestB(c:Int)->Int{

               returnc*2

            }

           letd = nestB(10)

            print("d =\(d)")

           returnnestB(a) + nestB(b)

        }

       lete = nestA(10, b:20)

        print("eeeeeeee ====== \(e)")

//<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 14.枚举---------------->

       /**

            它声明在类中，可以通过实例化类来访问它的值。

            枚举也可以定义构造函数（initializers）来提供一个初始成员值；可以在原始的实现基础上扩展它们的功能。

            可以遵守协议（protocols）来提供标准的功能

             enum enumname {

             //枚举定义放在这里

             }

            *注意: Swift的枚举成员在被创建时不会被赋予一个默认的整型值

         */

       // (1)语法:

       varweekDay = DayssofaWeek.WEDNESDAY

        weekDay = .WEDNESDAY

       switchweekDay {

       case.Sunday:

            print("周日")

       case.WEDNESDAY:

            print("周三")

       default:

            print("周六")

        }

       // (2)相关值:以下实例中定义一个名为Student的枚举类型，它可以是Name的一个相关值（Int，Int，Int），或者是Mark的一个字符串类型（String）相关值

       letstuNames = Student.Name("ZhangSan")

       letstuMarks = Student.Mark(98,97,95)

       switchstuMarks {

       case.Name(let stuName):

            print("学生的名字是：\(stuName)")

       case.Mark(let Mark1, let Mark2, let Mark3):

            print("学生的成绩是:\(Mark1),\(Mark2),\(Mark3)")

        }//输出结果： 学生的成绩是: 98,97,95

        print(stuNames)

        //原始值:原始值可以是字符串，字符，或者任何整型值或浮点型值

        //在原始值为整数的枚举时，不需要显式的为每一个成员赋值，Swift会自动为你赋值。

        //例如，当使用整数作为原始值时，隐式赋值的值依次递增1。如果第一个值没有被赋初值，将会被自动置为0

       /**

             enum Month: Int {

                 case January = 1, February, March, April, May, June, July, August, September, October, November, December

             }

         */

       letweekday1 = DayssofaWeek.WEDNESDAY.hashValue

        print(weekday1) // 输出：3

       //<!----------- 15.结构体---------------->

        //可以为结构体定义属性（常量、变量）和添加方法，从而扩展结构体的功能

       /**区别于C和OC:

            结构体不需要包含实现文件和接口。

            结构体允许我们创建一个单一文件，且系统会自动生成面向其它代码的外部接口。

         */

        //结构体总是通过被复制的方式在代码中传递，因此它的值是不可修改的

       // (1)语法:关键字struct

       /**

             struct nameStruct {

                 Definition 1

                 Definition 2

                 ……

                 Definition N

             }

         */

       structsturentsMarksStruct {

           varEnglish:Int=100

           varChines:Int=99

           varmath:Int=98

        }

        //我们可以通过结构体名来访问结构体成员。结构体实例化使用let关键字：

       letmyMarks =sturentsMarksStruct()

        print("我的成绩是：", myMarks.English, myMarks.math, myMarks.Chines)

        //以下实例化通过结构体实例化时传值并克隆一个结构体

       structYourMarksStruct {

           varmark :Int

           init(mark:Int) {

               self.mark = mark

            }

        }

       varaStruct =YourMarksStruct(mark: 99)

        aStruct.mark =100

       varbStruct = aStruct

        bStruct.mark =97

        print(aStruct.mark, bStruct.mark)// 100, 97

       // (2)结构体应用: 

        //结构体实例总是通过值传递来定义你的自定义数据类型

        /**按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体：

               结构体的主要目的是用来封装少量相关简单数据值。

               有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。

               任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。

               结构体不需要去继承另一个已存在类型的属性或者行为。

         */

        //结构体实例是通过值传递而不是通过引用传递

       //<!----------- 16.类---------------->

       // (1)类与结构体对比

        /**与结构体相比，类还有如下的附加功能：

            继承允许一个类继承另一个类的特征

            类型转换允许在运行时检查和解释一个类实例的类型

            解构器允许一个类实例释放任何其所被分配的资源

            引用计数允许对一个类的多次引用

         */

       /**语法：

             Class classname {

                 Definition 1

                 Definition 2

                 ……

                 Definition N

             }

         */

        // (2)作为引用类型访问类属性:类的属性可以通过.来访问。格式为：实例化类名.属性名

       // (3)恒等运算符: 

        //因为类是引用类型，有可能有多个常量和变量在后台同时引用某一个类实例。

        /**为了能够判定两个常量或者变量是否引用同一个类实例，Swift内建了两个恒等运算符：

            恒等运算符                                       不恒等运算符

            运算符为：===                                     运算符为：!==

            如果两个常量或者变量引用同一个类实例则返回true        如果两个常量或者变量引用不同一个类实例则返回true

         */

       //<!----------- 17.属性---------------->

        // Swift属性将值跟特定的类、结构或枚举关联。 属性可分为存储属性和计算属性

       /**

            存储属性                             计算属性

            存储常量或变量作为实例的一部分           计算（而不是存储）一个值

            用于类和结构体                         用于类、结构体和枚举

         */

        // (1)存储属性:简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量。

        // (2)延迟存储属性:延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用lazy来标示一个延迟存储属性。

       /**

         *注意：

        必须将延迟存储属性声明成变量（使用var关键字），因为属性的值在实例构造完成之前可能无法得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。

         */

        // (3)实例化变量:一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。

        // (4)计算属性:除存储属性外，类、结构体和枚举可以定义计算属性，计算属性不直接存储值，而是提供一个getter来获取值，一个可选的setter来间接设置其他属性或变量的值

       // (5)只读计算属性:只有getter没有setter的计算属性就是只读计算属性

        //必须使用var关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。let关键字只用来声明常量属性，表示初始化后再也无法修改的值。

        // (6)属性观察器:属性观察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。

        // (7)全局变量和局部变量:计算属性和属性观察器所描述的模式也可以用于全局变量和局部变量

       /**

            局部变量                             全局变量

            在函数、方法或闭包内部定义的变量。         函数、方法、闭包或任何类型之外定义的变量。

            用于存储和检索值。                     用于存储和检索值。

            存储属性用于获取和设置值。               存储属性用于获取和设置值。

            也用于计算属性。                       也用于计算属性。

         */

        // (8)类型属性:类型属性是作为类型定义的一部分写在类型最外层的花括号（{}）内。

        //使用关键字static来定义值类型的类型属性，关键字class来为类定义类型属性。

       structTeachers {

           staticvarEnglish =""

           staticvarcomputedTypeProperty:Int{

               return3

            }

        }

       enumTYpessss {

           staticvarTypeAA =""

           staticvarTypeBB:Int{

               return3

            }

           functypeDid(a:Int) ->Int{

                print(">>>>>> 枚举中定义方法：", a)

               returna*2

            }

        }

       classCLASSsss {

           classvarclassAAA:Int{

               return3

            }

        }

        // (9)获取和设置类型属性的值:类似于实例的属性，类型属性的访问也是通过点运算符(.)来进行。但是，类型属性是通过类型本身来获取和设置，而不是通过实例

//<!------------------------------------------我是可爱的分割线--------------------------------------------------->

       //<!----------- 18.方法---------------->

       // Swift方法是与某些特定类型相关联的函数

        //在Objective-C中，类是唯一能定义方法的类型。但在Swift中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型（类/结构体/枚举）上定义方法。

       // (1)实例方法: 

       /**语法:

             func <#name#>(<#parameters#>) -> <#return type#> {

             <#function body#>

             }

         */

        print(aAddB(100, b:200))

        countADD(100)

        print(countA)

        //方法的局部参数名称和外部参数名称: Swift默认仅给方法的第一个参数名称一个局部参数名称;默认同时给第二个和后续的参数名称为全局参数名称

        //例如aAddB方法中，a为局部参数名称，b用于全局的声明并通过外部程序访问。

        //是否提供外部名称设置:我们强制在第一个参数添加外部名称把这个局部名称当作外部名称使用（Swift 2.0前是使用#号）。

        //相反，我们呢也可以使用下划线（_）设置第二个及后续的参数不提供一个外部名称

       funcparamA(first a:Int, b:Int) {

            print("\(a+b)")

        }

        paramA(first:10, b:10)

       funcparamB(a:Int, second _b:Int) {

            print("\(a-_b)")

        }

        paramB(10, second:5)

        // (2)self属性:类型的每一个实例都有一个隐含属性叫做self，self完全等同于该实例本身。

        //你可以在一个实例的实例方法中使用这个隐含的self属性来引用当前实例。

       self.countA =100

        print(self.countA)

       // (3)在实例方法中修改值类型: 变异(mutating)

       /**

             Swift语言中结构体和枚举是值类型。一般情况下，值类型的属性不能在它的实例方法中被修改。

            但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择变异(mutating)这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中。

            方法还可以给它隐含的self属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例。

         */

       varmutaMarks = MarkStruct(English:99, Chines:99, Math:95)

        print(">>>>>英语：", mutaMarks.English)

        mutaMarks.subMarks(100, math:90)

        print(">>>>>英语......：", mutaMarks.English)

       // (4)在可变方法中给self赋值:可变方法能够赋给隐含属性self一个全新的实例。  mutating

        // (5)类型方法:实例方法是被类型的某个实例调用的方法，你也可以定义类型本身调用的方法

       //声明结构体和枚举的类型方法，在方法的func关键字之前加上关键字static。    static

       //类可能会用关键字class来允许子类重写父类的实现方法。      class

        //类型方法和实例方法一样用点号(.)语法调用

       letminmarkss = MarkStruct.minMarks(90, math:80)

        print(minmarkss)

       //<!--------------- 关键字static与class的区别-------------->

        // class关键字除了有自定义类的作用,还有声明类方法的作用

       // (1)在方法的func关键字之前加上关键字static或者class都可以用于指定类方法.

        // (2)不同的是用class关键字指定的类方法可以被子类重写,但是用static关键字指定的类方法是不能被子类重写的

       // (3)类方法和实例方法可以重名

       //<!----------- 19.下标脚本---------------->

       /**

            下标脚本可以定义在类（Class）、结构体（structure）和枚举（enumeration）这些目标中，可以认为是访问对象、集合或序列的快捷方式，不需要再调用实例的特定的赋值和访问方法。

            举例来说，用下标脚本访问一个数组(Array)实例中的元素可以这样写someArray[index]，访问字典(Dictionary)实例中的元素可以这样写someDictionary[key]。

            对于同一个目标可以定义多个下标脚本，通过索引值类型的不同来进行重载，而且索引值的个数可以是多个

         */

       // (1)下标脚本语法及应用:

       /**语法:

             subscript(index: Int) -> Int {

                 get {

                     //用于下标脚本值的声明

                 }

                 set(newValue) {

                     //执行赋值操作

                 }

             }

         */

       letsubscriMark = MarkStruct(English:100, Chines:100, Math:100)

        print("100/10 = ", subscriMark[10])

        print("100/20 = ", subscriMark[20])

       letp = ViewController2()

        print(p[0],"\n")

       //用法: 通常下标脚本是用来访问集合（collection），列表（list）或序列（sequence）中元素的快捷方式。

        //你可以在你自己特定的类或结构体中自由的实现下标脚本来提供合适的功能

       // (2)下标脚本选项: 

       /**

            下标脚本允许任意数量的入参索引，并且每个入参类型也没有限制。

            下标脚本的返回值也可以是任何类型。

            下标脚本可以使用变量参数和可变参数。

            一个类或结构体可以根据自身需要提供多个下标脚本实现，在定义下标脚本时通过传入参数的类型进行区分，使用下标脚本时会自动匹配合适的下标脚本实现运行，这就是下标脚本的重载。

         */

        print("下标脚本重载：10*2+2 = ",subscriMark[10,2])

       //<!----------- 20.继承---------------->

       //子类，超类(或父类)

        //在Swift中，类可以调用和访问超类的方法，属性和下标脚本，并且可以重写它们。

       // (1)基类:没有继承其它类的类，称之为基类（Base Class）

        // (2)子类:子类指的是在一个已有类的基础上创建一个新的类

        // (3)重写: Overriding,子类可以通过继承来的实例方法，类方法，实例属性，或下标脚本来实现自己的定制功能，我们把这种行为叫重写

       /**

            重写           访问方法，属性，下标脚本

            方法            super.somemethod()

            属性            super.someProperty()

            下标脚本          super[someIndex]

         */

       // (4)重写方法和属性: 

       //重写方法:

       letsuperStudent = StudentDetails()

        superStudent.recordMarks()

       letsubTom = Tom()

        subTom.recordMarks()

        //重写属性:你可以提供定制的getter（或setter）来重写任意继承来的属性，无论继承来的属性是存储型的还是计算型的属性

       /**注意

            如果你在重写属性中提供了setter，那么你也一定要提供getter。

            如果你不想在重写版本中的getter里修改继承来的属性值，你可以直接通过super.someProperty来返回继承来的值，其中someProperty是你要重写的属性的名字。

         */

        subTom.English =100

       //subTom.Math = 120 // get-only

        print("重写属性：tom  ", subTom.Math)

        // (5)重写属性观察器:你可以在属性重写中为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会监测到。

        //注意：你不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器。

        subTom.English =200

        print(">>>>重写：", subTom.Chines, subTom.Math)

       // (6)防止重写: final, 我们可以使用final关键字防止它们被重写

        //如果你重写了final方法，属性或下标脚本，在编译时会报错。

        //你可以通过在关键字class前添加final特性（final class）来将整个类标记为final的，这样的类是不可被继承的，否则会报编译错误。

        //构造过程是为了使用某个类、结构体或枚举类型的实例而进行的准备过程。这个过程包含了为实例中的每个属性设置初始值和为其执行必要的准备和初始化任务

        //构造函数: init()  , 与Object-C中的构造器不同，swift的构造函数无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化

        //类实例也可以通过定义析构器（deinitializer）在类实例释放之前执行清理内存的工作。

        // (1)存储型属性的初始赋值:在实例创建时，必须为所有存储型属性设置合适的初始值。

        //存储属性在构造器中赋值时，它们的值是被直接设置的，不会触发任何属性观测器。

        /**存储属性在构造器中赋值流程：

            创建初始值。

            在属性定义中指定默认属性值。

            初始化实例，并调用init()方法。

         */

        // (2)构造器: init   构造器在创建某特定类型的新实例时调用。它的最简形式类似于一个不带任何参数的实例方法，以关键字init命名。

       /**语法:

                init() {

                    //实例化后执行的代码

                }

         */

       //实例:以下结构体定义了一个不带参数的构造器init，并在里面将存储型属性length和breadth的值初始化为6和12：

       structAinitaStruct {

           varlength:Double

           varwidth:Double

           varr =3.5 // (3)默认属性值

           init() {

                length =5.5

                width =9

            }

        }

       letareaA =AinitaStruct()

        print("矩形的面积：\(areaA.length * areaA.width)")

        // (3)默认属性值:我们可以在构造器中为存储型属性设置初始值；同样，也可以在属性声明时为其设置默认值。

        //使用默认值能让你的构造器更简洁、更清晰，且能通过默认值自动推导出属性的类型。

        // (4)构造参数:你可以在定义构造器init()时提供构造参数，如下所示：

       structAparamStruct {

           varlength :Double

           varwidth :Double

           vararea :Double

           init(fromLength length:Double, fromWidth width:Double) {

               self.length = length

               self.width = width

                area = length * width

            }

           init(fromLg lg:Double, fromWd wd: Double) {

               self.length = lg

               self.width = wd

                area = lg * wd

            }

        }

       letareaPA =AparamStruct(fromLength:10, fromWidth:20)

       letareaPB =AparamStruct(fromLg: 100, fromWd:200)

       letareaPC =AparamStruct.init(fromLength:5, fromWidth:10)

        print("areaPA:\(areaPA.area),   areaPB:\(areaPB.area),   areaPC:\(areaPC)")

        // (5)内部和外部参数名:如果你在定义构造器时没有提供参数的外部名字，Swift会为每个构造器的参数自动生成一个跟内部名字相同的外部名。

       structColor {

           letred, green, blue:Double

           init(red:Double, green:Double, blue:Double) {

               self.red = red

               self.green = green

               self.blue = blue

            }

           init(white:Double) {

                red = white

                green = white

                blue = white

            }

        }

       letpurpleColor =Color.init(red:255, green:222, blue:111)

       letyellowColor =Color.init(white:200)

        print(purpleColor.red, yellowColor.red)

        //没有外部参数名称:如果你不希望为构造器的某个参数提供外部名字，你可以使用下划线_来显示描述它的外部名

       structColorNO {

           letred:Double

           init(_white:Double) {

                red = white

            }

        }

       letnoColorA =ColorNO.init(100)

        print(">>>>>>>>  没有外物参数：noColorA = ", noColorA.red)

        // (6)可选属性类型:如果你定制的类型包含一个逻辑上允许取值为空的存储型属性，你都需要将它定义为可选类型optional type（可选属性类型）。

        //当存储属性声明为可选时，将自动初始化为空nil

       structRGB {

           varred :Double?

           letgreen :Double?// (7)green属性现在是常量

           init(white:Double) {

                red = white +10

                green = red! +10// (7)仍然可以在构造器中设置值

            }

           init(_black:Double) {

                red = black

                green = red! +100

            }

        }

       letRGBa =RGB.init(white:100)

       letRGBb =RGB.init(200)

       // print(RGBa.red, RGBb.red) //输出结果Optional(110.0) Optional(200.0)

        print(RGBa.red!, RGBb.red!)//输出结果110.0 200.0

        // (7)构造过程中修改常量属性:只要在构造过程结束前常量的值能确定，你可以在构造过程中的任意时间点修改常量属性的值

        //对某个类实例来说，它的常量属性只能在定义它的类的构造过程中修改；不能在子类中修改

        // (8)默认构造器:默认构造器将简单的创建一个所有属性值都设置为默认值的实例

        //以下实例中，ShoppingListItem类中的所有属性都有默认值，且它是没有父类的基类，它将自动获得一个可以为所有属性设置默认值的默认构造器

       letitem = ShoppingListItem()

        print("默认构造器：", item.name, item.quantity, item.purchased) //输出结果：默认构造器：  nil 1 false

        //结构体的逐一成员构造器:如果结构体对所有存储型属性提供了默认值且自身没有提供定制的构造器，它们能自动获得一个逐一成员构造器。

        //我们在调用逐一成员构造器时，通过与成员属性名相同的参数名进行传值来完成对成员属性的初始赋值。

       structShopping {

           varlength =100.0

           varwidth =200.0

        }

       letshopA =Shopping.init(length:33.0, width:24.0)

        print("结构体的逐一成员变量：", shopA.length*shopA.width)

        // (9)值类型的构造器代理:构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。

       //以下实例中，RectA结构体调用了SizeA和PointA的构造过程：

       structSizeA {

           varwidth =0.0, height =0.0

        }

       structPointA {

           varx =0.0, y =0.0

        }

       structRectA {

           varorigin = PointA() // origin属性使用定义时的默认值PointA(x: 0.0, y: 0.0)

           varsize = SizeA()

           init() {}

           init(origin:PointA, size:SizeA) {

               self.origin = origin

               self.size = size

            }

           init(center:PointA, size:SizeA) {

               //先通过center和size的值计算出origin的坐标

               letoriginX = center.x - size.width/2

               letoriginY = center.y  - size.height/2

               //然后再调用（或代理给）init(origin:size:)构造器来将新的origin和size值赋值到对应的属性中

               self.init(origin: PointA.init(x: originX, y: originY), size: size)

            }

        }

       letrectA =RectA()

        print("PointA结构体初始值：\(rectA.origin.x, rectA.origin.y)") //输出结果：PointA结构体初始值：(0.0, 0.0)

       //将origin和size的参数值赋给对应的存储型属性

       letrectB =RectA.init(origin: PointA(x:56.0, y:45.0), size:SizeA(width:100.0, height:200.0))

        print("PointB结构体初始值：\(rectB.origin.x, rectB.origin.y)") //输出结果：PointB结构体初始值：(56.0, 45.0)

       //先通过center和size的值计算出origin的坐标。

       //然后再调用（或代理给）init(origin:size:)构造器来将新的origin和size值赋值到对应的属性中

       letrectC =RectA.init(center: PointA(x:10.0, y:10.0), size:SizeA(width:24.0, height:25.0))

        print("PointC结构体初始值：\(rectC.origin.x, rectC.origin.y)") //输出结果：PointC结构体初始值：(-2.0, -2.5)

       /**构造器代理规则:

        值类型  :不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给本身提供的其它构造器。可以使用self.init在自定义的构造器中引用其它的属于相同值类型的构造器。

        类类型  : 它可以继承自其它类,这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。

         */

        // (10)类的继承和构造过程: Swift提供了两种类型的类构造器来确保所有类实例中存储型属性都能获得初始值，它们分别是指定构造器和便利构造器。

       /** 

           指定构造器: 类中最主要的构造器

                        初始化类中提供的所有属性，并根据父类链往上调用父类的构造器来实现父类的初始化。

                       每一个类都必须拥有至少一个指定构造器

                         Init(parameters) {

                             statements

                         }

           便利构造器: 类中比较次要的、辅助型的构造器

                        可以定义便利构造器来调用同一个类中的指定构造器，并为其参数提供默认值。你也可以定义便利构造器来创建一个特殊用途或特定输入的实例。

                       只在必要的时候为类提供便利构造器

                         convenience init(parameters) {

                             statements

                         }

         */

       letyuebing = Mooncake.init(huaMei:"华美月饼")

       letyuebing1 = Ronglang.init(huaMei:"华美月饼", rongLang:"荣朗月饼")

        print(">>>>华美：\(yuebing.huamei), \n, >>>>>华美:\(yuebing1.huamei), \n, >>>>>荣朗：\(yuebing1.ronglang)")

       letcar = carCalss(aoDI:"奥迪。。。")

       // let aodi = AODIClass(aoDI: "奥迪、、、", daZhong: "大众、、、")

       letaodi = AODIClass.init(aoDI:"奥迪")

        print("car:\(car.aodi) \n AODI:\(aodi.aodi, aodi.dazhong)")

        // (11)构造器的继承和重载: Swift中的子类不会默认继承父类的构造器

        //父类的构造器仅在确定和安全的情况下被继承。当你重写一个父类指定构造器时，你需要写override修饰符。

       letwine = WineClass()

        print(wine.desccription) //输出结果：红酒不错！

       letredwine = REDWineClass()

        print(redwine.desccription)//输出结果：红酒名酒。。。不错！

        //指定构造器和便利构造器实例:接下来的例子将在操作中展示指定构造器、便利构造器和自动构造器的继承。

        //它定义了包含两个个类MainClass、SubClass的类层次结构，并将演示它们的构造器是如何相互作用的。

       letgame = GameClass(mobilegame:"精灵宝")

        print("game :\(game.mobileGames)")//输出结果：game :精灵宝

       letgame1 = GameClass()

        print("game none : \(game1.mobileGames)")//输出结果:  game none :逐鹿天下手游

       letmobile = MobileGameClass.init(mobilegame:"纪念碑谷")

        print("mobile one : \(mobile.mobileGames)")//输出结果: mobile one :纪念碑谷

       letmobile1 = MobileGameClass.init(moblegame:"梦幻西游", zhulu:"酷跑")

        print("mobile1 two : \(mobile1.zhuluGame)")//输出结果:  mobile1 two :酷跑

        // (12)类的可失败构造器:如果一个类，结构体或枚举类型的对象，在构造自身的过程中有可能失败，则为其定义一个可失败构造器。

       //其语法为在init关键字后面加添问号(init?)

        /**变量初始化失败可能的原因有：

            传入无效的参数值。

            缺少某种所需的外部资源。

            没有满足特定条件。

         */

       structGameStruct {

           letgame:String

           init?(zhulu:String) {

               ifzhulu.isEmpty {

                   returnnil

                }else{

                   self.game = zhulu

                }

            }

        }

        //通过该可失败构造器来构建一个GameStruct的对象，并检查其构建过程是否成功

       // gameZhulu的类型是GameStruct?  而不是GameStruct

       letgameZhulu =GameStruct.init(zhulu:"逐鹿天下，》》》")

       ifletzhulu = gameZhulu {

            print("可失败构造器：\(zhulu.game)")

        }

       //枚举类型的可失败构造器

       // (13)覆盖一个可失败构造器 

        //就如同其它构造器一样，你也可以用子类的可失败构造器覆盖基类的可失败构造器。

        //者你也可以用子类的非可失败构造器覆盖一个基类的可失败构造器。

        //你可以用一个非可失败构造器覆盖一个可失败构造器，但反过来却行不通。

        //一个非可失败的构造器永远也不能代理调用一个可失败构造器。

       letplName = planet(name:"Mercury")

        print("行星的名字是：\(plName.name)") //行星的名字是: Mercury

       letnopName = planet()

        print("没有这个星星的名字：\(nopName.name)") //没有这个名字的行星: [No Planets]

       // (14)可失败构造器init!

        //通常来说我们通过在init关键字后添加问号的方式（init?）来定义一个可失败构造器，但你也可以使用通过在init后面添加惊叹号的方式来定义一个可失败构造器(init!)

       letstmaek = StuRecord(stname:"Runoob")

       ifletname = stmaek {

            print("指定了学生名:\(name)")//指定了学生名:

        }

       letblankname = StuRecord(stname:"")

       ifblankname ==nil{

            print("学生名为空")//学生名为空

        }

       //<!----------- 22.析构过程---------------->

        // deinit :在一个类的实例被释放之前，析构函数被立即调用。用关键字deinit来标示析构函数，类似于初始化函数用init来标示。析构函数只适用于类类型。

       /**析构过程原理: 

             Swift会自动释放不再需要的实例以释放资源。

             Swift通过自动引用计数（ARC）处理实例的内存管理。

            通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。

            例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前关闭该文件。

         */

        /**语法:在类的定义中，每个类最多只能有一个析构函数。析构函数不带任何参数，在写法上不带括号：

             deinit {

                //执行析构过程

             }

         */

       varshow:BaseClass? = BaseClass()

       varhide:BaseClass? = BaseClass.init()

        print("有值：", counter) //输出：有值：  2

        show =nil //当show = nil语句执行后，计算器减1，show占用的内存就会释放。

        hide =nil

        print("置空：", counter)//输出：置空：0

        print(show, hide)// 输出：  nil nil

       //<!----------- 23.自动引用计数（ARC）---------------->

        // ARC 这一机制跟踪和管理应用程序的内存。通常不需要手动释放内存，因为ARC会在类的实例不再被使用时，自动释放其占用的内存

       /** ARC功能：

             init() ,  当每次使用init()方法创建一个类的新的实例的时候，ARC会分配一大块内存用来储存实例的信息。

            内存中包含实例的类型信息，以及这个实例所有相关属性的值

            当实例不再被使用时，ARC释放实例所占用的内存，并让释放的内存能挪作他用。

            为了确保使用中的实例不会被销毁，ARC会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。

            实例赋值给属性、常量或变量，它们都会创建此实例的强引用，只要强引用还在，实例是不允许被销毁的。

         */

       //值会被自动初始化为nil,目前还不会引用到BaseClass类的实例

       varbaseC :BaseClass?

       varbaseC1 :BaseClass?

       varbaseC2 :BaseClass?

       //创建BaseClass类的实例

        baseC = BaseClass()

        //赋值给其他两个变量，该实例又会多出两个强引用

        baseC1 = baseC

        baseC2 = baseC

       //断开第一个强引用

        baseC =nil

       //断开第二个强引用

        baseC1 =nil

        //断开第三个强引用，并调用析构函数

        baseC2 =nil

        print(baseC1, baseC2)

        //在上面的例子中，ARC会跟踪你所新创建的BaseClass实例的引用数量，并且会在BaseClass实例不再被需要时销毁它

       // ***类实例之间的循环强引用

       // ***类实例之间的循环强引用

        //一个类永远不会有0个强引用，这种情况发生在两个类实例相互保持对方的强引用，并让对方不被销毁，这就是所谓的循环强引用

       //两个变量都被初始化为nil

       varbasesingcalss :SignClass?

       varbasessclass :SSClass?

       //赋值

        basesingcalss = SignClass.init(name:"BaseSignClass")

        basessclass = SSClass.init(number:73)

       //意感叹号是用来展开和访问可选变量runoob和number73中的实例

       //循环强引用被创建

        basesingcalss!.baseSs = basessclass

        basessclass!.baseSign = basesingcalss

       //断开basesingcalss和basessclass变量所持有的强引用时，引用计数并不会降为0，实例也不会被ARC销毁

        //注意，当你把这两个变量设置为nil时，没有任何一个析构函数被调用

        //强引用循环阻止了SignClass，SSClass类实例的销毁，并在你的应用程序中造成了内存泄露

        basesingcalss =nil

        basessclass =nil

        print("循环请引用", basesingcalss, basessclass)

       //解决实例之间的循环强引用：weak弱引用，  unowned无主引用

        //此两种引用允许循环引用中的一个实例引用另外一个实例而不保持强引用，这样实例能够相互引用而不产生循环强引用

        //对于生命周期中会变为nil的实例使用弱引用，相反的，对于初始化赋值后再也不会被赋值为nil的实例，使用无主引用。

       //弱引用实例

       vartoc :Module?

       varlist :SubModul?

        toc = Module.init(name:"ARC")

        list = SubModul.init(number:4)

        toc!.sub = list

        list!.topic = toc

        toc =nil

        list =nil

        print("弱引用", basesingcalss, basessclass)

       //无主引用实例

       varpeter :StudentPeter?

        peter = StudentPeter.init(name:"Peter")

        peter!.section = MarkPeter.init(marks:99, stname: peter!)

        peter =nil

       // ***闭包引起的循环强引用

       // ***闭包引起的循环强引用

        //当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性，例如self.someProperty，或者闭包中调用了实例的某个方法，例如self.someMethod。这两种情况导致了闭包“捕获”self，从而产生了循环引用。

       //创建实例并打印信息

       varparagraph:HTMLElement?

        paragraph = HTMLElement.init(name:"pp", text:"hellow, world")

//        print(paragraph!.asHTML)

        //解决闭包引起的循环强引用:在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用

       /**弱引用和无主引用

            当闭包和捕获的实例总是互相引用时并且总是同时销毁时，将闭包内的捕获定义为无主引用。

            相反的，当捕获引用有时可能会是nil时，将闭包内的捕获定义为弱引用。

            如果捕获的引用绝对不会置为nil，应该用无主引用，而不是弱引用。

         */

        print(paragraph!.asasHTML())

        // HTMLElement实例将会被销毁，并能看到它的析构函数打印出的消息

        paragraph =nil

       //<!----------- 24.类型转换---------------->

       /**检测is， 转换as

             Swift语言类型转换可以判断实例的类型。也可以用于检测实例类型是否属于其父类或者子类的实例。

             Swift中类型转换使用is和as操作符实现，is用于检测值的类型，as用于转换类型。

            类型转换也可以用来检查一个类是否实现了某个协议。

         */

       // (1)定义一个类层次

        //类型转换用于检测实例类型是否属于特定的实例类型

        //你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。

       classSubjects {

           varphysics :String

           init(physics :String) {

               self.physics = physics

            }

        }

       classChemistry :Subjects{

           varequations :String

           init(physics:String, equations: String) {

               self.equations = equations

               super.init(physics: physics)

            }

        }

       classMaths:Subjects{

           varformulae :String

           init(physics :String, formulae : String) {

               self.formulae = formulae

               super.init(physics: physics)

            }

        }

       letsa = [Chemistry(physics:"固体物理", equations:"赫兹"),

                 Maths(physics:"流体动力学", formulae:"千兆赫"),

                 Maths(physics:"流体动力学", formulae:"千兆赫"),]

       letsamplechem =Chemistry.init(physics:"固体物理", equations:"赫兹")

        print("实例物理学史：\(samplechem.physics)")

        print("实例方程式：\(samplechem.equations) \(sa[0].physics)")

       letsamplemaths =Maths(physics:"流体动力学", formulae:"千兆赫")

        print("实例物理学是:\(samplemaths.physics)")

        print("实例公式是:\(samplemaths.formulae)")

       //（2）检查类型:关键字is

        //操作符is来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回true，否则返回false。

       varchemCount =0

       varmathsCount =0

       foriteminsa {

           ifitemisChemistry{

                chemCount +=1

            }else{

                mathsCount +=1

            }

        }

        print("化学科目包含：\(chemCount)个，数学包含：\(mathsCount)个主题")//化学科目包含：1个，数学包含：2个主题

       // (3)向下转型: as?或as!

        // as?  当你不确定向下转型可以成功时，用类型转换的条件形式(as?)。条件形式的类型转换总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是nil。

        // as!  只有你可以确定向下转型一定会成功时，才使用强制形式(as!)。当你试图向下转型为一个不正确的类型时，强制形式的类型转换会触发一个运行时错误。

       foriteminsa {

           //类型转换的条件形式

           ifletshow = itemas?Chemistry{

                print("化学主题是: '\(show.physics)',\(show.equations)")

               //强制形式

            }elseifletexample = itemas?Maths{

                print("数学主题是: '\(example.physics)', \(example.formulae)")

            }

        }

       // (4)Any和AnyObject的类型转换

       // AnyObject :可以代表任何class类型的实例,  Any可以代表任何类型，包括方法类(function types)

        //注意：只有当你明确的需要它的行为和功能时才使用Any和AnyObject。在你的代码里使用你期望的明确的类型总是更好的

       // Any实例:

       //可以存储Any类型的数组exampleany

       varexampleany = [Any]()

        exampleany.append(12)

        exampleany.append(3.14159)

        exampleany.append("Any 实例")

        exampleany.append(Chemistry(physics:"固体物理", equations:"赫兹"))

       foriteminexampleany {

           switchitem {

           caseletsomeIntasInt:

                print("整型值为\(someInt)")