27

27


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

Во многих случаях эта модель работает, но иногда класс выполняет некото­рые операции, требующие завершающих действий. Как упоминалось в главе 5, вы не знаете, когда будет вызван сборщик мусора и произойдет ли это вообще. Поэтому, если в классе должны выполняться действия по очистке, вам придется написать для этого особый метод и сделать так, чтобы программисты-клиенты знали о необходимости вызова этого метода. Более того, как описано в главе 10, вам придется предусмотреть возможные исключения и выполнить завершаю­щие действия в секции finally.
Представим пример системы автоматизированного проектирования, которая рисует на экране изображения:
//: reusing/CADSystem.java // Обеспечение необходимого завершения package reusing:
import static net.mindview util.Print.*;
class Shape {
Shape(int i) { print("Конструктор Shape"); } void disposed { print("Завершение Shape"); }
'}
class Circle extends Shape { Circle(int i) {
super(i),
print("Рисуем окружность Circle");
}
void disposeO {
print("Стираем окружность Circle"); super. disposeO;
}
}
class Triangle extends Shape { Triangle(int i) { super(i);
print("Рисуем треугольник Triangle");
}
void disposeO {
print("Стираем треугольник Triangle"); super.disposeO;
}
}
class Line extends Shape { private int start, end; Line(int start, int end) { super(start); this.start = start; this.end = end;
print("Рисуем линию Line: " + start + ", " + end);
}
void disposeO {
print("Стираем линию Line: " + start + ", " + end). super.disposeO;

}
public class CADSystem extends Shape { private Circle c; private Triangle t; private Line[] lines = new Line[3], public CADSystem(int i) { super(i + 1).
for(int j = 0, j < lines length; j++) lines[j] = new Line(j. j*j), с = new Circled), t = new Triangle(l), print("Комбинированный конструктор").
}
void disposed {
print("CADSystem.dispose()"); // Завершение осуществляется в порядке, // обратном порядку инициализации t disposed; с.disposed;
for(int i = lines length - 1; i >=0; i--)
lines[i] .disposed; super disposed;
}
public static void main(String[] args) { CADSystem x = new CADSystem(47), try {
// Код и обработка исключений. } finally {
х disposed,
}
}
} /* Output: Конструктор Shape Конструктор Shape Рисуем линию Line- 0, 0 Конструктор Shape Рисуем линию Line- 1. 1 Конструктор Shape Рисуем линию Line- 2, 4 Конструктор Shape Рисуем окружность Circle Конструктор Shape Рисуем треугольник Triangle Комбинированный конструктор CADSystem. disposed Стираем треугольник Triangle Завершение Shape Стираем окружность Circle Завершение Shape Стираем линию Line: 2, 4 Завершение Shape Стираем линию Line: 1, 1 Завершение Shape Стираем линию Line 0. 0 Завершение Shape Завершение Shape *///.-

Все в этой системе является некоторой разновидностью класса Shape (кото­рый, в свою очередь, неявно наследует от корневого класса Object). Каждый класс переопределяет метод dispose() класса Shape, вызывая при этом версию метода из базового класса с помощью ключевого слова super. Все конкретные классы, унаследованные от Shape — Circle, Triangle и Line, имеют конструкторы, которые просто выводят сообщение, хотя во время жизни объекта любой метод может сделать что-то, требующее очистки. В каждом классе есть свой собствен­ный метод dispose(), который восстанавливает ресурсы, не связанные с памя­тью, к исходному состоянию до создания объекта.
В методе main() вы можете заметить два новых ключевых слова, которые бу­дут подробно рассмотрены в главе 10: try и finally. Ключевое слово try показыва­ет, что следующий за ним блок (ограниченный фигурными скобками) являетсязащищенной секцией.Код в секции finally выполняется всегда, независимо от того, как прошло выполнение блока try. (При обработке исключений можно выйти из блока try некоторыми необычными способами.) В данном примере секция finally означает: «Что бы ни произошло, в конце всегда вызывать метод x.dispose()».
Также обратите особое внимание на порядок вызова завершающих методов для базового класса и объектов-членов в том случае, если они зависят друг от друга. В основном нужно следовать тому же принципу, что использует компи­лятор С++ при вызове деструкторов: сначала провести завершающие действия для вашего класса в последовательности, обратной порядку их создания. (Обычно для этого требуется, чтобы элементы базовых классов продолжали су­ществовать.) Затем вызываются завершающие методы из базовых классов, как и показано в программе.
Во многих случаях завершающие действия не являются проблемой; доста­точно дать сборщику мусора выполнить свою работу. Но уж если понадобилось провести их явно, сделайте это со всей возможной тщательностью и вниманием, так как в процессе сборки мусора трудно в чем-либо быть уверенным. Сборщик мусора вообще может не вызываться, а если он начнет работать, то объекты бу­дут уничтожаться в произвольном порядке. Лучше не полагаться на сборщик мусора в ситуациях, где дело не касается освобождения памяти. Если вы хотите провести завершающие действия, создайте для этой цели свой собственный ме­тод и не полагайтесь на метод finalize().
Сокрытие имен
Если какой-либо из методов базового класса Java был перегружен несколько раз, переопределение имени этого метода в производном классене скроетни одну из базовых версий (в отличие от С++). Поэтому перегрузка работает вне зависимости от того, где был определен метод — на текущем уровне или в базовом классе:
//: reusing/Hide java
// Перегрузка имени метода из базового класса
// в производном классе не скроет базовую версию метода.
import static net.mindview.util.Print.*:

class Milhouse {}
class Bart extends Homer { void doh(Milhouse m) {
print("doh(Milhouse)");
}
}
public class Hide {
public static void main(String[] args) { Bart b = new BartO; b doh(l); b doh('x'); b.doh(l.Of); b doh(new MilhouseO);
}
} /* Output. doh(float) doh(char) doh(float) doh(Milhouse) *///:-
Мы видим, что все перегруженные методы класса Homer доступны классу Bart, хотя класс Bart и добавляет новый перегруженный метод (в С++ такое дей­ствие спрятало бы все методы базового класса). Как вы увидите в следующей главе, на практике при переопределении методов гораздо чаще используется точно такое же описание и список аргументов, как и в базовом классе. Иначе легко можно запутаться (и поэтому С++ запрещает это, чтобы предотвратить совершение возможной ошибки).
В Java SE5 появилась запись @0verride; она не является ключевым словом, но может использоваться так, как если бы была им. Если вы собираетесь пере­определить метод, используйте @0verride, и компилятор выдаст сообщение об ошибке, если вместо переопределения будет случайно выполнена перегрузка:
//• reusing/Lisa java // {CompileTimeError} (Won't compile)
class Lisa extends Homer {
(^Override void doh(Milhouse m) {
System out println("doh(Milhouse)");
class Homer {
char doh(char с) {
print("doh(char)"); return 'd';
}
float doh(float f) {
print("doh(float)"); return l.Of,

}
Композиция в сравнении с наследованием
И композиция, и наследование позволяют вам помещать подобъекты внутрь ва­шего нового класса (при композиции это происходит явно, а в наследовании — опосредованно). Вы можете поинтересоваться, в чем между ними разница и ко­гда следует выбирать одно, а когда — другое.
Композиция в основном применяется, когда в новом классе необходимо ис­пользовать функциональность уже существующего класса, но не его интерфейс. То есть вы встраиваете объект, чтобы использовать его возможности в новом классе, а пользователь класса видит определенный вами интерфейс, но не заме­чает встроенных объектов. Для этого внедряемые объекты объявляются со спе­цификатором private.
Иногда требуется предоставить пользователю прямой доступ к композиции вашего класса, то есть сделать встроенный объект открытым (public). Встроен­ные объекты и сами используют сокрытие реализации, поэтому открытый дос­туп безопасен. Когда пользователь знает, что класс собирается из составных частей, ему значительно легче понять его интерфейс. Хорошим примером слу­жит объект Саг (машина):
// reusing/Car.java
// Композиция с использованием открытых объектов
// двигатель
class Engine {
public void startO {} // запустить public void rev() {} // переключить public void stopO {} // остановить
}
// колесо
class Wheel {
public void inflate(int psi) {} // накачать
}
// окно
class Window {
public void rollupO {} // поднять public void rolldownO {} // опустить
}
// дверь
class Door {
public Window window = new WindowO; // окно двери public void openО {} // открыть public void closeO {} // закрыть
}
// машина
public class Car {
public Engine engine = new EngineO; public Wheel[] wheel = new Wheel[4], public Door
left = new DoorO,
right = new DoorO: // двухдверная машина
public CarO {
for (int i =0; i <4; i++)
wheel[i] = new Wheel О;
}
public static void main(String[] args) { Car car = new CarO; car 1 eft.window.rollup(); car.wheel[0].inflate(72);
}
} /// -
Так как композиция объекта является частью проведенного анализа задачи (а не просто частью реализации класса), объявление членов класса открытыми (public) помогает программисту-клиенту понять, как использовать класс, и об­легчает создателю класса написание кода. Однако нужно все-таки помнить, что описанный случай является специфическим и в основном поля класса следует объявлять как private.
При использовании наследования вы берете уже существующий класс и соз­даете его специализированную версию. В основном это значит, что класс обще­го назначения адаптируется для конкретной задачи. Если чуть-чуть подумать, то вы поймете, что не имело бы смысла использовать композицию машины и средства передвижения — машина не содержит средства передвижения, она самаестьэто средство. Взаимосвязь «является» выражается наследованием, а взаимосвязь «имеет» описывается композицией.
protected
После знакомства с наследованием ключевое слово protected наконец-то обрело смысл. В идеале закрытых членов private должно было быть достаточно. В ре­альности существуют ситуации, когда вам необходимо спрятать что-либо от ок­ружающего мира, тем не менее оставив доступ для производных классов.
Ключевое слово protected — дань прагматизму. Оно означает: «Член класса является закрытым (private) для пользователя класса, но для всех, кто наследу­ет от класса, и для соседей по пакету он доступен». (В Java protected автомати­чески предоставляет доступ в пределах пакета.)
Лучше всего, конечно, объявлять поля класса как private — всегда стоит оста­вить за собою право изменять лежащую в основе реализацию. Управляемый доступ наследникам класса предоставляется через методы protected:
// reusing/Ore java
// Ключевое слово protected
import static net.mindview.util.Print.*;
class Villain {
private String name;
protected void set(String nm) { name = nm; } public Villain(String name) { this.name = name, } public String toStringO {
return "Я объект Villain и мое имя " + name;
}
public class Ore extends Villain { private int orcNumber, public Orc(String name, int orcNumber) { super(name);
this.orcNumber = orcNumber;
}
public void change(String name, int orcNumber) {
set(name); // Доступно, так как объявлено protected this.orcNumber = orcNumber;
}
public String toStringO {
return "Ore " + orcNumber + ": " + super.toString().
}
public static void main(String[] args) {