CodeGym/Help with Java Tasks/Cat or Tiger?

Level 27

03.04.2022
890views
14comments

Cat or Tiger?

Under discussion

Below are the instructions from Java Core Level 4, Lesson 3 Type casting. Widening and narrowing conversions My question is simple yet I can't establish an answer (that makes sense to me). Why would I need a type variable as a Cat and then assign it to a new object Tiger? It's a Tiger so should always be:-

Tiger tiger = new Tiger()

not

Cat cat = new Tiger();

Of course, I know there must be a good explanation😎

class Animal
{
public void doAnimalActions();
}class Cat extends Animal
{
public void doCatActions();
}class Tiger extends Cat
{
public void doTigerActions();
}

Here we have three class declarations: Animal, Cat, and Tiger. Cat inherits Animal. And Tiger inherits Cat. public static void main(String[] args)

{
Tiger tiger = new Tiger();
Cat cat = new Tiger();
Animal animal = new Tiger();
Object obj = new Tiger();
}

A Tiger object can always be assigned to a variable whose type is that of one of its ancestors. For the Tiger class, these are Cat, Animal, and Object.

Comments (14)

Popular
New
Old

You must be signed in to leave a comment

Thomas

Level 41 , Bayreuth, Germany

4 April 2022, 01:42

useful

Imagine a scrolling space shooter. You have a spaceship. It can shoot rockets and laser beams. You can temporarily call auxiliary spaceships to increase your firepower. And there are background objects you can collide with. And of course there are enemies in each level. Hundreds or even thousands if you add their missiles and lasers. Red spaceships, green ones, rotating ones, narrow fast ones, huge ones. And all of them you have to move, calculate the position, let them shoot, check collisions etc. I would create a class AbstractSprite, this has subclasses AbstractShapeSprite (for background objects, for which you only need an outline to check collisions) and AbstractImageSprite. These are all the others that have a mapped image and move. From this I derive all sprites I need RedSpaceShip, BlueSpaceShip, RotatingSpaceShip, PlayerShip, PlayerHelper, Rocket, Mine, LaserBeam, BossShip, whatever. Now all sprites are initalized and stored in a list or array as the base class AbstractSprite (or maybe you split that into AbstractShapeSprite and AbstractImageSprite). Without storing the sprites in a list, I would have to call all the commands for moving and collision checking and painting separately. But I create a thread and call the needed methods on the supertypes of the sprites. This is then only a few lines of code. I can also easily control the update process. Only the active sprites need to be recalculated. I do the same when painting. Only visible sprites have to be displayed.... all this is done with a few lines, as I said, if you use the base class type.

Thomas

Level 41 , Bayreuth, Germany

4 April 2022, 01:44

useful

As (pseude)code the game loop would look like this... that's all (that code is not from a scrolling shooter but from my breakout clone (I stripped a few lines). But it would be exactly the same for that scroller).

@Override
public void run() {
    try {
        while (true) {
            if (!pausing) {
                updateComponent();
            }
            repaint(); // invokes paintComponent()
            Thread.sleep(25);
        }
    } catch (InterruptedException ignored) { }
}

public void updateComponent() {
    for (AbstractSprite sprite : sprites) {
        if (sprite.isActive()) {
            sprite.updateSprite();
        }
    }
}

@Override
public void paintComponent(Graphics g) {
    for (AbstractSprite element : sprites) {
        if (sprite.isVisible()) {
            sprite.paintSprite(g);
        }
    }
}

Or we can stick with cats and imagine a shelter class. The shelter can take tigers, or Siamese cats, or or.... Now you can write a takeIn() method for each type of cats (or animals) or one for each specific object.

public class CatShelter {
    public Shelter takeIn(Cat cat) { ... }
    // or for each object
    public Shelter takeIn(Tiger tiger) { ... }
    public Shelter takeIn(SiameseCat siameseCat) { ... }
    // ...
}

Guadalupe Gagnon

Level 37 , Tampa, United States

4 April 2022, 13:18

useful

Here is a different (maybe easier to understand) example going along with what Thomas is explaining:

class Animal {
    String sounds;
}

class Fish extends Animal{
    Fish(){
        sounds = "Gurgle Pop";
    }
}

class Dog extends Animal {
    Dog() {
        sounds = "Bark!";
    }
}

class Sheep extends Animal{
    Sheep() {
        sounds = "Baaah!";
    }
}

class Bird extends Animal {
    Bird() {
        sounds = "tweet tweet";
    }
}

public class Solution {
    public static void main(String[] args) throws Exception {
        communicate(new Sheep());
        communicate(new Dog());
        Animal fish = new Fish();
        Bird bird = new Bird();
        communicate(fish);
        communicate(bird);
    }

    static void communicate(Animal x){
        System.out.printf("The %s say '%s'\n", x.getClass().getSimpleName(), x.sounds);
    }
}

