Сужение и расширение класса

Теперь объявим в методе Cat метод, к примеру jump(); Мы можем создать переменную

Cat cat = new Cat();

и соответственно вызвать метод

cat.jump();

Но мы не можем сделать так:

Animal cat = new Cat();
cat.jump();

Почему? Потому что для компилятора в данном случае имеет значение только тип переменной, а не тип объекта, ссылка которого в эту переменную кладется. Т.е. компилятор смотрит на тип переменной cat, видит, что она Animal, смотрит в Animal - не видит в нем метода jump() и, соответственно, не дает нам выполнить этот код, и его не волнует, что в cat лежит ссылка на объект типа Cat, в котором этот метод есть.

Почему так происходит? Это связано с одним из базовых принципов ООП - полиморфизмом (в инете статей куча), и с тем, что джава- язык со статической типизацией. Поэтому, если мы хотим положить в переменную типа Cat объект, ссылка на который ранее лежала в переменной типа Animal, то мы должны это явно указывать в скобках

Animal animal = new Cat();
Cat cat = (Cat) animal;

Тем самым, комплиятор как бы снимает ответственность с себя и перекладывает ее на разработчика - если в объекте, который лежал в переменной animal не окажется методов, которые объявлены в классе Cat (а такое легко может случится - ведь Animal может быть классом-родителем у множества других классов), то вся ответственность за последующее исключение будет лежать на разработчике.

Спасибо. Появилось обманчивое ощущение, что всё ясно :)))

Илья, прочел еще раз и вот что еще хочу уточнить. "...комплиятор как бы снимает ответственность с себя и перекладывает ее на разработчика - если в объекте, который лежал в переменной animal не окажется методов, которые объявлены в классе Cat (а такое легко может случится - ведь Animal может быть классом-родителем у множества других классов), то вся ответственность за последующее исключение будет лежать на разработчике." Мне кажется это справедливым в следующей ситуации:

public class Animal {}
public class Cat extends Animal{}
public class Dog extends Animal{}

Animal animal = new Dog();
Cat cat = (Cat) animal;

То, что у animal класса Dog нет каких-то методов - так они появятся после переопределения в класс Cat. В случае, когда мы создаем объект так: Animal animal = new Dog(); то объекту animal будут доступны все методы класса Animal, только в том виде, как они переписаны в классе Dog. А когда мы animal приводим к классу Dog - мы расширяем переменную, ведь она получит ранее недоступные ей методы. А вот если мы создали Animal animal = new Dog(); и теперь решили эту переменную передать классу Cat - вот тут она все равно (скорей всего) получит расширение - дополнительные методы. Вот только доступные ей ранее методы класса Animal, возможно, будут переопределены и это, возможно, приведет к сбою в программе. И дополнительно: Когда переопределяем методы родительского класса, надо ли писать @Override ??

Если я правильно помню, то ява не позволит сделать такое

Animal animal = new Dog();
Cat cat = (Cat) animal;

Потому что скастовать таким образом можно только в пределах блока с instanceof

А аннотация @override,опять же если я правильно помню, нужна не для программы, а для программиста, и выкинет ошибку, если ты ошибёшься в названии метода, который хочешь переопределить

А вот если мы создали
Animal animal = new Dog();
и теперь решили эту переменную передать классу Cat - вот тут она все равно (скорей всего) получит расширение - дополнительные методы. Вот только доступные ей ранее методы класса Animal, возможно, будут переопределены и это, возможно, приведет к сбою в программе.

Суть опасности приведения типа не в переопределенных методах, а в том, что у класса Dog могут быть свои методы, у Cat свои. Предположим, что у Dog есть свой метод bark(); а у класса Cat метод jump(); Тогда мы можем сделать так:

Animal animal = new Dog();
Cat cat = (Cat) animal;
cat.jump();

и компилятор пропустит этот код, он начнет выполнение и выкинет исключение ClassCastException на стадии приведения animal к Cat. Вообще, у того же Эккеля про явное приведение типа написано, что это в принципе плохая практика и если в программе приходится ее использовать, то стоит задуматься о том, что архитектура программы неудачна. По поводу Override уже ответили выше - это только для разработчика, чтобы видеть, что ты верно прописал сигнатуру переопределяемого метода.

public class Test {
    public static void main(String[] args) {

       Animal animal = new Dog();
       Cat cat = (Cat) animal;
       cat.jump();

    }

    static class Animal {}
    static class Dog extends Animal {
        void bark() {}
    }

    static class Cat extends Animal {
        void jump() {}
    }

}

Дмитрий, компилятор позволит это сделать, но естественно исключение вылетит на стадии приведения. А вот идея будет подсказывать, что лучше добавить instanceof.

Как в данном случае

Animal animal = new Cat();
Cat cat = (Cat) animal;

может не оказаться методов в объекте Cat, которые объявлены в классе Cat? Просто мы ведь кладем в переменную animal ссылку на объект класса Cat, так разве тогда при присваивании ссылки на объект класса Cat переменной типа Cat нужно приведение? Ведь мы имеем дело с одним и тем же классом.

вы это знаете, а компилятор нет. В первой строке вы объявили, что переменная с типом Animal. Значит для компилятора там объект Animal или любого наследника (не важно какого). А вот когда кастуете, вы точно говорите компилятору "хочу чтобы с этим объектом обращались как с Cat, сделай из него Cat". Если у компилятора не получится, он кинет ошибку об этом. В данном случае все будет нормально.

Спасибо! Очень доступно.