I can already see you using the Bridge and/or Strategy pattern from the specs.
You'll also most likely end up using the Observer pattern.
Try not to be distracted by the specs too much. Break down the problem.
You're limited to 1000 points of units. What I'd do is have the army class abstractly contain a set of units to use (an array or list of units - your call).
The set of type of units will be set during construction of the army, but you may also want to provide functionality to set the type of units during run-time to show flexibility to the system (though this is most likely not required).
Each abstract unit has a cost() method that defines how much that unit will cost.
You van use a separate list that will be the result of populated units (obviously an implementation of a random generator and a data type that contains the max amount of cost for the army).
Each Army class (or class the encapsulates the units) can act as the Observable and signal to all units, or observers, within the given army to initiate an attack.
Implement an attack(Unit other) command for all units, and also a react(Unit fromUnit) command. Since the kind of attacks can vary, you may (or may not) want to consider using an encapsulated Action interface that has a method act() which defines what will be done during an attack or when one receives damage (though this may be overkill for this assignment).
The moment a unit has lost too much health due to attacks, you should unregister them from being an Observer to receive commands from the army class (because honestly they shouldn't receive commands when they're dead - they can't).
As for the range implementations, you may want to have some kind of number representation of the range returned by a method. Every unit has some kind of theoretical range. Consider mapping your units out on a grid - units can't attack anything beyond their range so obviously the range will be used as a condition for a unit relative to the closest target to it. In order for this to work, each unit in each army will have to somehow know where all other enemy units are before an attack. This can be done by the Observable army signaling the position of all targets (or just signaling which targets exist and supply an implementation of the unit coordinates to each individual unit to keep track of themselves).
Hopefully this was helpful.
-Alex
