30
Даже если у вас в программе имеется множество классов, из командной строки исполняется только один (так как метод 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"):
}
public static void main(String[] args) {
. PlaceSetting x = new PlaceSetting(9);
}
} /* Output: Конструктор Custom Конструктор Utensil Конструктор Spoon Конструктор Utensil Конструктор Fork Конструктор Utensil Конструктор Knife Конструктор Plate Конструктор DinnerPlate конструктор PlaceSetting *///:-
Несмотря на то, что компилятор заставляет вас инициализировать базовые классы и требует, чтобы вы делали это прямо в начале конструктора, он не следит за инициализацией встроенный объектов, поэтому вы должны сами помнить об этом.
Обеспечение правильного завершения
В Java отсутствует понятиедеструктораиз С++ — метода, автоматически вызываемого при уничтожении объекта. В Java программисты просто «забывают» об объектах, не уничтожая их самостоятельно, так как функции очистки памяти возложены на сборщика мусора.