Работа с объектами в java?

Question

[UNy]

Пытаюсь разобраться с созданием объектов. Есть некий класс A для создания объекта мы пишем A a1 = new A(). Вроде бы просто. Затем появляется класс B который наследуется от класса A. Что значит такое создание объекта:
A a2 = new B();
Почему имена классов вначале и конце разные и что это значит?

Так же есть такой код:

class A{
    int q = 33;
    int sum(int a,int b){
        return a+b;
    }
}

class B extends A{
    int q = 32;

    int sum(int a, int b) {
        return a-b;
    }
}

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

        A a = new B();

        System.out.println(a.sum(1,2));
        System.out.println(a.q);

    }
}

Почему при вызове a.sum(1,2) вызывается метод класса B, а при вызове a.q вызывается переменная класса A?

Comments

[Игорь]

прочитайте хотябы самоучитель по java

Answer 1

[Cheypnow]

1. A a2 = new B(); означает что ты помещаешь объект дочернего класса в переменную родительского. Так можно и зачастую нужно, когда ты не знаешь точно какой из наследников будет использоваться или хочешь абстрагироваться от конкретной реализации.
2. a.sum(1,2) вызывает метод, переопределенный в дочернем классе. Т. к. он не имеет модификатора private, это работает.
3. При вызове a.q вызывается переменная класса A потому что поля не переопределяются.

Советую почитать про базу ООП: наследование. полиморфизм и инкапсуляцию.

Comments

[UNy]

Что значит: ты помещаешь объект дочернего класса в переменную родительского? можно поподробнее?

[Cheypnow]

UNy, new B() - создается объект класс В, который наследуется от А / является дочерним по отношению к классу А / расширяет класс А. Все эти формулировки эквивалентны.
A a2 - а2 является переменной типа А, а класс А является классом-родителем для класса В. То есть в переменную класса А можно поместить объект класса В.

[UNy]

Cheypnow, Но зачем это делать? Ведь у класса B есть всё от А класса + что-то своё, Зачем ему урезать свои возможности?

[Cheypnow]

UNy, какие возможности урезаются и в каком случае?

[pi314]

UNy, Снаружи никто не знает, какие урезаются и урезаются ли вообще. И не должен знать, ибо инкапсуляция. Принадлежность объекта к какому-то классу - это "гарантия" только того, что у экземпляра есть некие методы, но не того, как именно они реализованы внутри. Да, есть, конечно, принцип подстановки Лисков, но о нем не все знают, а из тех, кто знает, не все используют :) Вот весь этот пример как раз и есть на тему полиморфизма: вызвали метод sum() наследника (класса В), получили разность, вызвали этот же метод предка (класса А), получили сумму. Объект один и тот же, метод тот же самый, а результаты разные. Приведение типа для того и используется, чтоб, грубо говоря, взять объект/экземпляр/переменную тиа В, но "воспользоваться" ей, как если бы она была типа А.

[UNy]

pi314, Но ведь когда мы так делаем мы теряем переменные B класса. Почему просто не сделать A a = new A()?

[UNy]

Cheypnow, Например мы не можем использовать переменные B класса

[pi314]

UNy, Все верно. Поэтому, так делают не просто от балды, а только в случаях, когда именно это и нужно. В примере, конечно же, приведен упрощенный вариант, чтоб показать суть самой возможности. Реально никто не станет создавать экземпляр В, если прямо тут нужен А, и есть возможность и необходимость его создать. Но это далеко не всегда так. Класс А может быть, например, абстрактным. Или, у него нет публичного пустого конструктора, а только конструктор с параметрами, нужных значений для которых у нас в этом месте просто нет, т.к. код, который мы тут пишем, не отвечает за создание экземпляра, а просто должен им воспользоваться... например, нам в метод передали ссылку на где-то-там-почему-то-созданный экземпляр типа В, а нам от него нужно всего-то поведение базового класса А. Короче, есть варианты.
И, потом, что конкретно значит "теряем"?.. Теряем мы слева от приведения типа, т.е. в переменной типа А, которой присваивается значение. В правой части (там где new B() ) мы ничего не потеряли. Если нам нужно и то, и другое, можно было бы написать так:

B b = new B(); //создали экземпляр наследника и сохранили ссылку в переменной
A a = (A) b;      //привели его к базовому классу и сохранили в другой переменной

b.sum(); //тут пользуемся функционалом наследника
a.sum(); //тут пользуемся функционалом базового класса

...или, если нужно просто единоразово, не плодя переменные, можно так:

B b = new B();
//...тут делаем что-то там с b...

//... а потом вдруг
((A)b).sum(); //пользуемся ей, как А

//...и дальше, как ни в чем не бывало, пользуемся b

[UNy]

pi314, Спасибо за подробное объяснение) пойду читать про ООП.

[pi314]

UNy, Всегда пожалуйста. И еще совет, вдогонку - не чтитайте всякую лабуду, где про А и Б, сидевших на трубе. Читайте, где внятные и интуитивно понятные примеры из реального мира. ООП придумали для того, чтоб просто и логично моделировать объекты реального мира, и в нем все просто и естественно. Если кажется, что это не так, значит, автор учебника наводит тень на плетень и нужно читать другой ))

[UNy]

pi314, Можете что-то посоветовать? Нашел книгу Мэтта Вайсфельда - Объектно ориентированное мышление.

Answer 2

[pi314]

Принципиальная ошибка в понимании, видимо, заключается в формулировке "затем появляется"... Он появляется не "затем" - декларации обоих классов "появляются" во время написания кода и, соответственно, известны компилятору (compile time). А вот объекты, например, в результате выполнения строки A a1 = new A(); появляются во время работы программы (run time). Понимание этой разницы фундаментально важно!

А дальше все просто и становится на свои места. В строке A a = new B(); (на которую компилятор, кстати, будет ругаться) происходят сразу две вещи: во-первых, создается экземпляр класса B, во-вторых, он приводится по типу к классу А (что возможно, ибо B унаследован от А, и значит, имеет, как минимум, все те же члены класса) и ссылка на него присваивается переменной типа A. Компилятор код проглотит, но будет ругаться именно на то, что это приведение типа происходит неявно. Правильнее было бы указать его явно, вот так: A a = (А) new B(); Если бы В не был унаследован от А, компилятор выдал бы в этом месте ошибку и ничего бы не скомпилировал.

Чтоб убедиться, правильно ли Вы понимаете это дело, попробуйте теперь ответить на следующий вопрос: я написал, что "B унаследован от А"... Что это конкретно значти и когда это наследование "происходит"?

Последний вопрос, это про полиморфизм... почитайте вот тут: Почему полиморфизм так работает?