swift—4

swift—4

mport Foundation



println("Hello, World!")



//类的继承与重载



class NamedShape {

    var numberOfSides = 0

    var name : String



    init(){

        name = "xingz"

    }



    //    在这里self是区分是否是成员变量

//    在这里他会检查所有变量是否 赋了初值

    init(name:String){

        self.name = name

    }



    //    deinit{

    //    叫做析构函数，我们OC中的delloc 用法差不多。析构函数不能带参数，每个类最多只有一个析构函数。作用是自动销毁不用的实例变量



    //    里面写需要销毁的对象

    //    }



    func simpleDisception()->String{

        return "\(name) has \(numberOfSides)sides"

    }



}





class Square: NamedShape {



    var sideLength : Double

    init(name: String, sideLength:Double) {



      self.sideLength = sideLength



//        如果调用父类的成员变量，就要调用父类的super.init()

        super.init()

            self.numberOfSides = 4

            self.name = "正方形"



    }

    func area()->Double{

        return sideLength * sideLength

    }



//    重载父类的方法 必须有override这个关键字

    override func simpleDisception() -> String {

        return "\(super.simpleDisception()), the sideLength is \(sideLength) area is \(area())"

    }



}

var square = Square(name: "正方形", sideLength: 10)



print(square.simpleDisception())



//自己去定义一个圆类。继承自NamedShape  有自己的成员变量半径raduis。写一个计算面积的方法，重载父类的simpleDisception讲面积描述出来

class yuan:NamedShape{



    var radusi : Double



    init( name: String, raduis: Double) {



       self.radusi = raduis



       super.init()

        self.numberOfSides = 1

        self.name = "圆"



    }

    func area()->Double{

        return radusi * radusi * M_PI

    }

    override func simpleDisception() -> String {

        return "\(super.simpleDisception()), area is \(area())"

    }

}



var y = yuan(name: "yuan", raduis: 4)

print(y.simpleDisception())



class EquliaterTriangle: NamedShape {



    var sideLength : Double

    init(name: String, sideLength : Double) {

        self.sideLength = sideLength

        super.init()

        self.name = name



    }

//   计算等边三角形的周长



//    set 和get 方法。用在哪里呢，需要计算才能得到某些值的时候调用



//    set 方法

//    -(void)setName:(NSString *)name{

//    self.name = name

//    }



//    get 方法

//    -(NSString *)name{

//    return name

//    }

    var perimeter:Double{



        get{

//            通过给边长赋值，就可以得到周长

            return sideLength * 3

        }





        set{

//            通过周长去计算边长

            sideLength = newValue / 3

        }



    }

}

var equliaterTriangle = EquliaterTriangle(name: "三角形", sideLength: 10)

print(equliaterTriangle.perimeter)



equliaterTriangle.perimeter = 60

print(equliaterTriangle.sideLength)



class TriangleAndSquare{



    var triangle:EquliaterTriangle{



        willSet{

            square.sideLength = newValue.sideLength

        }



        didSet{

            print("\(triangle)")

        }

    }



    var square : Square{



        willSet{

            triangle.sideLength = newValue.sideLength

        }



        didSet{

            print("\(triangle)")

        }

    }



    init(name : String ,sideLength :Double){

        triangle = EquliaterTriangle(name: name, sideLength: sideLength )

        square = Square(name: name, sideLength: sideLength)

    }

}

var tAndS = TriangleAndSquare(name: "三角形和正方形", sideLength: 0.0)



var tria = EquliaterTriangle(name: "三角形", sideLength: 10)

tAndS.triangle = tria

print(tAndS.square.sideLength)





//定义一个类 类中有一个人增量函数，实现功能：传入一个参数amount 一个times。将类中的属性count 加上  amount * times



class Count{

    var count = 0



    func add(amount : Int, times : Int){

       count += amount * times

    }



}

var v1 = Count()

v1.add(10, times: 10)

print(v1.count)



//枚举

//如果枚举为init类型，那么该枚举就会有rawValue

enum Rank : Int{

    case Ace = 1

    case Two, Three, Four, Six, Seven, Eight, Nine, Ten

    case Jack, Queen, King



    func simpleDescripation()->NSString{



        switch self{



        case .Ace ://也可以case Rank.Ace



        return "Ace"



        case .Jack :

        return "jack"



        default:

            return "\(self.rawValue)"



        }

    }



    //将枚举值作为函数的参数。判断当前的枚举值.rawValue大还是传进来的参数的枚举值的.rawValue大