Guadalupe Gagnon

Level 37 , Tampa, United States

4 April 2022, 13:43

useful

In this code there are a bunch of classes that extend the Animal class. Each class sets the 'sounds' variable to something that makes sense. This is lines 1-27, hopefully easy to understand. Now on line 39, inside the Solution class, there is a method that takes in an Animal object as an argument and then will print to the screen a little message where the passed in Animal will say something. This is going to use a object orientated programming concept called polymorphism, where variables of one class can be declared and then initialized to objects of any descendent class. Then, inside the main method (lines 31-36), this concept is tested by passing in different objects of various classes to demonstrate that the one method can handle them all. Because of polymorphism I wouldn't need to code a communicate() method for each object type:

communicate(Bird x) { ... }
communicate(Fish x) { ... }
etc

This is the same concept being used with the Sprite example Thomas shared.

Jcode

Level 27 , United Kingdom

4 April 2022, 14:18

Thanks, guys for your input. Using the Animal example I can see how useful passing any type of Animal into a method and it looking in the subclass to display the animal-specific sound. It really shows the power of polymorphism to simplify our code. I have no problem understanding that. I loaded the code into IntelliJ and everything worked as expected. My sticking point is similar to the Cat/Tiger example.

Animal fish = new Fish();
Bird bird = new Bird();

Both of the above lines of code allows our method to locate the correct animal sound. So why would we ever need to use:-

Animal fish = new Fish();

The following line works exactly the same:-

Fish fish = new Fish();

Both work because previously we declared Fish extends Animal.

Guadalupe Gagnon

Level 37 , Tampa, United States

4 April 2022, 15:01

It all depends on what functionality the specific block of code needs, as well as your preference, for the particular objects being interacted with. If we extend my example by extending the Fish class to add an escape() method with 2 subclasses that use it:

class Fish extends Animal{
    Fish(){
        sounds = "Gurgle Pop";
    }

    void escape() {};
}

class CatFish extends Fish {
    void escape() {
        System.out.println("The fish hides under a rock");
    }
}

class FlyingFish extends Fish {
    void escape() {
        System.out.println("The fish jumps out of the water and glides away");
    }
}

In the main() method we can use

public static void main(String[] args) throws Exception {
   Fish x = new CatFish();
   x.escape();

   FlyingFish y = new FlyingFish();
   y.escape();

   Animal z = new FlyingFish();

   z.escape(); // !!This line is an ERROR. Code won't compile with it
}

I can use the one of the new classes as a variable and call the method; I can use the parent class Fish and call the method; however I can not use the class Animal. Alternatively I couldn't use one of the other classes that are not in the Fish class tree. This is because the method is defined in the Fish class and will not be accessible by any variable that is not a Fish or descendent. Therefore, in a block of code that needs to call the escape() method it wouldn't make sense to declare the variables as type Animal, which is what a Fish is, because you need the functionality of that method that is declared in the Fish class. You can extend this example infinitely and the answer to what type of variable type you should use is the one that allows all functionality that you need in the block of code you are writing.

Guadalupe Gagnon

Level 37 , Tampa, United States

4 April 2022, 15:23

As you are programming you will start creating larger and larger programs. Eventually you will run into situations where multiple classes in a program will have behavior that is shared amongst them. In that case you can create a parent class for them and move the shared behavior into the parent class, removing all those lines of code from each child class. The Sprite class from Thomas's post is a great example. Sprite's need to be drawn to the screen, however there are MANY different game components that are sprites. Player character, monsters, destructible environment pieces, NPC's, etc. While each one of those need to be drawn to the screen, they all have wildly different behavior beyond that. Also, with a game, there are going to be many different areas of code. When the code needs to draw it makes sense to use the Sprite call for the variable of each object, but in the area of code where the player attacks another attackable object it wouldn't make sense to use Sprite because the code dictating attacking wouldn't be there. There would most likely be a base class that describes anything that the player can attack that would be the choice for that block of code.

Jcode

Level 27 , United Kingdom

4 April 2022, 18:14

It is very interesting using your code and working through the error to try to fix it.

Animal z = new FlyingFish();
z.escape(); // !!This line is an ERROR. Code won't compile with it

FlyingFish y = new FlyingFish();// This works
y.escape();

Fish w = new FlyingFish();// This also works. I added it as an extra test.
w.escape();

Then I compare the Fish class to the Animal class. We have an empty method for escape() in Fish but not in Animal. If I move the empty method to Animal everything works fine. Logically, we would expect Animal to have an escape method as all animals may escape ... 'cat climbs a tree, 'rabbit runs down a hole' etc. I understand it is an example, so in no way a criticism. In fact, it has got me thinking more deeply about how the JVM/compiler interprets our code. The CG tasks tend to test a very narrow well defined aspect of Java. I sometimes get a solution without really understanding why it works (Im sure I'm not alone🙂). My thoughts at this stage are, that the 1st example shows that providing we are passing an animal to our method, a different variable type to our instance class makes no difference.

