26

26


Синтаксис композиции очевиден, но для наследования существует совер­шенно другая форма записи. При использовании наследования вы фактически говорите: «Этот новый класс похож на тот старый класс». В программе этот факт выражается перед фигурной скобкой, открывающей тело класса: сначала записывается ключевое слово extends, а затем имябазового(base)класса.Тем самым вы автоматически получаете доступ ко всем полям и методам базового класса. Пример:

//. reusing/Detergent.java
// Синтаксис наследования и его свойства
import static net mindview util Print.*.
class Cleanser {'
private String s = "Cleanser", public void append(String a) { s += a; } public void diluteO { append( dilutee)"), } public void applyO { appendC applyO"); } public void scrubO { appendC scrubO"): } public String toStringO { return s. } public static void main(String[] args) { Cleanser x = new CleanserO, x diluteO: x applyO, x scrubO; print(x);
}
}
public class Detergent extends Cleanser { II Изменяем метод- public void scrubO {
appendC' Detergent.scrubO").
super scrubO, // Вызываем метод базового класса
}
11 Добавляем новые методы к интерфейсу public void foamO { appendC foamO"), } // Проверяем новый класс, public static void main(String[] args) { Detergent x = new DetergentO, x.diluteO, x.applyO, x scrubO; x. foamO; print(x);
print("Проверяем базовый класс"); Cleanser main(args);
}
} /* Output
Cleanser diluteO applyO Detergent.scrub() scrubO foamO Проверяем базовый класс Cleanser diluteO applyO scrubO */// ~
Пример демонстрирует сразу несколько особенностей наследования. Во-первых, в методе класса Cleanser append() новые строки присоединяются к строке s оператором += — одним из операторов, специально «перегруженных» создателями Java для строк (String).
Во-вторых, как Cleanser, так и Detergent содержат метод main(). Вы можете оп­ределить метод main() в каждом из своих классов; это позволяет встраивать тес­товый код прямо в класс. Метод main() даже не обязательно удалять после за­вершения тестирования, его вполне можно оставить на будущее.
Даже если у вас в программе имеется множество классов, из командной строки исполняется только один (так как метод main() всегда объявляется как public, то неважно, объявлен ли класс, в котором он описан, как public). В нашем примере команда java Detergent вызывает метод Detergent.mainQ. Однако вы так­же можете использовать команду java Cleanser для вызова метода Cleanser.main(), хотя класс Cleanser не объявлен открытым. Даже если класс обладает доступом в пределах класса, открытый метод main() остается доступным.
Здесь метод Detergent.main() вызывает Cleanser.main() явно, передавая ему собственный массив аргументов командной строки (впрочем, для этого годится любой массив строк).
Важно, что все методы класса Cleanser объявлены открытыми. Помните, что при отсутствии спецификатора доступа, член класса автоматически получает доступ «в пределах пакета», что позволяет обращаться к нему только из теку­щего пакета. Таким образом,в пределах данного пакетапри отсутствии специ­фикатора доступа вызов этих методов разрешен кому угодно — например, это легко может сделать класс Detergent. Но если бы какой-то класс из другого па­кета был объявлен производным от класса Cleanser, то он получил бы доступ только к его public-членам. С учетом возможности наследования все поля обыч­но помечаются как private, а все методы — как public. (Производный класс также получает доступ к защищенным (protected) членам базового класса, но об этом позже.) Конечно, иногда вы будете отступать от этих правил, но в любом случае полезно их запомнить.
Класс Cleanser содержит ряд методов: append(), dilute(), apply(), scrub() и toString(). Так как класс Detergentпроизведенот класса Cleanser (с помощью ключевого слова extends), он автоматически получает все эти методы в своем интерфейсе, хотя они и не определяются явно в классе Detergent. Таким обра­зом, наследование обеспечивает повторное использование класса.
Как показано на примере метода scrub(), разработчик может взять уже суще­ствующий метод базового класса и изменить его. Возможно, в этом случае по­требуется вызвать метод базового класса из новой версии этого метода. Однако в методе scrub() вы не можете просто вызвать scrub() — это приведет к рекурсии, а нам нужно не это. Для решения проблемы в Java существует ключевое слово super, которое обозначает «суперкласс», то есть класс, производным от которого является текущий класс. Таким образом, выражение super.scrub() обращается к методу scrub() из базового класса.
При наследовании вы не ограничены использованием методов базового класса. В производный класс можно добавлять новые методы тем же способом, что и раньше, то есть просто определяя их. Метод foam() — наглядный пример такого подхода.
В методе Detergent.main() для объекта класса Detergent вызываются все методы, доступные как из класса Cleanser, так и из класса Detergent (имеется в виду ме­тод foam()).
Инициализация базового класса
Так как в наследовании участвуют два класса, базовый и производный, не сразу понятно, какой же объект получится в результате. Внешне все выглядит так, словно новый класс имеет тот же интерфейс, что и базовый класс, плюс еще не­сколько дополнительных методов и полей. Однако наследование не просто ко­пирует интерфейс базового класса. Когда вы создаете объект производного класса, внутри него содержитсяподобъектбазового класса. Этот подобъект вы­глядит точно так же, как выглядел бы созданный обычным порядком объект ба­зового класса. Поэтому извне представляется, будто бы в объекте производного класса «упакован» объект базового класса.
Конечно, очень важно, чтобы подобъект базового класса был правильно ини­циализирован, и гарантировать это можно только одним способом: выполнить инициализацию в конструкторе, вызывая при этом конструктор базового класса, у которого есть необходимые знания и привилегии для проведения инициали­зации базового класса. Java автоматически вставляет вызовы конструктора ба­зового класса в конструктор производного класса. В следующем примере задей­ствовано три уровня наследования:
//: reusing/Cartoon.java
// Вызовы конструкторов при проведении наследования, import static net.mindview.util.Print.*,
class Art {
ArtO { print("Конструктор Art"); }
}
class Drawing extends Art {
DrawingО { print("Конструктор Drawing"); }
}
public class Cartoon extends Drawing {
public CartoonO { print("Конструктор Cartoon"); } public static void main(String[] args) { Cartoon x = new CartoonO;
}
} /* Output; Конструктор Art Конструктор Drawing Конструктор Cartoon * ///:-
Как видите, конструирование начинается с «самого внутреннего» базового класса, поэтому базовый класс инициализируется еще до того, как он станет доступным для конструктора производного класса. Даже если конструктор класса Cartoon не определен, компилятор сгенерирует конструктор по умолча­нию, в котором также вызывается конструктор базового класса.
Конструкторы с аргументами
В предыдущем примере использовались конструкторы по умолчанию, то есть конструкторы без аргументов. У компилятора не возникает проблем с вызовом таких конструкторов, так как вопросов о передаче аргументов не возникает. Если класс не имеет конструктора по умолчанию или вам понадобится вызвать конструктор базового класса с аргументами, этот вызов придется оформить явно, с указанием ключевого слова super и передачей аргументов:
//: reusing/Chess.java
// Наследование, конструкторы и аргументы.
import static net.mindview.util.Print.*;
class Game {
Game(int i) {
print("Конструктор Game"),
}
}
class BoardGame extends Game { BoardGame(int i) { super(i);
print("Конструктор BoardGame");
}
}
public class Chess extends BoardGame { Chess О {
super(ll);
print("Конструктор Chess");
}
public static void main(String[] args) { Chess x = new ChessO:
}
} /* Output- Конструктор Game Конструктор BoardGame Конструктор Chess *///:-
Если не вызвать конструктор базового класса в BoardGame(), то компилятор «пожалуется» на то, что не может обнаружить конструктор в форме Game(). Вдобавок вызов конструктора базового класса должен быть первой командой в конструкторе производного класса. (Если вы вдруг забудете об этом, компи­лятор вам тут же напомнит.)
Делегирование
Третий вид отношений, не поддерживаемый в Java напрямую, называетсяделе­гированием.Он занимает промежуточное положение между наследованием и композицией: экземпляр существующего класса включается в создаваемый класс (как при композиции), но в то же время все методы встроенного объекта становятся доступными в новом классе (как при наследовании). Например, класс SpaceShipControls имитирует модуль управления космическим кораблем:
//. reusing/SpaceShipControls.java
public class SpaceShipControls { void up(int velocity) {} void down(int velocity) {} void left(int velocity) {} void right(int velocity) {} void forward(int velocity) {} void back(int velocity) {} void turboBoostO {} } ///-

