Confused of what's happening

oh but why did you say at first that the object cantains two methods(selectable(),onEat()) and ends up an error when trying to call the onEat method?

And what basically happens here Food newFood = (Food) selectable

a little program for you:

interface CanSwim {
    void swim();
}

interface CanFly {
    void fly();
}

class Plane implements CanFly {
    @Override
    public void fly() {
    }
}

class SeaPlane extends Plane implements CanSwim {
    @Override
    public void swim() {
    }
}

public class Airline {
    public static void s(CanSwim cs) {
        cs.swim();
    }

    public static void f(CanFly cf) {
        cf.fly();
    }

    public static void sf(SeaPlane sp) {
        sp.swim();
        sp.fly();
    }

    public static void main(String[] args) {
        SeaPlane fd = new SeaPlane();
        s(fd); // Treat it as a CanSwim
        f(fd); // Treat it as a CanFly
        sf(fd); // Treat it as an SeaPlane
    }
}

We have a class hierarchy here. SeaPlane inherits from Plane. Plane implements an interface and can fly. The SeaPlane implements an interface, too, and can swim. In addition to that we have a class (Airline) where we can test things. Here we add some static methods that take arguments of certain interfaces or classes. What you can see now is, that if you cast to a certain type, the object gets treated as if it is that type. If you cast a SeaPlane to a CanFly, you treat is as a CanFly and that just can fly. No other methods available for CanFly. To get all functionality back again, you'd need to cast the reference variable back to SeaPlane. Then you can use the interface (publically available set of methods) of the SeaPlane and that can swim and fly. There's a lot more involved. For a better understanding I suggest you search the web for some tutorials on oop and polymorphism (that isn't involved here).

@John "why did you first say that the object cantains two methods(selectable(),onEat()) and ends up with an error when trying to call the onEat method?" The object is an impalpable thing. It exists somewhere in memory. You can only work with it through the variable assigned it. You will only ever see the object as the variable that stores its reference. The variable used to access the object is like a sunglasses. If you use pink glasses, all objects will appear pink. But they are not pink in real. See also the attached image.

@John: "And what basically happens here: Food newFood = (Food) selectable;" See the attached picture: So, both of selectab1 and food2 variables are pointing to the same Food object, but with the one you will be able to access the onEat() method of the object, but with the other one not: selectab1.onEat(); // ERROR! food2.onEat(); // It works!

If this is indeed the case, I didn't know it. Thanx Gellert!

You're welcome:)

Thank you for the info thomas. the lesson about typecasting on reference is still unclear to me :3

When you upcast the interface (available methods) gets smaller so its called narrowing, and vice versa. is that right?

Yes, as I tried to explain in the other thread Try to imagine that with TV. I bet you already heared that but it's fitting really good. The object is a TV that you just control using a remote (that's the reference variable). The TV has a set of functions that you can access (with the correct remote). If you upcast, then you change remotes but that new remote has less buttons so you can't call all functions. However the TV is still a TV. Nothing has changed. Just the handle, the remote, the reference variable changes. That's the important thing you need to keep in mind. When casting the object itself doesn't change. You change the way how you can access that object.

hmm "You change the way how you can access the object" what do you mean by this? the TV? or you mean change the way how can i use that object. sorry im confused but im inderstanding it now thank you for the help ;)

The TV is the object with a fix set of fuctionality. The remote is the reference variable. Now you take the remote of a model with less functions and operate with that remote your TV. It works but with that remote you just can not invoke all functions. You treat your TV as if it is a smaller model. If you however take a remote of a TV with a richer feature set, then maybe weird things will happen (at least if you try that on objects that's the case). The TV doesn't have the functionality you send the commands to it.

@Thomas It's a very good example, i like it!!:)

@John: upcasting = moving up on the inheritance chain = the number of available methods are decreasing = but it's other name is widening!! Not narrowing. Because of the parent is a wider type than the child. Because you can store any child-type object in a parent-type variable. downcasting = moving down on the inheritance chain = the number of available methods are increasing = but it's other name is narrowing!! Not widening. Because of the child type is a narrower type than the parent. Because you can not store a parent-type object in a child-type variable.

;) Gellert, I liked the analogy as well. That's why I still remember it. And the explanation regarding narrowing/ widening that I know of I've already told John in his other thread (link above).

Thank you. you guys are awesome ;)

I compare the available methods to the scope of variables in a nested if/else statements(multiple). As you go into the nested if/else, the outer variables are available to the inner if/else's. However, as you come out of the inner if/else, the inner variables are not available to the outer if/else's.

That's the default bahaviour of local variables in blocks (not only restricted to if - else structures). A local variables scope is within the braces it is declared in.

{
    int a = 0;
    {
        int b = 1;
        a++; // a accessible
    }
    // b--; // won't compile, cannot resolve symbol
}

If you need a local variable you calculate inside an if-else block outside of that block then just declare it before entering that block.

int i = 0;
if (i < 10) {
    i++;
}
System.out.println(i);