    func moreThan(r1 : Rank)->Bool{

        return self.rawValue > r1.rawValue

    }



    func say(){

        print("hello world")

    }



}

let king = Rank.King



print(king.simpleDescripation())

print(Rank.Ten.moreThan(Rank.Jack))

print(king.say())



//调用枚举的init方法 通过rawValue去找到对应的枚举



 let threeValue = Rank(rawValue: 20)



//print(threeValue!.simpleDescripation())



//不到类型的枚举

enum 棋{



   case 象棋, 围棋, 五子棋, 跳棋, 飞行棋



    func simpleDescripation()->NSString{



        switch self{



            case .象棋 :

            return "象棋"



            case .围棋 :

            return "围棋"



            case .五子棋 :

            return "五子棋"



            case .跳棋 :

            return "跳棋"



            case .飞行棋 :

            return "飞行棋"



         default :

         return "\(self.hashValue)"

        }



    }



    func popularDate()->String{



        switch self{

        case .象棋, .围棋 :

            return "当前流行"

        case .五子棋 :

            return "流行"

        default :

            return "国际流行"



        }

    }



}

var 棋对象 = 棋.飞行棋

print(棋对象.simpleDescripation())

print(棋对象.popularDate())



//自己写一个枚举  枚举的名字叫做等级

//里面有三种情况  初级棋手 中级棋手 高级棋手

enum level{



    case 初级棋手, 中级棋手, 高级棋手

    func simple()->String{



        switch self{



        case .初级棋手:

            return "初级棋手"

        case .中级棋手:

            return "中级棋手"

        case .高级棋手:

            return "高级棋手"



        }



    }

}

var le = level.初级棋手

print(le.simple())



//enum example{

//    case one(name :String, age :Int), two(name :String, age :Int)

//    

//    func simple()->String{

//        switch self{

//            

//        case .one(name1: "zhangSan", age1: 24):

//            return "one name is \(name1), age is \(age1)"

//            

//        case .two(name1: "lisi", age1: 22) :

//            return "one name is \(name1), age is \(age1)"

//        

//        default :

//            return "erroe"

//            

//        }

//    }

//}



//结构体

struct 棋艺{

//    和类一样，里面可以变量， 常量和方法。

    var chess : 棋

    var chessArt : level

    let sss = 222

    func simple()->String{

        return "the person \(chess.simpleDescripation()) has \(chessArt.simple())"

    }





}

//结构体会自动给我们生成init方法

let 王五 = 棋艺(chess: 棋.象棋, chessArt: level.初级棋手)

print(王五.simple())

print(王五.chess)



//协议

protocol ExampelProtocol{



//    可以写变量 方法

//    协议中的变量 必须要有get方法 可以没有实现部分

//    协议 和 OC中的require协议是一样的 都是必须要遵从的

    var simple:String{



        get



        }

   mutating func adjust()

}

//swift 类 结构体 枚举 都可以遵从协议

class SimpleClass:ExampelProtocol{

    var simple = "a very simple class"

    func adjust() {

        simple += "an adjust 100%"

//        print("hello this is a Class Protocal")

    }

}

var sim = SimpleClass()

print(sim.adjust())

print(sim.simple)



//结构体 遵从协议

struct SimpleStruct:ExampelProtocol{

    var simple = "a very simple class"

//    mutating 用在结构体中 如果想要改变协议中的变量的值时 结构体默认是不允许去改变结构体中的变量的。包括协议的方法声明也要加这个关键字

  mutating  func adjust() {

       simple += "an adjust 100%"



    }



}

var  structExample = SimpleStruct(simple: "ewer")

print(structExample.simple)

print(structExample.adjust())



//枚举继承协议



//枚举如果没有类型的话 不能直接给变量赋值

//

enum SimpleEnum:ExampelProtocol{

//    我们只能重写继承协议里面的方法

    case one, two, three

    var simple :String{

        get{

            switch self{

            case .one:

                return "one"

            case .two:

                return "two"

            default :

                return "three"

            }

        }

    }

//    在改变成员变量的时候才要用到 mutating

    mutating func adjust() {

       print(simple)

    }

}





//延展  是给一个类写新的方法 也可以继承协议

extension Int:ExampelProtocol{

    var simple :String{

        return "a extension"

    }



    mutating func adjust() {

        print("very good")

    }

}

var ss1 = 13

print(ss1.simple)

print(ss1.adjust())