Для построения космического корабля можно воспользоваться наследова­нием:
// reusing/SpaceShip java
public class SpaceShip extends S^ceShipControls { private String name.
public SpaceShip(String name) { this.name = name, }
public String toStringO { return name. }_______
public static void main(String[] args) {
SpaceShip protector = new SpaceShipC'NSEA Protector"), protector forward(lOO).
}
} /// ~
Однако космический корабль не может рассматриваться как частный случай своего управляющего модуля — несмотря на то, что ему, к примеру, можно при­казать двигаться вперед (forward()). Точнее сказать, что SpaceShipсодержитSpaceShipControls, и в то же время все методы последнего предоставляются клас­сом SpaceShip. Проблема решается при помощи делегирования:
// reusing/SpaceShipDelegation java
public class SpaceShipDelegation { private String name, private SpaceShipControls controls =
new SpaceShipControlsO: public SpaceShipDelegation(String name) {
this name = name. }
// Делегированные методы: public void back(int velocity) { controls.back(velocity);
}
public void down(int velocity) { controls.down(velocity);
}
public void forward(int velocity) { controls forward(velocity).
}
public void leftCint velocity) { controls left(velocity).
}
public void rightOnt velocity) { controls right(velocity);
}
public void turboBoostO {
controls.turboBoostO.
}
public void up(int velocity) { controls.up(velocity):
}
public static void main(String[] args) { SpaceShipDelegation protector =
new SpaceShipDelegationC'NSEA Protector");продолжение &protector.forwarcK 100);
}
} ///:-
Как видите, вызовы методов переадресуются встроенному объекту controls, а интерфейс остается таким же, как и при наследовании. С другой стороны, деле­гирование позволяет лучше управлять происходящим, потому что вы можете ограничиться небольшим подмножеством методов встроенного объекта.
Хотя делегирование не поддерживается языком Java, его поддержка присут­ствует во многих средах разработки. Например, приведенный пример был авто­матически сгенерирован в JetBrains Idea IDE.
Сочетание композиции и наследования
Композиция очень часто используется вместе с наследованием. Следующий пример демонстрирует процесс создания более сложного класса с объединени­ем композиции и наследования, с выполнением необходимой инициализации в конструкторе:
II: reusing/PlaceSetting.java 11 Совмещение композиции и наследования, import static net.mindview.util.Print.*;
class Plate {
'PlateCint i) {
print("Конструктор Plate");
}
}
class DinnerPlate*extends Plate { DinnerPlate(int i) { super(i),
print("Конструктор DinnerPlate");
class Utensil {
Utensil(int i) {
print("Конструктор Utensil");
}
}
class Spoon extends Utensil { Spoon(int i) {
super(i);
print'CKoHCTpyKTop Spoon");
class Fork extends Utensil { Fork(int i) {
super(i);
System.out.println("Конструктор Fork");
}
class Knife extends Utensil { Knife(int i) {
super(i):
print("Конструктор Knife");
class Custom {
Custom(int i) {
print("Конструктор Custom");
public class'PIaceSetting extends Custom { private Spoon sp; private Fork frk; private Knife kn; private DinnerPlate pl; public PIaceSetting(int i) { super(i + 1); sp = new Spoon(i + 2); frk = new Fork(i + 3); kn = new Knifed + 4); pl = new DinnerPlated + 5); pri nt("Конструктор PlaceSetti ng"):