第三周第四天代码

第三周第四天

分数类，运算符重载，欧几里得算法

// 短除法(欧几里得算法)
// x和y的最大公约数跟y%x和x的最大公约数是一样的
// Greatest Common Divisor
func gcd(x: Int, _ y: Int) -> Int {
    if x > y {
        return gcd(y, x)
    }
    else if y % x != 0 {
        return gcd(y % x, x)
    }
    else {
        return x
    }
}

class Fraction {
    private var _num: Int
    private var _den: Int
    var info: String {
        get {//分子为0 或者分母为1都返回分子
            return _num == 0 || _den == 1 ? "\(_num)" : "\(_num)/\(_den)"
        }
    }
    init(num: Int, den: Int) {
        _num = num
        _den = den
        simplify()
        normalize()
    }
   //返回类型尽量用自己的少用初始的
    func add(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._den + other._num * _den, den: _den * other._den)
    }
    func sub(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._den - other._num * _den, den: _den * other._den)
    }
    func mul(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._num, den: _den * other._den)
    }
    func div(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._den, den: _den * other._num)
    }
    func normalize() -> Fraction {
        if _den < 0 {
            _num = -_num
            _den = -_den
        }//如果分母为负数分子分母同时取相反数
        return self
    }
    func simplify() -> Fraction {
        if _num == 0 {
            _den = 1
        }
        else {
            let x = abs(_num)
            let y = abs(_den)
            let g = gcd(x, y)
            _num /= g
            _den /= g
        }
        return self
    }
}

// 运算符重载(为自定义的类型定义运算符)

func +(one: Fraction, two: Fraction) -> Fraction {
    return one.add(two)
}

func -(one: Fraction, two: Fraction) -> Fraction {
    return one.sub(two)
}

func *(one: Fraction, two: Fraction) -> Fraction {
    return one.mul(two)
}

func /(one: Fraction, two: Fraction) -> Fraction {
    return one.div(two)
}

学生类，文档注释，属性的分类

// 存储属性通常是private的 因为数据要保护起来
// 方法一般是public的 因为方法是对象接受的消息
// 如果自定义的类没有打算在其他项目中使用 可以不写访问修饰符
// 直接使用默认的internal修饰符表示在本项目中公开对其他项目私有

/// 学生
public class Student {
    private var _name: String
    private var _age: Int
    
    /// 学生姓名隐去最后一个字符
    public var name: String {
        get {
            let displayName = _name.substringToIndex(_name.endIndex.advancedBy(-1))
            return displayName + "*"
        }
    }
    
    /// 学生的年龄
    public var age: Int {
        get { return _age }
    }
    
    /**
     初始化方法
     - parameter name: 姓名
     - parameter age:  年龄
     */
    public init(name: String, age: Int) {
        _name = name
        _age = age
    }
    
    /**
     吃饭
     - parameter food: 吃的东西
     */
    public func eat(food: String) {
        print("\(_name)正在吃饭.")
    }
    
    
    /**
     学习
     - parameter courseName: 课程的名称
     - parameter hour: 学习时间
     - returns: 学会了返回true否则返回false
     */
    public func study(courseName: String, hour: Int) -> Bool {
        print("\(_name)正在学习\(courseName).")
        return hour > 180 ? true : false
    }
    
    /**
     看片
     */
    public func watchJapaneseAV() {
        if _age >= 18 {
            print("\(_name)正在观看岛国爱情动作片.")
        }
    }
}

一张牌类

import Foundation

enum Direction: Int {
    case Up, Right, Down, Left
}

// GET: 枚举是定义符号常量的最佳方式
// GET: 符号常量总是优于字面常量
/**
 花色的枚举
 
 - Spade:   黑桃
 - Heart:   红心
 - Club:    草花
 - Diamond: 方块
 */
enum Suite: String {
    case Spade = "♠️"//特殊字符无法显示
    case Heart = "❤️"
    case Club = "♣️"
    case Diamond = "♦️"
}

/// 一张牌
class Card {
    var suite: Suite
    var face: Int
    /**
     初始化方法
     - parameter suite: 花色
     - parameter face:  点数
     */
    init(suite: Suite, face: Int) {
        self.suite = suite
        self.face = face
    }
    /// 牌的信息
    var info: String {
        get {
            var str = suite.rawValue
            switch face {
            case 1: str += "A"
            case 11: str += "J"
            case 12: str += "Q"
            case 13: str += "K"
            default: str += "\(face)"
            }
            return str
        }
    }
}

一副牌类

import Foundation

func randomInt(min: UInt32, _ max: UInt32) -> Int {
    return Int(arc4random_uniform(max - min + 1) + min)
}

/// 一副牌
class Poker {
    var cardsArray: [Card] = []
    
    init() {
        reset()
    }
    
    /**
     重置所有的牌
     */
    func reset() {
        // 移除数组中剩下的牌
        cardsArray.removeAll()
        // 将52张牌按照黑红梅方的顺序放到数组中
        let suitesArray = [Suite.Spade, .Heart, .Club, .Diamond]
        for suite in suitesArray {
            for face in 1...13 {
                let card = Card(suite: suite, face: face)
                cardsArray.append(card)
            }
        }
    }
    
    /**
     洗牌
     */
    func shuffle() {
        // 洗牌之前先重置所有的牌
        reset()
        // 通过随机乱序的方式打乱牌的位置
        for i in 0.. Card? {
        if hasMoreCards {
            return cardsArray.removeFirst()
        }
        return nil
    }
    
    /// 还有没有更多的牌
    var hasMoreCards: Bool {
        get { return cardsArray.count > 0 }
    }
}

玩家类

import Foundation

func <(one: Card, two: Card) -> Bool {
    return one.face < two.face
}

class Player {
    var nickname: String
    var cardsOnHand: [Card] = []
    
    init(nickname: String) {
        self.nickname = nickname
    }
    
    func getOneCard(card: Card) {
        cardsOnHand.append(card)
    }
    
    func sortCards() {
        cardsOnHand.sortInPlace(<)
    }
}

调用这些类，和这些类的展示

import Foundation

func showPlayerCards(player: Player) {
    print("\(player.nickname)", terminator: ": ")
    player.sortCards()
    for card in player.cardsOnHand {
        print(card.info, terminator: " ")
    }
    print("")
}

// 扑克游戏
let p = Poker()
p.shuffle()

let playersArray = [
    Player(nickname: "张尼玛"),
    Player(nickname: "王尼玛"),
    Player(nickname: "李尼玛"),
    Player(nickname: "刘尼玛")
]

for _ in 1...3 {
    for player in playersArray {
        if p.hasMoreCards {
            player.getOneCard(p.deal()!)
        }
    }
}

for player in playersArray {
    showPlayerCards(player)
}