Question on Polyphormism

Given:
3. class Mammal {
4. String name = "furry ";
5. String makeNoise() { return "generic noise"; }
6. }
7. class Zebra extends Mammal {
8. String name = "stripes ";
9. String makeNoise() { return "bray"; }
10. }
11. public class ZooKeeper {
12. public static void main(String[] args) { new ZooKeeper().go(); }
13. void go() {
14. Mammal m = new Zebra();
15. System.out.println(m.name + m.makeNoise());
16. }
17. }

What is the result?
A. furry bray
B. stripes bray
C. furry generic noise
D. stripes generic noise
E. Compilation fails
F. An exception is thrown at runtime


Question: At first look - my answer seems to be (B). Is that right?
It is related to polyphormism -- line 14 can tell..

The answer should be A, run it and confirm for us.
Basically instance variables are resolved using the compile time type while the run time type is used to resolve methods.
So since m is a Mammal at compile time, m.name resolves to "furry " while m.makeNoise() will call the Zebra version of the method.

yes.

Its option (A).
I think i need to practise alot more! Quite weak on all these...
Thanks for your help friend :)

Stupid question maybe, but why is the name defined in both classes, and not set via a constructor? Doing this prevents certain types of polymorphism.

For example, let's say we added a getter to Mammal that returns the name. Unless we also add the getter to the Zebra class, it won't work as expected. (Added getName method and used a Zebra to store the Zebra object)

Code:

---

class Mammal
{
        String name = "furry ";

        String makeNoise()
        {
                return "generic noise";
        }
       
        public String getName()
        {
                return name;
        }
}

class Zebra extends Mammal
{
        String name = "stripes ";

        String makeNoise()
        {
                return "bray";
        }       

        // @Override
        // public String getName()
        // {
        // return name;
        // }
}

public class ZooKeeper
{
        public static void main(String[] args)
        {
                new ZooKeeper().go();
        }

        void go()
        {
                Zebra m = new Zebra();
                               
                // outputs furry bray (if Zebra.getName doesn't exist)
                // outputs stripes bray (if Zebra.getName exists)
                System.out.println(m.getName() + m.makeNoise());
        }
}

---

However, if we create a single name variable in the Mammal class, and set its value when constructing the object, we get the expected result. (Only added constructors to original code)

Code:

---

class Mammal
{
        String name;

        public Mammal()
        {
                this("furry ");
        }
       
        public Mammal(String name)
        {
                this.name = name;
        }
       
        String makeNoise()
        {
                return "generic noise";
        }
       
        public String getName()
        {
                return name;
        }
}

class Zebra extends Mammal
{
        public Zebra()
        {
                super("stripes ");
        }

        String makeNoise()
        {
                return "bray";
        }       
}

public class ZooKeeper
{
        public static void main(String[] args)
        {
                new ZooKeeper().go();
        }

        void go()
        {
                Mammal m = new Zebra();
                               
                // outputs stripes bray (as expected)
                System.out.println(m.name + m.makeNoise());
        }
}

---

No question is stupid on Java exams! :D

"name" is in both to see if people taking the test understand how the compiler and JVM work with this stuff.

Aren't the tests suppose to include the practical uses only? I mean, I did UIL in High school for computer science, and they asked some of the most bizarre questions pertaining to C++, many that I would call poor programming practices.

Quote:

---

Originally Posted by CodesAway

Aren't the testes suppose to include the practical uses only? ..

---

No .

Exactly.
They're testing technical knowledge, which includes understanding what is actually going on with polymorphism in Java. Knowing the answer to the above question means you are less likely to get caught out.