Adding objects to a static array in swift - arrays

Question

Is it possible to add subclassed objects to a static array inside the parent class? I would like to run a function on all instances created. Another SO question describes being able to loop over an array to call a function on each instance and I think this is the end result I would like as well but my problem is even getting the instances into a static array that keeps track of all instances.
Of course my code is more modular but here is a simplified view of the code and hierarchy:
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
}
}
I get the feeling that I should have created the Jungle class first so they all would subclass from Jungle I guess but I'm still stumped on how I would get the instances into an array.

Answer 1

Instead of trying to trigger some behavior to increase the monkey count, tiger count etc from within an initializer, it will be easer to just add everything to an animals array, and then use the animals array to figure out how many Tigers/Snakes/Monkeys there are.
Basing the count off that single array is going to be easier in the long term than having a bunch of different variables, and making sure they're in sync (e.g. by decreasing during deinit).
Here's a minor reshuffle of your jungle, animal, and animal subclasses:
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)
}
}
Something to point out is that because each of the animal subclasses are currently doing the same thing (assigning the name) you don't need to override the initializer in the subclasses - that's the value of class inheritance!
You can override the subclasses sometimes in the future if an animal has to do something that's different from other animals.
The most interesting thing that's happening here is the computed property that calculates the tiger population by filtering the tigers in the animals array, and returning the count, this way you're not manually +/- 1 the population count, but just calculating it whenever you ask for it.
Then you'd use your jungle object something like this:
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