ios - 将两个类合并为一个类

Question

我有两个类:1. 分数类:分子和分母 AND 2. OperationWithFractions 类执行计算，例如将两个分数相加并将结果表示为字符串分数(例如 32/5)。

它有效，但我想通过将两个类合并到一个类中来简化，因此所有属性、方法和初始化程序都将在同一个保护伞下。

class Fraction {
    var numerator = 0
    var denominator = 0

    init (_ numer: Int, _ denom: Int){
        self.numerator = numer
        self.denominator = denom
    }
}

class OperationWithFractions {
    var fraction1: Fraction
    var fraction2: Fraction

    init(_ fraction1: Fraction, _ fraction2: Fraction) {
        self.fraction1 = fraction1
        self.fraction2 = fraction2
    }

    func addFractions()->String {
        var result = ""

        result = "\(fraction1.numerator * fraction2.denominator + fraction1.denominator * fraction2.numerator) / \(fraction1.denominator * fraction2.denominator)"

        return result
    }
}

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

        let result = OperationWithFractions(Fraction(5, 10), Fraction(10, 20)).addFractions()
        print(result)

        let result2 = OperationWithFractions(Fraction(10, 2), Fraction(8, 2)).addFractions()
        print(result2)
    }
}

Answer 1

两个分数相加应该返回一个 Fraction，而不是一个字符串。转换仅当您需要文本表示(例如打印最终结果)时才使用字符串。

算术运算可以作为 运算符 来实现分数类型:

struct Fraction {
    // ...

    static func +(lhs: Fraction, rhs: Fraction) -> Fraction { ... }
}

这允许你写

let result = Fraction(1, 2) + Fraction(-1, 6)

与引用类型和常量属性相比，也更喜欢值类型在变量属性上。第一个实现可能是

struct Fraction {
    let numerator: Int
    let denominator: Int

    init (_ numer: Int, _ denom: Int) {
        self.numerator = numer
        self.denominator = denom
    }

    static func +(lhs: Fraction, rhs: Fraction) -> Fraction {
        return Fraction(lhs.numerator * rhs.denominator + lhs.denominator * rhs.numerator,
                        lhs.denominator * rhs.denominator)
    }
}

采用CustomStringConvertible协议(protocol)提供文本表示:

extension Fraction: CustomStringConvertible {
    var description: String {
        return "\(numerator)/\(denominator)"
    }
}

这已经有效了

// Compute 1/2 - 1/6 + 1/3:
let result = Fraction(1, 2) + Fraction(-1, 6) + Fraction(1, 3)
print(result) // 24/36

但结果并不完全令人满意，因为它是没有减少到最低的通用条款。还有

 print(Fraction(2, -3)) // 2/-3

不是最优的。

这是一个稍微复杂一点的版本，其中结果被减少到最低限度。除了gcd 实用函数，一切都在里面定义分数类型。

// Greatest common divisor
func gcd(_ a : Int, _ b : Int) -> Int {
    var (a, b) = (a, b)
    while b != 0 {
        (a, b) = (b, a % b)
    }
    return a
}

struct Fraction {
    let numerator: Int
    let denominator: Int

    init (_ numer: Int, _ denom: Int, reduce: Bool = false) {
        if reduce {
            let commonFactor = gcd(numer, denom)
            self.numerator = numer / commonFactor
            self.denominator = denom / commonFactor
        } else {
            self.numerator = numer
            self.denominator = denom
        }
    }

    static func +(lhs: Fraction, rhs: Fraction) -> Fraction {
        return Fraction(lhs.numerator * rhs.denominator + lhs.denominator * rhs.numerator,
                        lhs.denominator * rhs.denominator, reduce: true)
    }
}

extension Fraction: CustomStringConvertible {
    var description: String {
        if denominator == 1 {
            return "\(numerator)"
        } else if denominator < 0 {
            return "\(-numerator)/\(-denominator)"
        } else {
            return "\(numerator)/\(denominator)"
        }
    }
}

示例用法:

// Compute 1/2 - 1/6 + 1/3:
let result = Fraction(1, 2) + Fraction(-1, 6) + Fraction(1, 3)
print(result) // 2/3

现在你可以添加其他运算符(例如-、*、/)、错误检查(例如，对于零分母或整数溢出)，其他实例方法(例如“绝对值”)等。