Animal fish = new Fish();
Bird bird = new Bird();

Both work when passed to:-

static void communicate(Animal x){
        System.out.printf("The %s say '%s'\n", x.getClass().getSimpleName(), x.sounds);
    }

The 2nd example shows that if we have a different variable type to our instance class and then try to use a method in our instance class that doesn't exist in our variable type(class) then the compiler complains.

Jcode

Level 27 , United Kingdom

4 April 2022, 18:15

The example that's missing is where upcasting our Tiger to a Cat provides any benefit. All it appears to do is restrict our Tiger to the more limited Cat behaviours. That feels like a backward step.

Guadalupe Gagnon

Level 37 , Tampa, United States

4 April 2022, 19:08

👏 *applause* I don't take anything as criticism. Using analogies for learning programming concepts is not going to be 100% "correct", its just to help with understanding, and it sounds like you are expanding your understanding of this concept. Here is a little bit that is already implemented in Java. Take the ArrayList<> class. It is defined as:

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

This means that it extends the AbstractList<> class as well as implements the List<>, RandomAccess, Cloneable, and Serializable interfaces. We can declare a variable of any one of these and set the object to ArrayList. We could also look at any of those classes/interfaces to see if they extend/implement any other classes or interfaces, which can be used to store an ArrayList object:

public static void main(String[] args) {
   AbstractList<Object> x = new ArrayList<>();
   List<Object> y = new ArrayList<>();
   Cloneable c = new ArrayList<>();
   Serializable s = new ArrayList<>();
   Collection<Object> co = new ArrayList<>(); // ** see note **
}

** The AbstractList class extends AbstractCollection which then extends Collection ** Here I used multiple different classes and interfaces as variables and initialized the object of each as ArrayList. For what we have been discussing in this thread, doing this doesn't make sense as we could (and should) declare the variable type as the object type. The benefit to using polymorphism though will be in other parts of code that have specific purposes. For example say you had a method that serialized everything that could be serialized. Would you want to make a new method for each and every object type?

Guadalupe Gagnon

Level 37 , Tampa, United States

4 April 2022, 19:31

"The example that's missing is where upcasting our Tiger to a Cat provides any benefit. All it appears to do is restrict our Tiger to the more limited Cat behaviours. That feels like a backward step." It doesn't make sense per se. This task is demonstrating that it can be done, by using a very abstract task that doesn't have a specific reason to do so. If the block of code used only state and behavior that was defined in the Cat class then you wouldn't need the Tiger class even though the actual object is a Tiger. It is all situational. In large programs, not these small tasks in codegym, objects become very abstract and the point where they are initialized is not where they are used.

Guadalupe Gagnon

Level 37 , Tampa, United States

4 April 2022, 19:47

This is the example I read in a book that made the light bulb go off in my head:

public class Solution {
    public static void main(String[] args) {
        String[] temp = {"1", "2", "3", "4", "5", "6", "7", "8"};
        ArrayList<String> strngs = new ArrayList<>();
        HashSet<Integer> ints = new HashSet<>();
        HashMap<String, Integer> map = new HashMap<>();

        for(String x : temp){
            strngs.add(x);
            Integer y = Integer.parseInt(x);
            ints.add(y);
            map.put(x,y);
        }

        System.out.println("Printing ArrayList:");
        print(strngs.iterator());
        System.out.println("\nPrinting HashSet:");
        print(ints.iterator());
        System.out.println("\nPrinting HashMap:");
        print(map.entrySet().iterator());

        System.out.println("\nAND we can print the String[]:");
        print(Arrays.stream(temp).iterator());
    }

    static void print(Iterator list){
        while(list.hasNext()) System.out.println(list.next());
    }

The print method is the magic. It can accept ANY Iterator (which all collections can produce) and print it out regardless of what the collection is and what it contains. Along with what I included you can pass it classes such as Vector, Queue, Deque, TreeSet, LinkedList etc. You don't need to write any other code to handle each and every type of Collection.

Jcode

Level 27 , United Kingdom

5 April 2022, 01:51

Thanks Guadalupe for your contributions (the snippets of code really helped). It has certainly improved my understanding. I'm not quite at the light bulb moment yet but super motivated to make progress on the course. I'm looking forward to the Collections quest on CG. Understanding the inner workings of Collections is like a crash course in OOPs all on its own! Speak soon, Jason

Guadalupe Gagnon

Level 37 , Tampa, United States

5 April 2022, 13:13

Do the multithread quest first. I know codegym allows you to choose what to do after core, however the lessons and task make it seem like they expect students to do multithread and then collections. There is a HUGE jump in difficulty if you do the collections quest first.