Question

是否可以将子类对象添加到父类内的静态数组中？我想在创建的所有实例上运行一个函数。另一个SO问题描述了能够遍历一个数组来调用每个实例上的函数，我认为这也是我想要的最终结果，但我的问题是甚至将实例放入一个跟踪所有实例的静态数组中。

当然，我的代码更模块化，但这里是代码和层次结构的简化视图：

class Jungle {

    static var jungle: [Animals] = []

}

class Tigers: Animals {
    static var tigerPopulation: Int = 0

    override init(name:String){
        super.init(name: name)
        Tigers.tigerPopulation += 1
    }

    deinit {
        Tigers.tigerPopulation -= 1
    }

}

class Monkeys: Animals {
    static var monkeysPopulation: Int = 0


    override init(name: String){
        super.init(name: name)
        Monkeys.monkeysPopulation += 1
    }
    deinit {
        Monkeys.monkeysPopulation -= 1

    }

}

class Snakes: Animals {
    static var snakePopulation: Int = 0

    override init(name: String){
        super.init(name: name)
        Snakes.snakePopulation += 1
    }
    deinit {
        Snakes.snakePopulation -= 1
    }
}

我觉得我应该首先创建Jungle类，所以他们都会从丛林中继承我想但是我仍然难以理解如何将实例放入数组中。

Answer 1

不是尝试触发某些行为来增加初始化器中的猴子数，老虎数等，只需将所有内容添加到动物数组中，然后使用animals数组来计算出有多少Tigers /有蛇/猴子。

从长期来看，单个阵列的计数比拥有一堆不同的变量更容易，并确保它们是同步的（例如在deinit期间减少）。

这是你的丛林，动物和动物亚类的轻微改组：

class Jungle {

    var animals: [Animal] = []

    func addAnimal(animal: Animal) {
        animals.append(animal)
    }

    // this is a computed property, everytime you access it
    // via jungle.tigerPopulation, the code inside this statement
    // executes, and you get the value that is returned
    var tigerPopulation: Int {

        // tigers is a new array containing only tigers
        let tigers = animals.filter{ animal in
            return animal is Tiger
        }

        // return the number of items in the tigers array
        return tigers.count
    }
}

class Animal {
    let name: String
    init(name: String) {
        self.name = name
    }

    func sayHello() {
        print("I'm an animal")
    }
}

class Tiger: Animal {
    // tiger specific stuff
    override func sayHello() {
        print("I'm a tiger called", name)
    }
}

class Monkey: Animal {
    // monkey specific stuff
}

class Snake: Animal {
    // snake specific stuff
    override func sayHello() {
        print("I'm a snake called", name)
    }
}

需要指出的是，因为每个动物子类当前都在做相同的事情（分配名称），所以你不需要覆盖子类中的初始化程序 - 这就是类继承的价值！

如果动物必须做与其他动物不同的事情，您可以在将来有时覆盖子类。

这里发生的最有趣的事情是computed property通过过滤动物阵列中的老虎来计算老虎数量，并返回计数，这样你就不会手动+/- 1人口数，但只要你要求它就计算它。

然后你会使用你的丛林对象：

let jungle = Jungle()
// jungle.animals -> []
// jungle.animals.count -> 0
// jungle.tigerPopulation -> 0

jungle.addAnimal(animal: Tiger(name: "Tony"))
// jungle.animals -> [Tiger()]
// jungle.animals.count -> 1
// jungle.tigerPopulation -> 1

jungle.addAnimal(animal: Snake(name: "Susan"))
// jungle.animals -> [Tiger(), Snake()]
// jungle.animals.count -> 2
// jungle.tigerPopulation -> 1


for animal in jungle.animals {
    animal.sayHello()
}
// prints ->
// I'm a tiger called Tony
// I'm a snake called Susan

在swift中将对象添加到静态数组

1 个答案: