abstract (Выпуск 18)

Модификатор abstract применяется только для классов и методов.

Абстрактный класс не может быть инстанциирован, то есть нельзя вызвать конструктор для создания его объекта.

Абстрактные классы перекладывают имплементацию методов на "плечи" своих подклассов. Рассмотрим, к примеру, рисунок ниже:

Разработчик класса Animal решил, что все животные должны иметь метод travel(). Поскольку каждое животное перемещается по-своему, то невозможно заимплементировать этот метод уникальным образом и просто наследовать этот метод в подклассы. Поэтому метод travel() объявлен с модификатором abstract следующим образом:

abstract void travel();

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

Если класс содержит обстрактный метод, то компилятор предлагает объявить и весь класс абстрактным. Эта конвенция делает класс лёгким для использования другими разработчиками: им нужно всего лишь взглянуть на объявление класса, чтобы понять, можно ли инстанциировать класс непосредственно или для этого нужно создавать подкласс.

Класс рекомендуется объявлять абстрактным, если:

• В классе есть абстрактные методы.
• Класс наследует абстрактные методы (от абстрактного суперкласса) и не предоставляет имплементации для всех унаследованных абстрактных методов.
• Класс имплементирует интрефейс но не предоставляет имплементации для всех методов интерфейса.

Все эти три условия выше означают одно: класс абстрактен, если он не полностью имплементирован. Какая-то часть функциональности класса отсутствует и должна быть предоставлена одним из его подклассов.

Таким образом, можификатор abstract можно считать противоположностью модификатору final. Финальный класс не может иметь подклассов. Абстрактный класс должен иметь подклассы.

Читать далее!

final (Выпуск 18)

Модификатор final может применяться к классам, методам и переменным. При этом его конкретное значение зависит от контекста. Но в общем модификатор final означает, что элемент не может быть модифицирован, изменён.

В частности, final класс не может иметь подклассов. Например, следующий код просто не откомпилируется, потому что java.lang.Math имеет модификатор final:

class SubMath extends java.lang.Math { }

Получаем ошибку компиляции: "Can’t subclass final classes." ("Невозможно создать подкласс от класса final")

Final переменная не может принимать значение, которое отличается от того, что было присвоено при инициализации. Поэтому в Java переменные с модификатором final играют роль const в C++ и #define в С. Например в классе java.lang.Math есть переменная с модификатором final типа double, которая называется PI. Очевидно, что число пи не должно изменяться по прихоти программиста.

Если объекту назначен модификатор final, то это означает, что ссылка (указатель) на объект должна оставаться неизменной, хотя сам объект может меняться. Проиллюстрируем это примером:

1. class Walrus {
2.     int weight;
3.     Walrus(int w) { weight = w; }
4. }
5.
6. class Tester {
7.      final Walrus w1 = new Walrus(1500);
8.      void test() {
9.          w1 = new Walrus(1400); // Illegal
10.         w1.weight = 1800; // Legal
11.     }
12. }

Обратите внимание, как в строке 7 объект w1 был объявлен с модификатором final. Именно поэтому в строке 9 выполняется недопустимая операция создания нового указателя на объект. Хотя в строке 10 мы можем изменить значение некоторых полей объекта.

Иными словами:

• Нельзя менять ссылку на объект, то есть пересоздавать объект.
• Можно изменять значения полей.

Наконец, final метод не может быть переопределён (overriden). Например, следующий код не откомпилируется:

1. class Mammal {
2.     final void getAround() { }
3. }
4.
5. class Dolphin extends Mammal {
6.     void getAround() { }
7. }

Дельфины плавают совершенно по-другому в отличие от большинства млекопитающих. Поэтому имеет смысл переопределить метод унаследованный метод getAround(). Но этот метод final, поэтому в 6 строке мы получим ошибку компиляции "Final methods can’t be overridden." (Финальные методы не могут быть переопределены)

Читать далее!

Модификаторы доступа: резюме. Другие модификаторы (Выпуск 17)

Java предоставляет следующие модификаторы доступа (от самого разрешающего до самого ограничивающего):

• public - элемент доступен из любого класса
• protected - элемент доступен из подкласса или из любого класса пакета того класса, в котором находится элемент
• default - элемент доступен из из любого класса пакета того класса, в котором находится элемент
• private - элемент доступен лишь из того класса, в котором находится

Элементы подклассов могут иметь любой модификатор доступа, отличный от наследуемого, если только новый модификатор доступа не является более ограничивающим. В противном случае возникает ошибка компиляции.

---

В следующих статьях мы рассмотрим другие модификаторы: final, abstract, static, native, transient, synchronized, and volatile.

В Java порядок объявления модификаторов не имеет значения. Например, если вы напишите, что класс public final, то это равносильно тому, если бы вы написали final public. Если вы обхъявите метод protected static - это тоже самое, что и объявить его static protected.

Не все модификаторы одинаково применимы к разным элементам Java-языка (т.е. класс, переменная, метод, конструктор). Более детальные разъяснения будут даны в следующих статьях.

Читать далее!

Подклассы и методы (Выпуск 17)

Согласно спецификации Java методы не могут быть переписаны (например, в наследуемых классах). Например, у апплетов есть метод init(). Этот метод должен переписывать одноименный метод из супер-класса
java.applet.Applet, доступ к которому public. Таким образом, переписывающий метод init() из подкласса класса java.applet.Applet не можеть иметь более ограничивающий доступ, т.е., protected, private или default - его модификатор доступа может быть только public. В противном случае на этапе компиляции возникнет ошибка "Methods can’t be overridden to be more private" (Доступ к методам не может быть более ограниченным).

На рисунке ниже мы представили иерархию модификаторов доступа. Слева находится самый ограничивающий модификатор доступа. Справа - самый разрешающий. Методы подклассов могут иметь модификатор доступа отличный, от наследуемого, если он является более разрешающим (т.е. находится правее исходного модификатора доступа на рис. ниже).

Иерархия модификаторов доступа

Таким образом модификатор доступа к методу и подкласса может быть следующим:

• private, protected, public, default, если модификатор доступа у метода суперкласса private
• protected, public, default, если модификатор доступа у метода суперкласса default
• protected, public, если модификатор доступа у метода суперкласса protected
• public, если модификатор доступа у метода суперкласса public

На следующем рисунке показана "обратная" иерархия, которая приведёт к ошибке компиляции:

Обратная иерархия

То есть:

• default не может быть ограничен до private
• protected не может быть ограничен до default или private
• public не может быть ограничен до protected, default или private

Читать далее!

protected (Выпуск 16)

Название protected (защищённый) слегка сбивает с толку. Читатель может подумать, что защищённый доступ имеет очень ограничивающую натуру, что-то вроде приватного. В реальности же защищённые элементы являются более доступны, чем, скажем, элементы с доступом по умолчанию.

Только переменные и методы могут иметь защищённый модификатор доступа. Защищённый элемент доступен всем остальным классам из того же пакета, как и в случае с доступом по умолчанию. Кроме того, защищённый элемент класса доступен всем его подклассам, даже если они находятся в других пакетах.

В качестве примера рассмотрим фрагмент кода:

1. package sportinggoods;
2. class Ski {
3.     void applyWax() { . . . }
4. }

У метода applyWax() доступ по умолчанию. Теперь рассмотрим подкласс:

1. package sportinggoods;
2. class DownhillSki extends Ski {
3.     void tuneup() {
4.         applyWax();
5.         // продолжение кода
6.     }
7. }

Подкласс вызывает унаследованный метод applyWax(). Всё идёт, как надо, поскольку оба класса Ski и DownhillSki находятся в одном и том же пакете. Но если один из этих классов по какой-то причине будет перемещён в другой пакет, DownhillSki больше не будт иметь доступа к наследуемому методу applyWax() и код не откомпилируется. Данная проблема решается при добавлении защмщённого модификатора доступа к методу applyWax() в строке 3:

1. package adifferentpackage; // Класс Ski в
                              // другом пакете
2. class Ski {
3.     protected void applyWax() { . . . }
4. }

Читать далее!

Default (Выпуск 16)

Default (по умолчанию)- это способ доступа к классам, переменным и методам, если иной другой модификатор доступа не указан. Данные класса или его методы могут быть доступны по умолчанию, равно как и сам класс может быть доступен по умолчанию.

Default не является ключевым словом в Java, но это всего лишь понятие, обозначающее уровень доступа в том случае, если не задан никакой явный модификатор доступа.

