Little visibility issue in my game

Question

Alright, so I got bored at work and started writing this game, and I grasp the concept of polymorphism, and inheritance, but the implimentation eludes me a bit.
Anyway the run down is, I have a super class called Mob, from that two classes are extended, human, and monster. from those, more classes are extended, such as Paladin (human) Dragon(monster) and so forth.
Both monsters, and humans have a common method of Attack(mob temp) which I put in the Mob class. This is fine and dandy up to this point.
In the Attack() method, Humans and monsters both have some different chararistics, such as humans can drink health/mana potions, and monsters can frenzy() etc. So, in the Attack() method, I have some logic to determine if it's a monster/human, and they are able to perform their unique actions.
Since however, that DrinkPotion() is in class human, Frenzy() is in class Monster etc, The compiler is telling me it cannot see those methods.
I may be going about them wrong, i'm just not sure though.
Also, in the class with Main, I have them declaired as
mob player;
mob CPU;
Then later, when the player chooses the class, I set the base class reference to the new derived class object,
Warrior warrior = new Warrior();
player = warrior;
I just don't know why class Mob can't see the methods in grandchildren classes such as Warrior. It is afterall a warrior object i'm performing the dot operator on, is it not? ( such as player.GetHeathPotionsLeft(); )
Any help is apreciated!

Answer 1

The thing is you shouldn't put the implementation of the "attack" method in Mob. The idea of polymorphism is that you can treat all "actors" in your game as instances of class Mob (and therefore to have an attack() methods), while leaving the actual implementation of the method up to the various subclasses. Those subclasses will be able to see the methods inside themselves just fine, your Mob class doesn't need to know about them.
So you could have something like this:public interface Mob {
public void attack(Mob target);
}and thenpublic class Monster implements Mob {
public boolean isAngry() { // could also be private
   // put code here to determine if the monster is angry
private void frenzy() { // private, only Monster itself needs to know this
   // put code here to put your monster into a frenzy
public void attack(Mob target) {
   if(isAngry()) {
    frenzy();
   // put code here to actually attack
}andpublic class Human implements Mob {
  public void attack(Mob target) {
    // put some code here to attack
}and last but not least:public class Paladin extends Human {
  private void pray() { // private, only Paladins need to know this
    // put code here that determines if the prayer is heard and what happens then
  public void attack(Mob target) {
    pray();
    super.attack(target); // super.something() means use the implementation of my parent class, in this case the normal Human attack().
}You could then use this from your main game class like so:....
  List<Mob> participants = ... (some list containing the actors, perhaps sorted by initiative)
  public void setup() {
    participants.add(new Human());
    participants.add(new Human());
    participants.add(new Paladin());
    participants.add(new Monster());
    participants.add(new Monster());
  // handle one turn of attacks in the game
  public void handleTurn() {
    for(int attackerIndex = 0; attackerIndex < participants.size(); attackerIndex++) {
      // note: all we need to know is that the attacker is-a Mob, even though it will actually be a monster, human or paladin
      Mob attacker = participants.get(attackerIndex);
      Mob target = getMostLikelyTargetFor(attacker); // somehow determine who gets attacked
      // because of polymorphism, this will use the implementation of the actual subclass with no casting necessary:
      attacker.attack(target);
...Hope this helps.