java - Errors In Polymorphism

Question

I am kinda new to java and I have a question about polymorphism and possible errors. Assume that we have this:

public interface Animal {
}

public abstract class Cat implements Animal{
}

public abstract class Fish implements Animal {
}

public class Salmon extends Fish{
}

public class Tiger extends Cat{
}

and Assume that we have something like this:

Animal t1 = new Tiger();
Fish f1 = new Salmon();
Tiger t2= new Tiger();
Salmon s1 = new Salmon();

What is The errors in following lines (Compile Time Error, Runtime Error or No Error):

Cat c1 = new Cat();
Cat c2 = (Tiger) t1;
Animal a1 = s1;
Animal a2 = new Animal();
Fish f1 = (Fish) t2;
Animal a3 = (Fish) s1;
Animal a4 = (Cat) new Tiger();
Cat c3 = (Cat) new Salmon();

I've Answered it like bellow but I've thought it's kinda weird that I found no Runtime Error. if all of them is correct can u make an example where we have runtime error (in this polymorphism concept)

My Answer:

a  compile error
b  no error
c  no error
d  compile error
e  compile error
f  no error
g  no error
h  compile error

question from:https://stackoverflow.com/questions/65934509/errors-in-polymorphism

Answer 1

Focusing on the part about "how to get to an exception at runtime".

You figured yourself that Cat c3 = (Cat) new Salmon(); is wrong. And obviously, the compiler can already tell you that.

Why? Because the compiler can "see" that you create a Salmon, and that you then want to treat that as Cat, which isn't meaningful.

The only thing you need to get "past" the compiler is to "hide" that fact, like:

Salmon s1 = new Salmon();
Animal a3 = (Fish) s1;
Cat c3 = (Cat) a3;

As soon as you introduce a3, you are able to "hide" the fact that s1 is actually a Salmon.

Of course: even in my example, a smarter compiler could understand that a3 must be a Salmon, can't be a Cat. But java plays it "simple and conservative" here. The compiler only recognizes the most basic casting violations, and for good or bad, the java language ignores many situations that could be detected at compile time, too. That makes it easier to implement compilers, the traddeoff is that your code is more exposed to such exceptions at runtime.