Когда вы пишете приложение, для которого нужно разработать несколько классов, то скорее всего вы размещаете ваши файлы с расширением .java, а байткоды соответствующий классов (.class) - в другой директории. И вот эта другая директория с точки зрения JRE (Java Runtime Environment) является пакетом.

Если вы не озаботитесь обозначением модификаторов доступа для всяких разных ваших классов, а также их данных и методов, то им будет присвоен модификатор доступа по умолчанию. А это означает их доступность любым другим классам в том же самом пакете.

Все классы в одном пакете с модификатором доступа по умолчанию могут доступаться к данным и методам друг друга.

Классы из других пакетов не могут получить доступ к вашим классам, поскольку у ваших классов можификатор доступа default, а не public! Даже если у классов вне вашего пакета есть подклассы из вашего пакета (например, такая ситуация характерна для апплетов), то и подклассы не могут доступаться по умолчанию, потому что модификатор default, а не protected или public. Рисунок ниже иллюстрирует разные ситуации с доступом по умолчанию внутри пакета и вне его:

Только классы из одного пакета могут получать доступ к элементам других классов, не имеющим ямного модификатора доступа

Читать далее!

private

Самый ограничивающий модификатор – private (приватный). Приватный метод или переменная могут быть использованы только внутри объекта класса, в котором они объявлены. Например, у нас имеется следующий фрагмент кода:

1. class Complex {
2.     private double real, imaginary;
3.
4.     public Complex(double r, double i) {
5.         real = r; imaginary = i;
6.     }
7.     public Complex add(Complex c) {
8.         return new Complex(real + c.real,
9.             imaginary + c.imaginary);
10.     }
11. }
12.
13. class Client {
14.     void useThem() {
15.         Complex c1 = new Complex(1, 2);
16.         Complex c2 = new Complex(3, 4);
17.         Complex c3 = c1.add(c2);
18.         double d = c3.real; // Illegal!
19.     }
20. }

В строке 17 мы вызываем c1.add(c2). Объект c1 вызывает метод add и использует при этом объект c2 в качестве параметра. Смотрите дальше, в строке 8 c1 имеет доступ к своим приватным переменным и к приватным переменным объекта c2! И это не ошибка.

Объявление переменных real и imaginary с модификатором private означает, что эти переменные могут быть доступны только в экземплярах (instance) класса Complex для любых экземпляров класса Complex. Таким образом c1 имеет доступ не только к своим собственным полям real и imaginary но и к полям real и imaginary любого экземпляра класса Complex. Модификаторы доступа определяют какие классы могут доступаться к разным элементам (поля, методы и т.д.), но не какие экземпляры классов.

Строка 18 нелегальна и приведёт к ошибке компиляции с сообщением: “Variable real in class Complex not accessible from class Client”. (Переменная real в классе Complex недоступна из класса Client) .Приватная переменная real может быть доступна только для экземпляра класса Complex.

Приватные данные могут быть скрыты от любого объекта. Если у класса Complex есть подкласс SubComplex, то любой экземпляр класса SubComplex будет наследовать переменные real и imaginary. И тем не менее, ни один экземпляр класса SubComplex не сможет получить доступ к значениям тех переменных. Поэтому, например, следующий код не откомпилируется:

1. class Complex {
2.     private double real, imaginary;
3. }
4.
5.
6. class SubComplex extends Complex {
7.     SubComplex(double r, double i) {
8.         real = r; // Trouble!
9.     }
10. }

В конструкторе класса SubComplex (строка 8), мы обращаемся к переменной real. И в этой строке возникает ошибка компиляции с сообщением: “Undefined variable: real.” (Не определена переменная real.) Модификатор private переменной real предотврашает к ней доступ из экземпляра класса SubComplex, то есть SubComplex не может доступиться к собственной переменной!

Читать далее!

public

Модификатор, который обеспечивает максимальную свободу в использовании классов, их полей и методов, - это public (публичный). Публичный класс, переменная или метод могут использоваться в любых Java программах без каких-либо ограничений. Например, если апплет (подкласс класса java.applet.Applet) объявлен публичным, то он может быть инстанциирован в браузерах. Приложение декларирует свой метод main() публичным, чтобы этот метод мог быть легко вызван из любого JRE (Java runtime Environment).

Читать далее!