Java

static (Выпуск 19)

2010-01-03T08:19:00.000-08:00

Модификатор static (статичный) применяется переменным, методам и даже к странным фрагментам кода, которые не являются частью метода. Статичные фрагменты кода принадлежат не объекту класса, но ко всему классу.

Рассмотрим пример простого класса с одной статичной переменной:

1. class Ecstatic{
2.     static int x = 0;
3.     Ecstatic() { x++; }
4. }

Переменная x объявлена статичной. Это означает, что не важно, сколько объектов класса Ecstatic существует в данный момент - x всего лишь одна. При загрузке класса Ecstatic выделяется 4 байта под переменную x. И её инициализация происходит (см. строку №2) тоже в момент загрузки класса. И каждый раз, когда создаётся объект класса Ecstatic, x инкрементируется. Этот приём позволяет знать точное количество созданных объектов класса Ecstatic.

Получить доступ к статичным переменным можно двумя способами:

Через любой объект класса: обьект.переменная.
Через сам класс: класс.переменная.

Первый метод, однако, считается дурным тоном, так как очень сильно вводит в заблуждение. Давайте рассмотрим это на примере:

1. Ecstatic e1 = new Ecstatic();
2. Ecstatic e2 = new Ecstatic();
3. e1.x = 100;
4. e2.x = 200;
5. reallyImportantVariable = e1.x;

Если вы заранее не знаете, что x - статичная переменная, то можете подумать, что в 5-й строке переменной reallyImportantVariable присваивается 100. Но на самом деле ей присваивается 200, потому что e1.x и e2.x - это всё одна и та же переменная х.

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

1. Ecstatic e1 = new Ecstatic();
2. Ecstatic e2 = new Ecstatic();
3. Ecstatic.x = 100; // Бессмысленное действие
4. Ecstatic.x = 200;
5. reallyImportantVariable = Ecstatic.x;

Теперь всё встаёт на свои места: строка 3 не несёт никакого смысла - это всего лишь лишняя операция, а в 5-й строке переменной reallyImportantVariable присваивается сразу 200.

Статичные методы не могут использовать нестатичные элементы (переменные и методы) своиего класса, но могут использовать другие статичные элементы. Статичные методы не принадлежат ни одному объекту класса. Поэтому они могут вообще вызваться до того, как класс инстанциирован.

Каждое Java приложение содержит в себе статичный метод main():

1. class SomeClass {
2.     static int i = 48;
3.     int j = 1;
4.
5.     public static void main(String args[]) {
6.        i += 100;
7.        // j *= 5; Если раскомментировать, будет ошибка
8.     }
9. }

Когда приложение запускается (то есть кто-то вызывает из коммандной строки java SomeClass), не существует ни одного объекта класса SomeClass. Однако существует переменная i, которая инициализурется во 2-й строке и инкрементируется в 6-й строке. А если бы мы раскомметировали 7-ю строку, то вообще получили бы ошибку компиляции, потому что статичный метод не может использовать нестатичные переменные класса.

abstract (Выпуск 18)

2009-10-13T06:47:00.000-07:00

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

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

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

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

abstract void travel();

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

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

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

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

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

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

final (Выпуск 18)

2009-10-12T06:13:00.000-07:00

Модификатор 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)

2009-04-15T03:34:00.000-07:00

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

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

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

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

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

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

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

2009-04-15T02:41:00.000-07:00

Согласно спецификации 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)

2009-01-26T07:57:00.000-08:00

Название 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)

2009-01-26T07:32:00.000-08:00

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

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

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

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

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

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

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

private

2009-01-09T01:23:00.000-08:00

Самый ограничивающий модификатор – 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

2009-01-09T01:19:00.000-08:00

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

3.2 Модификаторы доступа (Выпуск 14)

2008-11-24T03:44:00.000-08:00

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

Существует три модификатора доступа:

public
private
protected

Элементы (см. выше) могут иметь один и более модификаторов, либо не иметь их вовсе. Однако, среди всевозможных модификаторов элемента количество модификаторов доступа долно быть не больше одного.

Если элемент не имеет модификатора, то доступ к нему определяется по умолчанию, то есть default. Однако, ключевого слова default не существует! Другие наименования доступа по умолчанию, которые вы можете встретить в литературе, включают в себя friendly, package.

Ниже мы приводим примеры легально объявленых элементов с модификаторами или без них. Легальность некоторых объявлений зависит от контекста.

class Parser { ... }
public class EightDimensionalComplex { ... }
private int i;
Graphics offScreenGC;
protected double getChiSquared() { ... }
private class Horse { ... }

А вот примеры нелегальных объявлений элементов:

public protected int x; // Не более одного модификатора доступа!
default Button getBtn() {...} // "default" - это не ключевое слово

Глава 3: Модификаторы (Выпуск 14)

2008-11-24T03:04:00.000-08:00

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

3.1 Обзор модификаторов

Наиболее распространённые модификаторы - модификаторы доступа: public, protected, private. О них мы поговорим сразу в следующей статье. Все остальные модификаторы не подпадают ни под какую чёткую классификацию. Мы их просто перечислим:

final
abstract
static
native
transient
synchronized
volatile

Каждому из этих модификаторов будет посвящена отдельная статья в будущем.

Ответы на тест по операторам (Выпуск 13)

2008-11-05T05:10:00.000-08:00

Вопросы теста можно посмотреть здесь.

Ответ: С
Вычисление производится в таком порядке: x = a + b; a = a + 1; b = b + 1; Поэтому x = 6 + 7 то есть 13. После чего переменные a и b инкрементируются до значений 7 и 8 соответственно.
Ответ: B, С
В варианте A использование оператора ! незаконно, поскольку x является переменной типа int, а не boolean. На этом часто попадаются C и C++ программисты. В варианте B выражение (x<3) имеет тип boolean, поэтому перед ним можно использовать оператор !. В ответе C поразрядный оператор ~ применен к целочисленному x, значение которого равно 6, что в битовом виде имеет форму 0..0110 (на месте двух точек должны стоять 27 нулей). После применения оператора ~ x примет значение 1..1001 (на месте двух точек подставьте 27 единиц).
Ответ: A
Битовое представление -1 состоит из единиц во всех разрядах. В варианте A эта строка из единиц сдвигается вправо на 5 позиций и освободившиеся 5 первых позиций заполняются нулями. Это в десятичном выражении имеет положительное значение 134217727. В варианте B аналогичный сдвиг происходит на 32 разряда и результат состоит из строки, у которой во всех позициях нули, то есть 0. Вариант C недопустим, потому что результат выражения x <<< 5 имеет тип int и не может быть присвоен переменной типа byte без явного приведения типов, которое в данном случае отсутствует. Наконец, в варианте D при сдвиге все освободившиеся позиции принимают значение наиболее значимого разряда исходного значения, то есть -1. Результат операции не отличается от исходного значения и равен -1.

Ответ: A, C, E
Варианты A и C эквивалентны, поскольку x+=y эквивалентно x = x+y. Выражение x+y "суммирует" строки и целое число, в результате из целого числа будет создан объект строкового типа и потом будет создана новая строка (ещё один новый объект строкового типа) со значением "Hello9". В варианте B сравнение x == y незаконно, потому что целочисленный тип не может сравниваться с указателем. В варианте D в результате вычисления выражения y+x также, как и в вариантах A и C создаётся новая строка. Но в последствии она присваивается переменной целочисленного типа, а это недопустимо. Вариант E самый оригинальный. В нём важны два момента: условный оператор :? и укороченный оператор &&. Левый операнд укороченого оператора, то есть выражение (x != null), всегда равен false. Следовательно правый операнд, то есть выражение (x.length() > 0), никогда не будет вычисляться, поскольку всё выражение заведомо равняется значению false. Это значение false затем используется в выражении условного оператора, результат которого будет равен 0 (операнд после двоеточия).

Ответ: A, E
Хотя int и float и не являются совместимыми с точки зрения присваиваний, они могут легко использоваться в левых и правых частях операторов сравнения, коим и является оператор ==. При этом int 100 приводится к float 100.0 и запросто сравнивается с другим float 100.0F. Поэтому вариант A проходит. В варианте B код не откомпилируется, потому что int и Integer (указатель) не могут быть приведены даже в случае оператора сравнения. В варианте C код компилируется и сравнение может быть проведено. Но выражение x == y сравнивает два различных указателя, и поэтому результат теста равен false. Аналогичные рассыждения можно провести для варианта D. Вариант E кажется эквивалентным варианту D, но это на самом деле не так. В варианте E для строковой константы "100" создаётся объект строкового типа, а x и y являются указателями на этот объект. То есть тест (x == y) равняется true и мы получаем сообщение "Equal".

Ответ: AВ четвёртой строке кода результат вычисления (s.length()>5) равен false (поскольку длина строки "Hello" равна 5). Таким образом, всё выражения условия if равно false. В результате никаких манипуляций над строкой не производится и она остаётся прежней.

Ответ: B
Побитовый XOR оператор ^ возвращает 0, если оба биты одинаковы (оба равны 0 или оба равны 1), и 1 - в противном случае. Таким образом 00001010^00001111=00000101, то есть 5 в десятичном исчислении.

Ответ: CВ операторе ?: используются операнды различных типов: 99.99 (double) и 9 (int). Поэтому int приводится к double и результат всего выражения будет типа double. Поскольку x = 4, то тест (x > 4) равен false. Следовательно, результат равен значению после двоеточия, то есть 9.0 (то есть типа double).

Ответ: B
Вычисление достаточно очевидно, поскольку участвуют только положительные числа. Деление 10 на 3 даёт 3 и в остатке 1, что и является ответом. Если бы мы имели дело с дробными числами, то алгоритм вычисления остатка от деления y на x был бы таким: вычитать x из y до тех пор, пока y не станет меньше x. Как только это случится, y - остаток от деления. Для отрицательных чисел можно забыть о знаках, но иметь в виду, что знак остатка от деления равен знаку делимого (левого операнда).

Ответ: AОператор присваивания op= высчитывает левое выражение только один раз. Таким образом, декремент --x происходит только раз и в результате получается 0, а не -1. То есть не возникает никаких ошибок выхода за границы (out-of-bounds). В нулевой позиции массива находится значение Fred. При этом декремент имеет место перед операцией +=. Хотя объекты типа String не могут изменять своего значения (immutable), указатели, коими являются элементы массивы, могут изменяться. То есть мы можем создать новый объект в нулевой позиции массива name, который будет иметь значение "Fred.", то есть строка Fred, заканчивающаяся точкой.

Итоги главы 2 и тест по операторам (Выпуск 12)

2008-10-12T15:34:00.000-07:00

Резюме главы 2 об операторах:

Вы должны знать тип результата унарных и бинарных арифметичских операций, применямых над операндами различных типов.

Различие между равенством объектов и равенством ссылок. Функциональность метода equal() в классах Object, String, Boolean (они сравнивают инкапсулированные данные).

Тест

После выполнения кода ниже каковы будут значения переменных x, a, и b?
```
1. int x, a = 6, b = 7;
2. x = a++ + b++;
```
1. x = 15, a = 7, b = 8
2. x = 15, a = 6, b = 7
3. x = 13, a = 7, b = 8
4. x = 13, a = 6, b = 7
Какие из нижеследующих выражений допустимы? (Выберите все допустимые)

int x = 6; x = !x;
int x = 6; if (!(x > 3)) {}
int x = 6; x = ~x;

Какие выражения возвратят положительное значение переменной x?

int x = -1; x = x >>> 5;
int x = -1; x = x >>> 32;
byte x = -1; x = x >>> 5;
int x = -1; x = x >> 5;

Какие из нижеследующих выражений допустимы? (Выберите все допустимые)

String x = “Hello”; int y = 9; x += y;
String x = “Hello”; int y = 9; if (x == y) {}
String x = “Hello”; int y = 9; x = x + y;
String x = “Hello”; int y = 9; y = y + x;
String x = null;int y = (x != null) && (x.length() > 0) ? x.length() : 0;

Какие из нижеследующих выражений откомпилируются и напечатают “Equal” во время выполнения? (Выберите все допустимые)

int x = 100; float y = 100.0F;
if (x == y)
System.out.println("Equal");
int x = 100; Integer y = new Integer(100);
if (x == y)
System.out.println("Equal");
Integer x = new Integer(100);
Integer y = new Integer(100);
if (x == y)
System.out.println("Equal");
String x = new String("100");
String y = new String("100");
if (x == y)
System.out.println("Equal");
String x = "100"; String y = "100";
if (x == y)
System.out.println("Equal");

Каков результат выполнения кода ниже?

1. public class Short {
2.     public static void main(String args[]) {
3.         StringBuffer s = new StringBuffer(“Hello”);
4.         if ((s.length() > 5) &&
5.           (s.append(“ there”).equals(“False”)))
6.               ; // do nothing
7.         System.out.println(“value is “ + s);
8.     }
9. }

Hello
Hello there
Ошибка компиляции в 4-й или 5-й строке
Ничего не выводится
Исключение NullPointerException

Каков результат выполнения кода ниже?

1. public class Xor {
2.     public static void main(String args[]) {
3.         byte b = 10; // 00001010 binary
4.         byte c = 15; // 00001111 binary
5.         b = (byte)(b ^ c);
6.         System.out.println(“b contains ” + b);
7.     }
8. }

b contains 10
b contains 5
b contains 250
b contains 245

Каков результат компиляции и выполнения кода ниже?

1. public class Conditional {
2.     public static void main(String args[]) {
3.         int x = 4;
4.         System.out.println(“value is “ +
5.           ((x > 4) ? 99.99 : 9);
6.     }
7. }

value is 99.99
value is 9
value is 9.0
Ошибка компиляции в пятой строке

Каков результат выполнения кода ниже?
```
1. int x = 3; int y = 10;
2. System.out.println(y % x);
```

Каков результат выполнения кода ниже?

1. int x = 1;
2. String [] names = { “Fred”, “Jim”, “Sheila” };
3. names[--x] += “.”;
4. for (int i = 0; i < names.length; i++) {
5.     System.out.println(names[i]);
6. }

Fred.\nJim\nSheila
Fred\nJim.\nSheila
Fred\nJim\nSheila.
Fred\nJim\nSheila
Исключение ArrayIndexOutOfBoundsException

2.9 Оператор присваивания (Выпуск 11)

2008-09-24T02:52:00.000-07:00

Операторы присваивания устанавливают значение переменной или выражения в новое значение. Присваивание поддерживается рядом других операторов. Простое присваивание использует знак "=". Такие операторы, как, например, "*=", "+=" выполняют композиционную функцию, имеющую значение "вычислить и присвоить". Такие композиционные операторы имеют общую форму op=, где op - любой бинарный небулевый оператор, рассмотренный в данной главе.

Для любых выражений x и y совместимого типа выражение x op= y является эквиваленным выражению x = x op y. Но есть и отличия:

В первом случае x вычисляется только раз, а не два раза, как во втором, традиционном, случае.
Оператор присваивания содержит в себе неявное приведение типов.

Например:

1. byte x = 2;
2. x += 3;

В расширенном варианте это выглядит так:

1. byte x = 2;
2. x = (byte)(x + 3);

Использование приведения типа к byte необходимо, потому что результат целочисленного сложения имеет по меньшей мере тип int. В первом же случае, приведение типов неявное.

Выражение x+=2 всего лишь на два символа короче своей расширенной формы x = x + 2. Но представьте себе, что x имеет более сложный вид, например:
target[temp.calculateOffset(1.9F) + depth++].item. И тогда читаемость этого выражения существенно возрастает!

Любое присваивание обладает значением

Все операторы, которые мы обсудили в данной главе возвращают некое значение в результате выполнения операции. Например, выражение 1+2 возвращает значение 3 в результате выполнения операции сложения. И это значение может быть использовано на следующих шагах программы, например, оно может быть присвоено некоторой переменной. Оператор присваивания также возвращает значение. Например, если нам даны три переменные a, b, c, то допустимо выражение a = b = c = 0. Это выражение вычисляется справа налево, то есть ноль сначала присваивается переменной c. И присваивание возвращает значение 0, которое присваивается переменной b. А потом аналогичным образом ноль присваивается переменной a.

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

2.8 Условный оператор ? : (Выпуск 11)

2008-09-24T02:29:00.000-07:00

Условный оператор ? :, известный также, как тройной оператор позволяет закодировать условие if/else в одну строку. Если условие истинно, то результат - левое выражение от двоеточия, иначе - правое. Заметьте, что выражения слева и справа от двоеточия должны быть приводимы к типу переменной, к которой эти выражения присваиваются. Например, пусть a, b, c - это переменные типа int, а x - переменная типа boolean. Тогда выражение a = x ? b : c эквивалентно следующему фрагменту кода:

1. if (x) {
2.     a = b;
3. }
4. else {
5.     a = c;
6. }

Конечно, вместо a, b, c и x могут быть использованы выражения гораздо более сложного вида.

Некоторые не любят условный оператор и в некоторых компаниях он и вовсе запрещён к использованию внутренними правилами компании. Да, этот оператор позволяет создавать компактный код. Но в большинстве случаев компилятор сгенерирует такой же компактный и эффективный код из более понятной конструкции if/else. Кроме того, приятный и компактный условный оператор приобретает иной лик, если использовать его несколько раз во вложенном виде, например:a = b ? c ? d : e ? f : g : h ? i : j ? k : l;

Резюмируем тонкости использования условного оператора на примере выражения a = x ? b : c:

Типы выражений b и c должны быть совместимыми и даже идентичными, если их привести.
Тип выражения x должен быть boolean.
Типы выражений b и c должны быть совместимыми с типом переменной a.
Переменной a присваивается b, если x = true, и c - в противном случае (x = false).

2.7 Укороченные (short-circuit) логические операторы (Выпуск 10)

2008-08-20T02:02:00.000-07:00

Укороченные (short-circuit) логические операторы && и || предназначаются для логических AND (И) и OR (ИЛИ) операций над выражениями типа boolean. Заметьте, что для XOR (исключающее ИЛИ) операции не существует укороченного логического оператора.

Укороченные логические операторы похожи на операторы & и |, но в отличие от них применяются только к выражениям типа boolean и никогда не применяются к интегральным типам. Тем не менее, && и || обладают замечательным свойством: они укорачивают вычисление выражения, если результат может быть дедуцирован из части выражения (чуть позже я поясню это на примерах). Благодаря этому свойству, операторы && и || широко используются для обработки null-выражений. Они также помогают увеличить эффективность всей программы.

Свойство укорачивания вытекает прямым образом из различий между &&/|| и &/|: последняя пара операторов должна получать на вход значения левого и правого операторов, в то время как для первой пары операторов иногда достаточно знать значение только левого операнда, чтобы вернуть значение всего выражения. Такое поведение укороченных логических операторов базируется на двух математических правилах логической таблицы истинности:

выражение с AND оператором ложно (false), если значение хотя бы одного из его операндов ложно;
выражение с OR оператором истинно (true), если значение хотя бы одного из его операндов истинно.

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

false AND X = false
true OR X = true

То есть, если левый операнд AND выражения ложен, то и всё выражение ложно, вне зависимости от значения правого операнда. То есть при ложном левом операнде нет нужны вычислять значение правого операнда. Аналогичным образом, если левый операнд OR выражения истиннен, то истинно и всё выражения, вне зависимости от значения правого операнда, которое, следовательно, нам не нужно вычислять.

Рассмотрим пример кода, который выводит сообщение String, если строка не нулевая и более 20 символов длиной:

1. if ((s != null) && (s.length() > 20)) {
2.     System.out.println(s);
3. }

Эта же задача может быть закодиравана по-другому:

1. if (s != null) {
2.     if (s.length() > 20) {
3.          System.out.println(s);
4.     }
5. }

Если бы строка s была null, то при вызове метода s.length() мы бы получили NullPointerException. Ни в одном из двух примеров кода, однако, такая ситауция не возникнет. В частности, во втором примере, s.length() не вызывается при s = null, благодаря использованию укороченного оператора &&. Если бы тест (s!=null) возвращал ложь (false), то есть s - несуществующая строка, то и всё выражение гарантированно ложно. Значит, отпадает необхеодимость вычислять значение второго операнда, то есть выражения (s.length()>20).

Однако данные операторы имеют побочные эффекты. Например, если правый операнд является выражением, выполняющим некую операцию, то при применении укороченных операторов, эта операция может оазаться невыполненной в случае ложного левого операнда.

Рассмотрим пример:

// первый пример
1. int val = (int)(2 * Math.random());
2. boolean test = (val == 0) || (++val == 2);
3. System.out.println(“test = “ + test + “\nval = “ + val);

// второй пример
1. int val = (int)(2 * Math.random());
2. boolean test = (val == 0)|(++val == 2);
3. System.out.println(“test = “ + test + “\nval = “ + val);

Первый пример иногда будет выводить на печать вот это:

test = true
val = 0

А иногда вот это:

test = true
val = 2

Второй пример иногда будет выводить на печать вот это:

test = true
val = 1

А иногда вот это:

test = true
val = 2

А дело вот в чём. Если val равно 0, то второй операнд (++val) никогда не будет вычислен, то есть val останется равным нулю. Если же изначально val равен единице, то в результате эта переменная будет инкрементирована и мы увидим val = 2. Во втором примере, при использовании неукороченных операторов, инкремент выполняется всегда и результат будет всегда или 1 или 2 в зависимости от случайного значения выбранного на первом шаге. В обоих примерах переменная test принимает значение true, потому что либо val = 0, либо val = 1 и инкрементируется до значения 2.

Резюмируем информацию об укороченных операторах && и ||:

Они применяются к операндам типа boolean;
Они вычисляют значение правого операнда только если результат не может быть вычислен на основании значения левого операнда:

false AND X = false
true OR X = true

Откуда скачать Java (Выпуск 9)

2008-06-29T05:53:00.000-07:00

Получила первое письмо от читателя рассылки, в котором вопрос: откуда скачать Java. Скачать Java очень просто:

Идём на сайт java.sun.com.
На открывшейся странице в верхней менюшке наводим курсором на Downloads и из выпадающей менюшке выбираем Java SE (подсвечено оранжевым на рисунке ниже).
На открывшейся странице (см. рис. ниже) нам нужно выбрать (кнопка Download) JDK 6 Update 6 (отмечено красным).

На открывшейся странице необходимо выбрать платформу (Windows, Linux и т.д.). И опция Multi-language, по-моему, там единственная. Отметьте также галочкой License Agreement и нажмите оранжевую кнопку Continue.

Наконец мы добрались до ссылки на скачивание. При этом вы можете выбрать либо пакет для он-лайн инсталляции, либо пакет для офф-лайн инсталляции. Он-лайн инсталляция, конечно, занимает мало (0.36Мб)по сравнению со вторым пакетом (71.49Мб), но это только кажимость. Всё равно все недостающие компоненты будут подкачиваться из интернета в процессе инсталляции. Так что все 70 мег вам так или иначе придётся скачать. Единственная разница в том, что в первом случае (он-лайн инсталляция) вы ещё окажетесь связанными по рукам, если вдруг у вса не окажется под рукой интернета при переустановки джавы. Так что я рекомендую скачивать офф-лайн инсталляцию (отмечено красным карандашом на рис. ниже).

Скачиваемый файл в моём случае (винда) называется jdk-6u6-windows-i586-p.exe. И я егос охранила на диск (Salva, Save).

Скачивание длилось у меня где-то 10 минут.

Потом нужно просто запустить скачанный файл. Установится JRE (Java Run-time Edition), то есть всё то, что необходимо для функционирования джавы под платформу, выбранную на шаге 4. А также устанится JDK (Java Development Kit), то есть всё, что нужно для программирования: документация, библиотеки, примеры...

2.6 Поразрядные операторы: &, ^ и | (Выпуск 9)

2008-06-29T03:09:00.000-07:00

Поразрядные операторы &, ^ и используются для выполнения побитовых операций AND, XOR и OR соответственно. Они применяются к целочисленным типам. Набор битов является эффективным средством экономии памяти, когда некое состояние (например, данные физических устройств) необходимо представить в виде вектора значений типа boolean.

Результат применения операторов &, ^ и к двум операндам описывается таблицами 1, 2 и 3 соответственно.

Таблица 1: Операция AND

Операнд₁	Операнд₂	Операнд₁ AND Операнд₂
0	0	0
0	1	0
1	0	0
1	1	1

Таблица 2: Операция OR

Операнд₁	Операнд₂	Операнд₁ OR Операнд₂
0	0	0
0	1	1
1	0	1
1	1	1

Таблица 3: Операция XOR

Операнд₁	Операнд₂	Операнд₁ XOR Операнд₂
0	0	0
0	1	1
1	0	1
1	1	0

Для AND операции результат будет истинным (1), если оба операнда истинны. Для OR оператора результат истинный, если хотя бы один операнд истинный. Для XOR оператора результат истинный, если один и только один (не оба!) операнд истинный. XOR - это исключающий (eXclusive) OR.

Сейчас мы рассмотрим работу этих операторов не над одним единственным битом, но над битовым представлением числа.

Пример 1.

    00110011
    11110000
AND --------
    00110000

Посмотрите, как каждый бит результата считается на основе битов на соответсвующих позициях двух операндов. Первые биты двух операндов равны 0 и 1, значит первый бит результата равен 0 согласно Таблице 1. Третьи биты равны 1 и 1, значит результат равен 1. Пятые биты равный 0 и 0, значит результат равен 0. Последние биты равны 1 и 0, значит результат равен 0.

Пример 2.

    00110011
    11110000
XOR --------
    11000011

   00110011
   11110000
OR --------
   11110011

Для вычисления результата операций XOR и OR необходимо воспользоваться таблицами 3 и 2 соответсвенно для соответсвующих разрядов первого (верхнего) и второго (нижнего) операндов. Заметьте, что операции AND, OR, XOR коммутативны, то есть результат изменится прежним, даже если мы поменяем операнды местами.

Аналогичным образом таблицы 1, 2, 3 можно применить и к значениям типа boolean, где 1 - true, 0 - false. При этом операнды должны быть булевого типа (например, a==10) и операторы &, ^ и применяются не побитово, а ко всему булевому выражению.

Оба операнда должны быть либо целочисленного типа (и тогда операторы &, ^ и применяются поразрядно), либо булевого типа (и тогда операторы применяются ко всему выражению). В Java нельзя привести тип к boolean. Вместо этого необходимо использовать булевы выражения, например, сравнения.

2.5 Операторы сравнения (Выпуск 8)

2008-05-28T11:37:00.000-07:00

Операторы сравнения, <, >, <=, >=, ==, !=, возвращают результат типа boolean, то есть true или false. Эти операторы обычно используются в условных конструкциях (например, if () или циклы). Существует три типа сравнения:

порядковое (ordinal) тестирует относительные значения числовых операндов.
объектно-ориентированное определяет тип объекта во время исполнения программы.
операторы равенства тестируют, одинаковы ли два значения, в том числе и нечисленные.

Рассмотрим их все подробнее.

Порядковые операторы (<, >, <=, >=)

К порядковым операторам относятся < (меньше), > (больше), <= (меньше либо равно), >= (больше либо равно). Они применяются ко всем численным типам и типу char и возвращают результат boolean. Например, если у нас имеются следующие объявления:

int p = 9;
int q = 65;
int r = -12;
float f = 9.0F;
char c = ‘A’;

то следующие тесты возвратят true:

p < q
f < q
f <= c
c > r
c >= q

Заметьте, что, когда эти операторы используются, применяется арифметическое распространение. Например, будет ошибкой присвоение значение 9.0F типа float переменной c типа char. Но к этой паре может быть применено сравнение! Для этого Java распространяет меньший тип к большему типу. То есть значение 'A' типа char (представляемое значением 65 в Unicode) распространяется до float 65.0F. Сравнение затем выполняется на результирующей паре значений float.

Порядковые сравнения не могут быть применены к объектным типам!

Оператор instanceof

Оператор instanceof тестирует класс объекта в момент исполнения программы (runtime). Левый операнд - любое выражение объектного типа (переменная или массив). Правый операнд - имя класса, интерфейса или массивный тип. Однако, левым операндом не может быть объект типа java.lang.Class, а правым операндом не может быть String.

Фрагмент кода ниже показывает пример использования оператора instanceof. Предположим, что существует класс Person с подклассом Parent:

1. public class Classroom {
2.     private Hashtable inTheRoom = new Hashtable();
3.     public void enterRoom(Person p) {
4.         inTheRoom.put(p.getName(), p);
5.     }
6.     public Person getParent(String name) {
7.         Object p = inTheRoom.get(name);
8.         if (p instanceof Parent) {
9.             return (Parent)p;
10.        }
11.        else {
12.            return null;
13.        }
14.    }
15. }

Метод getParent() в строках 6-14 проверяет, содержит ли Hashtable родителя со специфическим именем. Для этого в Hashtable сначал ищется элемент со специфическим именем родителя. А потом проверяется, является ли этот элемент объектом типа Parent. Оператор instanceof проверяет, совпадает ли класс левого операнда с названием класса, заданного правым операндом или является его подклассом.

Правый операнд также может быть и названием интерфейса. И в этом случае оператор определяет, имплементирует ли левый аргумент данный интерфейс.

Опертор также используется для тестирования, является ли объект массивом. Поскольку массивы в Java являются объектами, то такое тестирование логично. Но тест проводится в два шага: (1) является ли объект массивом и (2) является ли тип элементов массива (под)классом правого аргумента. Это отражает идею, что массив, скажем, объектов типа Button (кнопки) является массивом объектов типа Component (компоненты), поскольку Button - это Component. Тест для такого массива будет выглядеть так:

if (x instanceof Component[])

Заметьте, что невозможно провести тестирование для "любого массива с элементами любого типа". То есть следующая строка недопустима:

if (x instanceof [])

Недопустимо также тестирование на массив с элементами типа Object:

if (x instanceof Object [])

поскольку элементы массива могут быть примитивного типа и тест, попросту, не сработает.

А как же протестировать, является ли объект массивом без привязки к типу его элементов? Допустим myObject это массив. Тогда следующая строка возвратит true:

myObject.getClass().isArray()

Если левый операнд равен null, то instanceof возвратит false. Никокого исключения не возникнет.

Операторы равенства (== и !=)

Операторы == и != тестируют, соответственно, равенство или неравенство. Для примитивных типов концепция равенства или неравенства достаточно тривиальна. Как и в случае с операторами порядка, операнды распространяются до наибольшего. Например, значение 10.0 типа float равно значению 10 типа byte. Для значений объектного типа, сравниваемая величина - это ссылка на объект, то есть адрес памяти.

Никогда не используйте операторы равенства для сравнения объектных типов (например строк)! Потому что они возвращают true только если адрес памяти совпадает, а не поля объектов совпадают. Для сравнения объектов используется метод equals().

Метод equals() должен был определён в классе сравниваемых объектов. Чтобы быть уверенными в этом, проверьте документацию. В документации должно быть указано, что equals() определён в классе или переопределяет (overrides) метод equals() своего супер-класса. Если документация ничего по этому поводу не говорит, то метод equals() будет, скорее всего, работать неправильно. Метод equals() принимает аргумент типа Object. Но в реальности вы должны передавать ему аргумент того же типа, что и объект, для которого он вызывается. Например, если вы вызываете x.equals(y), то y instanceof x должно возвращать true. Если же это не так, то equals() вернёт false.

Если вы определяете equals() в вашем собственном классе, то вы должны соблюдать три правила:

Аргумент для equals() должен быть объект типа Object. Не поддавайтесь искушению вставить аргумент того же типа, что и класс. Иначе вы перегрузите (overload) метод, а не переопределите (override) его. В итоге функциональность других частей кода, зависящих от equals() будет неправильна. Например, итерации по HashMap, то есть containsKey() и get(), будут неправильны.
equals() должен быть коммутативным оператором. То есть результат x.equals(y) должен быть равен результату y.equals(x).
Если вы лпределяете equals() в своём классе, то вы должны определить и hashCode(), который возвращает одно и то же значение для объектов, сравниваемых методом equals(). Это, опять таки, нужно для правильного функционирования итераций по контейнерам. Минимально допустимое поведение hashCode() - это return 1. Конечно, при такой имплементации потеряются все преимущества "настоящего" хеширования и HashMap будет просто связным списком. Но, по крайней мере, функциональность будет корректной.

2.4. Операторы сдвига <<, >> и >>>(Выпуск 7)

2008-05-15T03:39:00.000-07:00

В Java есть операторы сдвига. Операторы << и >> позаимствованы из С/C++. Кроме того, Java обладает своим новым оператором сдвига >>>.

Операторы сдвига присущи системам, которые могут выравнивать биты, прочтённые из IO портов или зартсываемые в IO порты. Это также быстрое умножение или деление на степень двойки. Преимущество операторов сдвига в Java - это независимость от платформы. Поэтому вы можете использовать их не беспокоясь ни о чём.

Основы сдвига

Сдвиг - это, по сути, простейшая операция: мы берём последовательность битов и двигаем её влево или вправо. Больше всего конфуза вызывает оператор >>>. Но о нём мы поговорим чуть позже.

Операторы сдвига могут применяться лишь к целым числам, то есть к типам int или long. Следующая таблица иллюстрирует базовый механизм сдвига.

Таблица 1: Идея сдвига

Исходные данные	192
Бинарное представление		00000000	00000000	00000000	11000000
Сдвиг влево на 1 бит	0	00000000	00000000	00000001	1000000?
Сдвиг вправо на бит		?0000000	00000000	00000000	01100000	0
Сдвиг влево на 4 бита	0000	00000000	00000000	00001100	0000????
Исходные данные	-192
Бинарное представление		11111111	11111111	11111111	01000000
Сдвиг влево на 1 бит	1	11111111	11111111	11111110	1000000?
Сдвиг вправо на бит		?1111111	11111111	11111111	10100000	0

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

Однако, глядя на таблицу, возникают три вопроса вопроса:

Что происходит, если мы сдвигаем влево и при этом часть бинарной записи выходит за границу слева, а часть - остаётся пустой справа?
Что происходит, когда справа - выход за границы, а слева - пустое место?
Какое истинное значение принимает знак "?"?.

Ответим на часть этих вопросов. Биты, вышедшие за границы, просто теряются. Мы о них забываем.

В некоторых языках, типа ассемблер, есть операция ротации, когда при сдвиге вышедшие за границы биты не теряются, но ставятся на освободившееся место (вместо вопросиков). Однако языки высокого уровня, типа Java, не имеют в своём арсенале такой операции.

Сдвиг отрицательных чисел

Ответ на вопрос о значении символов "?" в приведенной выше таблице требует отдельного рассмотрения.

В случае сдвига влево << и беззнакового сдвига вправо >>> новые биты просто устанавливаются в ноль. В случае сдвига вправо со знаком >> новые биты принимают значение старшего (самого левого) бита перед сдвигом. Следующая таблица демонстрирует это:

Таблица 2: Сдвиг положительных и отрицательных чисел

Исходные данные	192
Бинарное представление	00000000	00000000	00000000	11000000
Сдвиг вправо на 1 бит	00000000	00000000	00000000	01100000
Сдвиг вправо на 7 бит	00000000	00000000	00000000	00000001
Исходные данные	-192
Бинарное представление	11111111	11111111	11111111	01000000
Сдвиг вправо на 1 бит	11111111	11111111	11111111	10100000
Сдвиг вправо на 7 бит	11111111	11111111	11111111	11111110

Заметьте: в том, случае, где старший бит был 0 перед сдвигом, новые биты стали тоже 0. Там где старший бит перед сдвигом был 1, новые биты тоже заполнились 1.

Это правило может показаться странным на первый взгляд. Но оно имеет под собой очень серьёзное обоснование. Если мы сдвигаем бинарное число влево на одну позицию, то в десятичной записи мы умножаем его на два. Если мы сдвигаем влево на n позиций, то умножение происходит на 2ⁿ, то есть на 2, 4, 8, 16 и т.д.

Сдвиг вправо даёт деление на степени двойки. При этом, добавление слева нулей на появившиеся биты на самом деле даёт деление на степени двойки лишь в случае положительных чисел. Но для отрицательных чисел всё совсем по другому!

Как известно, старший бит отрицательных чисел равен единице, 1. Для того, чтобы сохранить старшинство единицы при сдвиге, то есть сохранить отрицательный знак результата деления отрицательного числа на положительное (степень двойки), нам нужно подставлять единицы на освободившиеся места.

Если мы посмотрим на Таблицу 2, то заметим, что 192, сдвинутое на 1 бит вправо - это 192/2=96, а сдвинутое на 7 битов вправо - это 192/2⁷=192/128=1 по законам целочисленной арифметики. С другой стороны, -192 сдвинутое на 1 бит вправо - это 192/2=-96 и т.д.

Есть, однако пример, когда реультат сдвига вправо отличается от результата целочисленного деления на 2. Это случай, когда аргумент = -1. При целочисленном делении мы имеем: -1/2=0. Но результат сдвига вправо нам даёт -1. Это можно трактовать так: целочисленное деление округляет к нулю, а сдвиг округляет к -1.

Таким образом, сдвиг вправо имеет две ипостаси: одна (>>>) просто сдвигает битовый паттерн "в лоб", а другая (>>) сохраняет эквивалентность с операцией деления на 2.

Зачем же Java потребовался беззнаковый сдвиг вправо (сдвиг "в лоб"), когда ни в С, ни в С++ его не существует? Ответ прост, потому что в С и С++ сдвиг всегда беззнаковый. То есть >>>> в Java - это и есть сдвиг вправо в C и C++. Но, поскольку в Java все численные типы со знаком (за исключением char), то и результаты сдвигов должны иметь знаки.

Сокращение (reduction) правого операнда

На самом деле у операторов сдвига есть правый операнд - число позиций, на которое нужно произвести сдвиг. Для корректного сдвига это число должно быть меньше, чем количество битов в результате сдвига. Если число типа int (long), то сдвиг не может быть сделан более, чем на 32 (64) бита.

Оператор же сдвига не делает никаких проверок данного условия и допускает операнды, его нарушающие. При этом правый операнд сокращается по модулю от нужного количества битов. Например, если вы захотите сдвинуть целое число на 33 бита, то сдвиг произойдёт на 33%32=1 бит. В результатае такого сдвига мы легко можем получить аномальные результаты, то есть результаты, которых мы не ожидали. Например, при сдвиге на 33 бита мы ожидаем получить 0 или -1 (в знаковой арифметике). Но это не так.

Почему Java сокращает правый операнд оператора сдвига или грустная история о заснувшем процессоре

Одной из главной причин введения сокращения было то, что процессоры сами сокращают подобным образом правый операнд оператора сдвига. Почему?

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

Основным применением данных процессоров был контроль систем реального времени. В данных системах самый быстрый ответ на внешнее событие должно занимать не более задержки на прерывание (interrupt latency). Отдельные инскрукции таких процессоров были неделимы. Поэтому выполнение длинных операций (сдвига на несколько бит и ротации) нарушало эффективную работу процессора.

Следующая версия процессора имплементировала эти операции уже по-другому: размер правого операнда сократился. Задержка на прерывание восстанавилась. И многие процессоры переняли данную практику.

Арифметическое распространение (promotion) операндов

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

Следующая таблица показывает пример аномалии:

Таблица 3: Арифметическое распространение для беззнакового сдвига вправо, когда операнд меньше, чем int

Исходные данные (-64 в десятичной записи)	11000000
Распространение до int	11111111	11111111	11111111	11000000
Сдвиг вправо на 4 битa	00001111	11111111	11111111	11111100
Сокращение до байта				11111100
Ожидаемый результат был				00001100

Сложение и вычитание, NaN (Выпуск 6)

2008-05-03T04:19:00.000-07:00

Сложение и вычитание (+ и -)

За сложение и вычитание отвечают соответсвенно операторы + и -. Они применимы для операндов любых численных типов. Помимо этого, операция + применяется и для операндов типа String. Когда один из операндов типа String, то результат будет объектом типа String.

Особенности оператора +

В Java не допускается определять перегрузку операторов (то есть перепрограммирование операторов в зависимости от типа), как в С/С++. Но сам язык Java перегружает операторы автоматически. И это в общем-то не ново, поскольку многие языки программирования, которые поддерживают множественные арифметические типы, определяют автоматическую перегрузку арифметических операторов для примитивных типов. Java, помимо этого, имеет перегрузку оператора + для строкового типа (String). И результат действия оператора + в данном случае - это конкатенация, сцепление строк. Если один из операндов не строковый, то к нему будет предварительно применено приведение типа к строке.

Перегрузка (overloading) - это термин, упоминаемый в том случае, когда одна и та же операция (оператор) используется для операндов (аргументов) различного типа. При этом поведение операции (оператора) определяется типом операндов, к котором она должна быть применена. Например, метод println() может применяться как для операндов строкового, так и целочисленного типа. Эти два использования, на самом деле, относятся к совершенно различным методам. Просто было использовано одно и то же имя операции. Аналогично сложение (+) используется, как для целочисленных, так и для дробных типов. Но код, реализующий это сложение совершенно различный.

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

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

Приведение численных типов к строке

Для объектных типов приобразование к типу String происходит посредством вызова метода toString(). Этот метод определён в классе java.lang.Object, который является прародителем всех остальных классов. Поэтому все объекты наследуют от Object метод toString(). Однако, этот метод выдаёт некое зашифрованное значение объекта. Например, если мы рассмотрим такой код:

1. public class Test {
2.    private static class MyClass {
3.        private String name;
4.        private int age;
5.        public MyClass() {
6.            name = "Natalia Macheda";
7.            age = 28;
8.        }
9.
10.    }
11.    public static void main (String[] args) {
12.        MyClass myObj = new MyClass();
13.        System.out.println(myObj.toString());
14.    }
15.}

То результат, выводимый 13-й строкой будет такого вида: Test$MyClass@c17164. Здесь мы видим имена классов объекта (разделённые символом $) и какой-то идентификатор после символа @. Идентификатор - это, как правило, ссылка на объект.

Это не очень удобно для понимания, но может быть использовано, например, для отладки программы. С другой строны, для предания читаемости результату операции toString() необходимо перегрузить эту операцию. Например, если в 9-й строке вставить код:

9.       public String toString(){
9'. return (name + " " + age);
9''. }

то результат будет Natalia Macheda 28. Заметьте, что втрой аргумент - целочисленного типа. Как же произошло его преобразование в строку?

Преобразование чесленных аргументов к строчному типу неявно использует метод toString() классов-оболочек (wrapper). Например, значение типа int конвертируется вызовом статической функции Integer.toString().

Резюмируем сведения о сложении. Сложение двух числовых значений примтивных типов даёт результат:

примитивного численного типа;
по крайней мере самого длинного типа среди типов операндов, участвующих в сложении;
вычисленный приведением обоих операндов к типу результата и их дальнейшим суммированием.
Результат может переполнить тип и точность вычисления может потеряться.

Если один из операндов - НЕпримитивного типа:

второй операнд должен быть строкового типа. Иначе операция нелегальна;
операнд НЕстрокового типа приводится к типу String и результат - сцепление двух строк.

Приведение операнда объектного типа к строке производится путём вызова метода toString().

Приведение операнда примитивного типа к строке производится неявно путём вызова статичского метода класса-оболочки.

Если вы хотите держать под контролем форматирование результата приведения типа, обратитесь к коду пакета java.text.

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

Арифметические ошибки

Мы ожидаем от арифметических операций результата, который выдаёт знаяение с математическим смыслом. Но, как уже было сказано выше, результат может не соответсвовать нашим ожиданиям в виду ограниченности ресурсов компьютера. В частности:

Деление на ноль (в том числе и для операции %) выдаёт ArithmeticException;
Никаких других исключений для арифметических операций не выдаётся, но результат может быть арифметически неправильным ввиду переполнения.
Дробные типы представляют абстрактные значения при помощи следующих значений: IEEE 754 бесконечности, минус бесконечности и Не-числа NaN (Not a Number). Именные константы, представляющие эти значения, объявлены в классах Float и Double.

NaN сигнализирует о том, что вычисление не имеет результата в математическом понимании. Например, бесконечность или вычисление квадратного корня из отрицательного числа.

Сравнение с НЕ-числом

Два НЕ-числа NaN определены в пакете java.lang. Это Float.NaN и Double.NaN. Следующие сравнения всегда дают false, даже если x равен NaN:

x < Float.NaN
x <= Float.NaN
x == Float.NaN
x > Float.NaN
x >= Float.NaN

В тестах Float.NaN != Float.NaN и Doube.NaN != Double.NaN результат будет true.

Если же вы хотите проверить, что число (не) является NaN, то нужно использовать статические методы Float.isNaN(float) или Double.isNaN(double), определённые в пакете java.lang.

2.3 Арифметические операторы: умножение, деление, деление по модулю

2008-04-27T14:37:00.001-07:00

2.3 Арифметические операторы

По приоритетности за унарными операторами следуют арифметические операторы. Эта группа включает в себя четыре наиболее распространённых оператора: сложение, вычитание, умножение, деление. И не только их. Существует также оператор деления по модулю, который обозначается знаком %. Арифметические операторы разделены на две группы. В первой, более приоритетной, группе находятся *, /, %. Во второй, соответственно, + и -.

Умножение и деление (* и /)

Операторы * и / выполняют умножение и деление над всеми примитивными числовыми типами и char. При делении на ноль возникает ArithmeticException.

Вы, наверное, недоумеваете, зачем я вам рассказываю про умножение и деление известное вам с первого класса. Однако, в программировании мы имеем дело с некоторыми ограничениями, связанными с представлением чисел в компьютере. Эти ограничения накладываются на все числовые форматы, от byte до double. Но наиболее заметны они для целочисленного типа int.

Если вы умножаете или делите два числа, результат вычисляется посредством целочисленной арифметики и сохраняется либо в int, либо в long. Если числа очень большие, то результат будет больше максимального числа, которое можно представить в этих числах. А значит, результат не сможет правильно закодироваться компьютером и не будет иметь смысла. Например, тип byte используется для представления чисел в диапазоне от -128 до 127. Если мы умножим 64 и 4, то результат 256, имеющий в двоичной записи 100000000 девять символов, будет закодирован, как 0, потому что byte использует лишь 8 символов.

Рассмотрим деление. Если вы делите в целочисленной арифметике, результат должен быть обязательно целочисленным. И значит, дробная часть будет потеряна. Например, 7/4 даёт нам 1.75, но в целочисленной арифметике это будет 1.

Таким образом, если вы имеете дело со сложными выражениями, вы можете выбирать последовательность умножений и делений. Но имейте в виду, что умножение может привести к переполнению, а деление - к потере точности. Народная мудрость считает, что выполнение сначала умножений, а потом делений в большинстве случаев выдаёт правильный результат. Рассмотрим пример:

1. int a = 12345, b = 234567, c, d;
2. long e, f;
3.
4. c = a * b / b; // должно равняться а=12345
5. d = a / b * b; // тоже должно равняться а=12345
6. System.out.println(“a is “ + a +
7. “\nb is “ + b +
8. “\nc is “ + c +
9. “\nd is “ + d);
10.
11. e = (long)a * b / b;
12. f = (long)a / b * b;
13. System.out.println(
14. “\ne is “ + e +
15. “\nf is “ + f);

Результат работы данного фрагмента выдаст следующее:

a is 12345
b is 234567
c is -5965
d is 0
e is 12345
f is 0

Пусть вас не смущают числовые значения данного примера. Важно то, что при выполнении умножения первым мы получили переполнение (c is -5965), когда закодировали его в тип int. Однако мы можем получить правильный результат, если закондируем его в более длинный тип, как, например, long. В обоих случаях применение первым деления будет катастрофическим для результата, независимо от длины его типа.

Деление по модулю %

Результат деления по модулю - остаток от деления. Например, 7/4 равно 1 с остатком 3. Поэтому 7%4 = 3. Обычно операнды имеют целочисленный тип, но иногда оператор применяется и к числам с плавающей точкой. Также следует знать некоторые особенности данного оператора, когда операнды отрицательные.

При негативных или дробных операндах правило такое: вычитайте правый операнд из левого до тех пор, пока последний не станет меньше первого. Примеры:

17%5 = ? 17-5=12>5; 12-5=7>5; 7-5=2<5. Значит 17%5 = 2

21%7? 21-7=14>7; 14-7=7=7; 7-7=0<7. Значит 21%7 = 0

7.6%2.9? 7.6-2.9=4.7>2.9; 4.7-2.9=1.8<2.9. Значит 7.6%2.9=1.8

Заметьте: знак результата (положительный или отрицательный) целиком и полностью определён знаком левого операнда, то есть делимого.

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

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

Деление по модулю, как и нормальное деление, может выбросить исключение ArithmeticException, если делитель (правый операнд) ровняется нулю.

2. Операторы и присваивания (Выпуск 4)

2008-04-27T12:56:00.000-07:00

2. Операторы и присвоения" (Operators and assignments)

Операторы в Java используются для разнообразных операций (всех необходимых). Все Javaоператоры перечислены в Таблице 2.1:

Таблица 2.1: Операторы Java в нисходящем порядке приоритетности массива
Категория	Операторы

Унарные	++ -- + - ! ~ ()
Арифметические	* / %
	+ -
Сдвиг	<< >> >>>
Сравнение	< <= > >= instanceof
	== !=
Поразрядные	& ^
Быстрого принятия решения	&&
Условные	?:
Присвоение	= op=

2.1. Порядок вычисления

В Java, в отличие от многих других языков, явный порядок вычисления зафиксирован. Результат любого выражения считается слева направо. Рассмотрим фрагмент кода:

1. int [] a = { 4, 4 };
2. int b = 1;
3. a[b] = b = 0;

Какой элемент массива модифицирован? Какое значение b использовано для выбора элемента массива: 0 или 1? Согласно правилу вычисления слева направо самое левое выражение a[b] должно быть вычислено первым. Так что это a[1]. Затем вычисляется b, то есть активируется ссылка на переменную b. Затем вычисляется константа 0, что не требует никаких операций. Затем в вычисление включаются операторы. Вычисление при этом проводится в порядке приоритетности и ассоциацивности. Для присвоений ассоциативность - справа налево. Таким образом, сначала значение 0 присваивается переменной b, которая, в свою очередь, затем присваивается последнему элементу массива a.

Рекомендуется использовать простые выражения и скобки, чтобы улучшить читаемость кода. Код, сгенерированый компилятром, будет тем же самым, несмотря на скобки.

2.2. Унарные операторы

Большинство оперторов имеют два операнда. Например, когда мы производим умножение, то делаем это с двумя числами. Однако, унарные операторы применяются только к одному операнду. В Java представлены семь унарных операторов:

Инкремент (увеличение значения на 1) и декремент (уменьшение значения на 1): ++ и --
Унарный плюс и минус: + и -
Поразрядное инвертирование: ~
Логическое дополнение: !
Приведение типа: ( )

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

Инкремент (увеличение значения на 1) и декремент (уменьшение значения на 1): ++ и --

Эти операторы изменяют значение выражения добавлением или вычитанием 1. Например, если переменная x типа int равна 10, то ++x (--x) равно 11 (соответственно, 9). Результат записывается в x.

В предыдущих примерах операторы находились перед переменной. Они могут находиться и после неё. И ++x, и x++ дают один и тот же результат, сохраняемый в x. Но значение всего выражения отличается. Например, если y = x++, то значение y равно исходному значению x. Если же y = ++x, то значение y на единицу больше, чем исходное значение x. В обоих случаях значение x увеличивается на 1.

Если инкремент (декремент) расположен слева от выражения, то выражение модифицируется перед тем (после того), как оно начинает участвовать в остальном вычислении. Это называется пре-инкремент (пре-декремент). Соответсвенно, если оператор находится справа от выражения, то в остальном вычислении участвует исходное значение этого выражения. И инкремент (декремент) происходит после того, как вычисление всего выражения завершено.

Таблица 2.2. показывает значения x и y после применения инкремента и декремента справа и слева.

Таблица 2.2: Примеры премодификации и постмодификации инкрементом и декрементом
Категория	Операторы

Начальное значение x	Выражение	Итоговое значение y	Итоговое значение x
5	y = x++	5	6
5	y = ++x	6	6
5	y = x--	5	4
5	y = --x	4	4

Унарный плюс и минус: + и -

Унарные операторы + и - отличаются от обычных бинарных операторов + и -, которые трактуются, как сложение и вычитание. Унарный + не имеет никакого эфекта, кроме подчёркивания положительной природы численного литерала. Унарный - отрицает выражение (было положительным - стало отрицательным, было отрицательным - стало положительным). Примеры:

1. x = -3;
2. y = +3;
3. z = -(y + 6);

В примере единственное обоснование использования унарного плюса - подчёркивание, что переменной y присваивается положительное число. Общее выравнивание кода также более красиво с эстетической точки зрения :). Заметим, что в третьей строке унарный оператор применяется не к литералу, а к выражению. Таким образом, значение переменной z присваивается -9.

Поразрядное инвертирование: ~

Каждый примитивный тип Java представляется в виртуальной машине так, что представление не зависит от платформы. Это означает, что битовый шаблон, используемый для представления некоего отдельного числа, будет всегда тем же самым. Таким образом и манипулирование битами - процесс более эффективный, в силу независимости от платформы. Поразрядное инвертирование означает, что в двоичном представлении числа 0 заменяется на 1, а 1 - на 0.

Например, применение этого оператора к байту с содержимым 00001111 даст 11110000.

Логическое дополнение: !

Оператор ! инвертирует логическое значение выражения. Например, !true = false. Этот оператор часто используется в тестовой части if () конструкции. Эффект этого - изменение значения логического выражения. То есть обработчики if () и else могут быть легко обменяться местами. Рассмотрим два эквивалентных фрагмента кода:

1. public Object myMethod(Object x) {
2. if (x instanceof String) {
3. // do nothing
4. }
5. else {
6. x = x.toString();
7. }
8. return x;
9. }

и

1. public Object myMethod(Object x) {
2. if (!(x instanceof String)) {
3. x = x.toString();
4. }
5. return x;
6. }

В первом фрагменте, тестирование происходит в строке 2, но присвоение - в строке 6, если тест не пройдёт. Это сделано немного громоздко при помощи ветви else конструкции if/else. Второй фрагмент использует оператор логического дополнения, поэтому во второй строке тест инвертирован и может быть прочтён как Если x не строка. Если тест проходит, то обработка происходит в третьей строке и никакого отдельного else не требуется и результирующий код более краток и более читаем.

Приведение типа: ( )

Приведение типа используется для явной конвертации выражения в заданный тип. Операция возможна только для допустимых типов. И во время компиляции, и во время выполнения программы, приведение типа проверяется на корректность. И этот аспект будет описан в дальнейших выпусках рассылки.

Приведение типа применяется для изменения типа значений примитивного типа. Например, мы можем форсировать конвертацию double к int как, например, в следующем фрагменте:

int circum = (int)(Math.PI * diameter);

Здесь приведение типа выражается фрагментом (int). Если бы этот фрагмент отсутсвовал, то компилятор бы выдал ошибку, поскольку double значение, возвращаемое арифметическим выражением не может быть точно представлено int значением, к которому присваивается. Присвоение типа - это способ, которым программист говорит компилятору: "Я знаю, что такое присвоение может быть рискованным, но верь мне, ведь я - специалист". Конечно, если результат при этом теряет точность так, что программа не функционирует должным образом, - это ответсвенность программиста.

Присвоение типа может быть применено и к объектным (непримитивным) типам. Это типично, например, для случаев, когда используются контейнеры типа Vector. Если вы помещаете объект типа String в Vector, то когда вы его извлекаете, тип, возвращаемый методом elementAt(), будет Object. Для использования извлечённого объекта как String нужно применить приведение типа, как, например, в следующем фрагменте кода:

1. Vector v = new Vector();
2. v.add ("Hello");
3. String s = (String)v.get(0);

В данном примере приведение типа имеет место в третьей строке (конструкция (String)). И хотя компилятор допускает такое приведение типа, во время выполнения программы всё равно проверяется, является объект извлечённый из Vector на самом деле объектом типа String. В будущих выпусках я расскажу о допустимых приведениях типов.

Ответы на тест по основам языка (Выпуск 4)

2008-04-27T12:53:00.000-07:00

Ответ В: разность между количеством отрицательных чисел и количеством положительных чисел равна единице (отрицательных чисел больше).
Ответ A, В, C, D, E: все идентификаторы допустимы.
Ответ В, D: все варианты являются допустимыми сигнатурами методов. Но для того, чтобы быть точкой входа в приложение, метод main() должен быть public static void и принимать один параметр типа String[].
Ответ D: порядок Декларация пакета, импорты, классы должен быть соблюдён строго.
Ответ A, E: массив из 25-ти элемнтов индексируется от 0 до 24. Все элементы инициализируются нулём.
Ответ D: объект типа Holder создаётся в третьей строчке. Ссылка на этот объект передаётся в метод bump() в пятой строчке. И внутри метода поле held объекта изменяет значение с 100 на 101.
Ответ C: в метод decrement() передаётся копия аргумента d; копия увеличивает значение на единицу, но сам аргумент нет.
Ответ A: сборщик мусора не может быть вызван принудительно. На вызовы System.gc() и Runtime.gc() нельзя полагаться на 100%, потому что сборка мусора может быть отсрочена в пользу потока более высокой приоритетности. Поэтому ответы B и D неверны. Ответ C неверен хотя бы потому, что метод gc() не принимает никаких аргументов. Ответ E просто напросто декларирует, что объект может быть собран сборщиком мусора, когда тот начнёт свою работу.
Ответ D: 16-тибитный тип short вартируется от -2¹⁵ до 2¹⁵-1 согласно Java спецификации вне зависимости от платформы.
Ответ D: 8-мибитный тип byte вартируется от -2⁷ до 2⁷-1 согласно Java спецификации вне зависимости от платформы.

Тест по основам языка (Выпуск 3)

2008-04-27T12:46:00.000-07:00

1.10. Тест для самопроверки

Данные типов со знаком имеют равное количество положительны ненулевых и отрицательных значений.
1. Истинно
2. Ложно
Выберите все идентификаторы, которые допускаются в Java программе.
1. BigOlLongStringWithMeaninglessName
2. $int
3. bytes
4. $1
5. finallist
Какие из нижеследующих сигнатур могут быть использованы для объявления методаmain()? (Выберите все допустимые.)
1. public static void main()
2. public static void main(String arg[])
3. public void main(String [] arg)
4. public static void main(String[] args)
5. public static int main(String [] arg)
Если исходый файл включает в себя все три высокоуровневых элемента, какова их последовательность?
1. Импорты, декларация пакета, классы
2. Классы, импорты, декларация пакета
3. Декларация пакета идёт первой, а порядок импортов и классов не существенен
4. Декларация пакета, импорты, классы
5. Импорты идёт первыми, а порядок декларации пакета и определений классов несущественен
Рассмотрим следующую строку кода: int[] x = new int[25];. После её выполения, какие утверждения истинны? (Выберите все истинные утверждения.)
1. x[24] = 0
2. x[24] не определено
3. x[25] = 0
4. x[0] = null
5. x.length = 25
Рассмотрим следующий код:
1. class Q6 {
2. public static void main(String args[]) {
3. Holder h = new Holder();
4. h.held = 100;
5. h.bump(h);
6. System.out.println(h.held);
7. }
8. }
9.
10. class Holder {
11. public int held;
12. public void bump(Holder theHolder) {
13. theHolder.held++;
14. }
15. }

Что печатается в строке 6?
1. 0
2. 1
3. 100
4. 101
Рассмотрим следующий код:
1. class Q7 {
2. public static void main(String args[]) {
3. double d = 12.3;
4. Decrementer dec = new Decrementer();
5. dec.decrement(d);
6. System.out.println(d);
7. }
8. }
9.
10. class Decrementer {
11. public void decrement(double decMe) {
12. decMe = decMe - 1.0;
13. }
14. }

Что печатается в строке 6?
1. 0.0
2. -1.0
3. 12.3
4. 11.3
Как можно заставит сборщик мусора освободить память, выделенную под некий объект?
1. Никак
2. Вызвав System.gc()
3. Вызвав System.gc(), и передав параметром ссылку на объект, память под который хотим освободить
4. Вызвав Runtime.gc()
5. Установив ссылку на объект в null
Каков диапазон значений, которые могут быть присвоены перемнной типа short?
1. Зависит от аппаратного обеспечения компьютера, на котором запускаетя программа
2. От 0 до 2¹⁶-1
3. От 0 до 2³²-1
4. От -2¹⁵ до 2¹⁵-1
5. От -2³¹ до 2³¹-1
Каков диапазон значений, которые могут быть присвоены перемнной типа byte?
1. Зависит от аппаратного обеспечения компьютера, на котором запускаетя программа
2. От 0 до 2⁸-1
3. От 0 до 2¹⁶-1
4. От -2⁷ до 2⁷-1
5. От -2¹⁵ до 2¹⁵-1

Резюме по основам языка (Выпуск 3)

2008-04-27T12:45:00.001-07:00

1.9. Итоги первой главы

Элементы исходного файла должны идти в следующем порядке:

Декларация пакетов
Утверждения импортов
Определения классов

В исходном файле должно быть хотя бы одно общедоступное (public) определение класса, имя которого должно совпадать с именем файла.
Идентификатор должен начинаться с буквы, символа доллара или подчёркивания; остальными символами могут быть буквы, цифры, символы доллара или подчёркивания.
В Java имеются четыре примитивных целочисленных типа со знаком: byte, short, int, long.
Два примитивных типа с плавающей точкой: float, double.
Тип char беззнаковый и используется для представления символов Unicode.
Тип boolean принимает только два значения: true или false.
Массивы должны быть (в порядке перечисления):

Объявлены
Созданы
Инициализированы

Инициализация по умолчанию может быть применена и к переменным членам класса, и к элементам массивов, но не к автоматическим переменным (создаются в методе или передаются в него параметром). Значения по умолчанию: 0 - для численных типов, null - для ссылок на объекты и для типа char, false - для boolean.
Член length массивов возвращает количество элементов в массиве.
Класс с методом main() может быть вызван из командной строки, как Java приложение. Сигнатура для этого метода: public static void main(String[] args), где аргумент args содержит все параметры входной строки, которые идут следом за именем класса.
Параметры метода - копии, а не оригиналы. Для параметров примитивных типов это означает, что модификации переменных внутри вызываемого метода не видны методу вызывающему. Для параметров объектого типа (в том числе и для массивов) это тоже имеет место, но модификация объекта или массива, на который ссылается параметр, видна в вызывающем методе.
Сборщик мусора может освободить память, если ясно, что она больше не используется.
Достоверная сборка мусора невозможна.
Невозможно предсказать, когда неиспользуемая память будет освобождена.
Сборка мусора не гарантирует, что не случится утечка памяти, которая может иметь место, если ссылки на неиспользуемые объекты не установлены в null или не уничтожены (например, с выходом из вызываемого метода).

Передача параметров, сборщик мусора (Выпуск 3)

2008-04-27T12:40:00.000-07:00

1. Основы языка (окончание)

1.7. Передача параметров

Параметр = Аргумент (argument)

При передаче параметров при вызове функции в Java, на самом деле передаётся копия параметра. Рассмотрим фрагмент кода:

1. double radians = 1.2345;
2. System.out.println("Синус от " + radians + " = " + Math.sin(radians));

Переменная radians состоит из битового шаблона, который представляет собой число 1.2345. Во второй строке копия этого битового шаблона передаётся в аппарат вызывания методов Виртуальной Java Машины (Java Virtual Machine, JVM).

Когда параметр передаётся в метод, изменения значения параметра методом не отражаются на исходном значении параметра вне метода. Для наглядности рассмотрим пример:

1. public void bumper(int bumpMe) {
2. bumpMe += 15;
3. }

Метод bumper вызывается в следующем коде:

1. int xx = 12345;
2. bumper(xx);
3. System.out.println("Сейчас xx равен " + xx);

Во второй строке xx копируется и передаётся в bumper(), который изменяет значение 12345 на 12360 (+15). Но в третьей строке выводится всё равно 12345, потому что вне метода bumper() значение xx не изменяется.

Это также имеет место, когда передаваемый параметр объект, а не переменная примитивного типа. Однако эффект совсем другой. Для понимания этого, рассмотрим концепцию ссылки на объект. Java программы не работают непосредственно с объектами. Когда конструктор создаёт объект, то возвращает некое значение, битовый шаблон, который уникальным образом идентифицирует объект. Это значение называется ссылка на объект. Например, рассмотрим следующий код:

1. Button btn;
2. btn = new Button("Ok");

Во второй строке конструктор Button возвращает ссылку на только что созданнную кнопку посредством переменной btn. Это не сам объект и не его копия, но ссылка на объект. Например, в некоторых имплементациях JVM ссылка - это адрес объекта.

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

Рассмотрим следующий фрагмент кода:

1. Button btn;
2. btn = new Button("Pink");
3. replacer(btn);
4. System.out.println(btn.getLabel());
5.
6. public void replacer(Button replaceMe) {
7. replaceMe = new Button("Blue");
8. }

Во второй строке создаётся кнопка, ссылка на которую сохраняется в переменной btn. В третьей строке копия ссылки на кнопку Pink передаётся в метод replacer(), который (в строке 7) создаёт вторую кнопку Blue, ссылку на которую сохраняет в переданном параметре replaceMe. Но вне метода replacer() ссылка на кнопку Pink остаётся той же самой, поэтому строка 4 напечает Pink.

Таким образом, вызываемый метод не изменяет значение параметра вызывающего метода, то есть значения передаваемых параметров сохраняются вызывающим методом. Однако, когда вызываемый метод производит операции над объектами через значение ссылки, передаваемой как параметр, последствия могут быть другими. Иными словами, если вызываемый метод модифицирует объект через саму ссылку, то изменения видны вызывающему методу. Если мы в предыдущем примере седьмую строку заменим на

7. replaceMe.setLabel("Blue");

то, хоть переданная ссылка btn и та же самая, что и в предыдущей версии примера, но сам объект изменён. Ссылка на объект не изменяется, но используется для доступа к самому объекту. В результате четвёртая строка выдаст Blue в выходном потоке.

Массивы - это объекты, а значит, программы работают со ссылками на них, а не непосредственно с ними. То есть при передаче ссылки на массив в некоторый метод, возможно изменить содержимое массива, хранимого в вызывающем методе.

Как создать ссылку на переменную примитивного вида

Это полезная техника для для создания эффекта передачи переменных примитивного вида по ссылке (когда вызываемый метод может изменять значение переменной). В вызываемый метод достаточно просто передать массив, состоящий из одного элемента, которым является заданная переменная. В коде это будет выглядеть, например, так:

1. public class PrimitiveReference {
2. public static void main(String args[]) {
3. int [] myValue = { 1 };
4. modifyIt(myValue);
5. System.out.println("myValue contains " + myValue[0]);
6. }

7. public static void modifyIt(int [] value) {
8. value[0]++;
9. }
10. }

1.8. Сборщик мусора (Garbage Collection)

Большинство современных языков программирования позволяют выделять память во время выполнения программы. В Java это делается явно тогда, когда используется оператор new для создания объекта, и неявно - когда вызывается метод, который имеет локальные переменные или параметры. В случае неявного выделения памяти используется стековое пространство, которое освобождается, как только совершается выход из метода. В случае явного выделения памяти (под объекты) используется пространство кучи (heap). Освобождение этой памяти не так тривиально, но об этом поговорим ниже.

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

public void aMethod() {
MyClass mc = new MyClass();
}

локальная переменная mc - это ссылка, память для которой выделяется в стеке. Но память для объекта типа MyClass, на который ссылается mc, выделяется в куче.

В этой части мы рассмотрим освобождение памяти в куче, выделенной для объектов. Мы должны ответить на вопрос: когда мы можем освободить эту память? Некоторые языки программирования обязывают программиста явно освобождать память, когда он заканчивает с ней работать. На практике оказалось, что при таком подходе возникает много ошибок, поскольку программист мог или освободить память раньше, чем нужно (вызывая потерю данных), или забыть совсем об её освобождении (провоцируя недостаток памяти). Сборщик мусора в Java полностью решает первую проблему и значительно упрощает вторую.

В Java вы никогда не освобождаете память явно. Во время выполнения программы выделяемая память и её использование отслеживается. Это выполняется в фоновом режиме потоком (Thread, который называется сборщик мусора), имеющим низкую приоритетность. Как только сборщик мусора находит память, которая не достижима ни из одного из действующих потоков, он освобождает её обратно в кучу для последующего использования.

Сбор мусора может быть осуществлён разными способами, каждый из которых имеет свои недостатки и преимущества в зависимости от типа выполняемой программы. Для систем контроля в реальном времени, например, необходимо обеспечивать беспрепятственную реакцию на прерывания. Сборка муссора для таких приложений должна производиться часто, в коротких временных интервалах и должна быть легко прерываема. Программы, которые интенсивно используют память, работают лучше, если сборка муссора проводится редко и быстро. В настоящее время сборщик мусора "зашит" (hardcoded) в систему выполнения Java программ и болшинство его алгоритмов используют компромис между выгрузкой и реактивностью (способность к реагированию). В будущем, наверное, будет возможно подключать различные сборщики мусора (или JVM) с различными алгоритмами в зависимости от наших нужд. По крайней мере, мы себе этого желаем.

Однако мы до сих пор не ответили явно на вопрос, поставленный вначале. Самый лучший ответ: память не освобождается до тех пор, пока она используется. Даже если объект больше не используется, нельзя уверенно сказать, когда память, выделенная под него, будет освобождена. Это может случиться через 1 милисекунду, или через 100 милисекунд, или не случиться вовсе. Методы System.gc() и Runtime.gc() выглядят, как "запустить сборщик мусора", но и на них нельзя полагаться, поскольку другие более приоритетные потоки могут отложить их выполнение. И на самом деле, документация для методов gc() гласит: "Вызов этих методов подразумевает, что JVM приложит усилия для переработки неиспользуемых объектов".

Сама природа автоматического сбора мусора имеет важное последствие: утечка памяти (ведущая к её нехватке) всё ещё может иметь место. Достижимые ссылки на неиспользуемые объекты позволяют последним занимать память и не быть обработанными сборщиком мусора. Решением этой проблемы может быть явное присвоение null значения ссылке на объект, который вам уже не нужен. Это особенно просто в случае имплементации коллекции. Например, пусть массив storage используется для реализации стека. Типичная имплементация метода pop() такова:

1. public Object pop() {
2. return storage[index--];
3. }

Если метод, вызывающий pop(), не позаботится о вытолкнутом объекте после его использования, память для этого объекта не будет освобождена до тех пор, пока не произойдёт выход из вызывающего метода или пока ссылка на этот объект (находящаяся в массиве storage) не будет перезаписана. Это может занять много времени. Для ускорения процесса, метод pop() может быть модифицирован следующим образом:

1. public Object pop() {
2. Object returnValue = storage[index];
3. storage[index--] = null;
4. return returnValue;
5. }

Литералы, массивы, основы классов (Выпуск 2)

2008-04-27T12:26:00.000-07:00

1. Основы языка (продолжение)

1.4. Литералы

Литерал - это костанта (не литерал - это значение определённое во время выполнения программы, например, сумма двух дитералов). Литералы могут являться значениями переменных как примитивных, так и строковых типов. Они появляются в присвоении значения (assignment) справа или в вызовах методов. Вы не можете присвоить какое-то значение литералу, то есть литералы не могут находиться слева в утверждении присвоения.

1.4.1. Литералы типа boolean

Единственные правомерные литералы типа boolean - true и false. Например:

1. boolean isBig = true;
2. boolean isLittle = false;

Здесь boolean isBig = true; - это утверждение присвоения, boolean isBig - это объявление переменной isBig типа boolean, true - это литерал. Заметьте, что литерал находится справа.

1.4.2. Литералы типа char

Литералы типа char могут быть выражены как символ в одинарных кавычках. Например:

char c = 'w';

Естественно, это справедливо только для символов, которые могут быть набраны на клавиатуре. Ещё один способ выражения символьных литералов - Unicode значение, специфицированое четырьмя шестнадцатиричными цифрами, следующими за \u. Всё выражение должно быть взято в одинарные кавычки. Например:

char c1 = '\u4567';

Специальные символы в Java выражаются так:

'\n' - для новой строки;
'\r' - для возврата каретки на начало строки;
'\t' - для табуляции;
'\b' - для возврата каретки на одну позицию назад;
'\f' - для новой страницы;
'\'' - для одинарной кавычки;
'\"' - для двойной кавычки;
'\\' - для обратной наклонной линии.

1.4.3. Целочисленные литералы

Целочисленные литералы могыт быть выражены в десятичной, восьмеричной (префикс литерала - 0) и шестнадцатиречной (префикс литерала - 0х или 0Х) форме. В последнем случае и верхний и нижний регистр может использоваться. Например, 28 может быть выражено шесьтью способами:

28
034
0х1с
0х1С
0Х1с
0Х1С

По умолчанию целочисленный литерал занимает 32 бита. Чтобы указать 64-хбитовый (long) литерал, нужно добавить суффикс L к литеральному выражению. (Можно указывать l и в нижнем регистре, но тогда этот суффикс выглядит как 1 (единица), что может привести к конфузам при чтении кода).

1.4.4. Литералы с плавающей точкой

Литерал с плавающей точкой выражает число с плавающей точкой. Для того, чтобы считаться литералом с плавающей точкой, численное выражение должно удовлетворять одной из следующих опций:

десятичная точка: 1.414
Буква E или e, указывающая на научную нотацию: 4.23E+21
Суффикс F или f, указывающий на литерал типа float: 1.828f
Суффикс D или d, указывающий на литерал типа double: 1234d

Литерал с плавающей точкой без суффикса F или D по умолчанию является литералом типа double.

Если вы присваиваете переменной литеральное значение, например, short s = 9;, компилятор определяет размер литерала согласно типу переменной. Поэтому, только что показанное присвоение сработает без ошибок. Однако, выражение с переменными, как, например, short s1 = 9 + s;, выдаст ошибку компиляции, потому что тип выражения 9 + s есть int, а не short.

1.4.5. Строковые литералы

Строковый литерал - это последовательность символов, заключённых в двойные кавычки. Например: String s = "Characters in strings are 16-bit Unicode.";.

Java включает в себя много различных средств для определения не литеральных строковых значений, например: операторы конкатенации, некоторые сложные конструкторы для класса String. Эти способы мы рассмотрим в других номерах рассылки.

1.5. Массивы (Arrays)

Массивы в Java - это нумерованные коллекции литералов/переменных/выражений примитивных типов, указателей на объекты или других массивов. Массивы в Java однородные, то есть все элементы в массиве должны быть одного типа, за исключением случаев, разрешённых полиморфизмом. Иными словами, когда вы создаёте массив, вы должны определить тип элементов, которые могут в нём содержаться. Если тип не примитивный, а определённый через класс, то реальный массив, помимо объектов заданного класса, может содержать также объекты подклассов того класса, который был указан в объявлении массива.

Массив создаётся последовательностью трёх шагов: объявление, создание и инициализация.

В объявлении содержится имя массива, и тип его допустимых элементов. Например:

1. int[] ints; // массив, состоящий из элементов примитивного типа int
2. double[] dubs; // массив, состоящий из элементов примитивного типа double
3. Dimension[] dims; // массив из указателей на объекты (Dimension - класс в пакете java.awt)
4. float[][] twoDee; // двухмерный массив (т.е. массив массивов) из элементов типа float

Квадратные скобки могут идти и до, и после названия массива. Это также имеет место в декларации методов. Например, метод, который принимает массив элементов типа double как параметр, может быть объявлен так: takeMethod(double[] dubs) или takeMethod(double dubs[]). Метод, который возвращает массив элементов типа double, может быть объявлен как double[] returnMethod() или double returnMethod()[]. Первый способ, лично для меня, более удобен для чтения.

Заметьте, что при объявлении массива не указывается его размер, т.е. число элементов, в него входящих. Размер определяется в момент выполнения программы, когда память под массив выделяется через ключевое слово new. Например:

1. int[] ints; // Объявление массива
2. ints = new int[25]; // Создание массива во время выполнения программы

Поскольку размер массива используется только во время выполнения программы, допустимо определять размер массива через переменную, а не через литерал. Например:

1. int size = 1152 * 900;
2. int[] raster;
3. raster = new int[size];

Объявление и создание массива может быть задано одной строкой:

int[] ints = new int[25];

Когда массив создан, его элементы автоматически инициализируются значениями по умолчанию согласно Таблице 1.4.

Таблица 1.4: Значения по умолчанию для инициализации элементов массива
Тип элемента	Значение по умолчанию	Тип элемента	Значение по умолчанию

byte	0	short	0
int	0	long	0L
float	0.0f	double	0.0d
char	'\u0000'	boolean	false
указатель на объект		null

Методы (и атрибуты) для Java объекта вызываются через точку: имяОбъекта.имяМетода (соответсвенно имяОбъекта.имяАтрибута).

На самом деле, массивы - это объекты, вплоть до того, что вы можете вызывать методы (через точку!) для них (в большинстве своём - это методы класса Object), хотя вы и не можете создавать подклассы для массивов.

Если вы хотите инициализировать массив другими значениями, отличными от тех, что приведены в Таблице 1.4, вы должны комбинировать объявление, создание и инпициализацию в одной строке. Например, массив из пяти опредённых чисел с плавающей точкой задаётся так:

float[] diameters = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f};

Размер массива вычисляется автоматически и равен числу элементов в фигурных скобках.

Конечно же массив может быть также инициализирован явным присвоением значенией каждому элементу массива:

1. long[] squares;
2. squares = new long[6000]; // массив создан, его значения по умолчанию равны 0L
3. for (int i = 0; i < 6000; i++) {
4.  squares[i] = i * i; // значения по умолчанию изменены
5. }

Если в приведенном примере размер массива поменяется (строка 2), то цикл в строке 3 может функционировать с ошибками. Для целостности программы мы перепишем строку 3 следующим образом:

3. for (int i = 0; i < squares.length; i++) { // length - встроенный атрибут массива, обозначающий длину массива

Нумерация элементов в массиве начинается с нуля (0).

В Java можно создавать непрямоугольные массивы. Поскольку многомерные массивы - это массив подмассивов, а каждый подмассив - это отдельный объект, размеры подмассивов могут быть различны. Но в этом случае будьте внимательны с итерацией по массиву.

1.6. Основы классов

Java построена на классах. Более детальное изучение классов мы разберём в других выпусках рассылки. Сейчас же обратимся к базовым понятиям.

1.6.1. Метод main()

Метод main() - это входная точка в приложениях, написанных на Java. То есть для создания приложения, вы пишете класс, в котором присутствует метод main(). Для выполнения приложения наберите в командной строке java и имя класса с методом main().

Форма задания (сигнатура) метода main() такова:

public static void main(String[] args)

Заметьте, метод main() объявлен, как общедоступный (public). Кроме того, требуется, чтобы он был также статическим (static), что означает, что он может быть вызван без создания соответсвующего объекта.

Параметр args - аргументы, которые пользователь ввёл в командную строку после имени класса. Например:

% java Mapper France Belgium

означает, что классу Mapper в командной строке было передано два аргумента France, помещённый в args[0] и Belgium - в args[1]. Имя массива args может быть заменено любым допустимым именем переменной. Главное, что его тип - массив строк.

1.6.2. Переменные и инициализация

Java поддерживает переменные двух типов, зависящих от области видимости переменной:

Член класса: создаётся (уничтожается) при создании (уничтожении) объекта класса. Может иметь явное объявление доступности (общедоступный, защищённый или приватный). Вызывается через обращение к объекту класса. Видимость до закрывающей скобки класса.
Автоматическая переменная метода: создаётся в методе или передаётся в него параметром. Существует во время выполнения метода и, следовательно, видна внутри метода и доступна во время выполнения метода. (Исключения бывают во внутренних классах, но о них мы поговорим в других выпусках рассылки.)

Все переменные первого типа, которым не были присвоены явные значения, автоматически инициализируются значением по умолчанию, которое зависит от типа переменной (см. Таблицу 1.4).

Член класса может быть инициализирован в строке объявления:

1. class HasVariables {
2.  int x = 20; // x устанавливается в значение 20 перед вызовом конструктора класса HasVariables
3.  static int y = 30; // y принимает значение 30 в момент загрузки класса HasVariables

При таком способе, нестатические переменные инициализируются перед вызовом конструктора класса, а статические переменные инициализируются в момент загрузки класса.

Автоматические переменные (также известные как локальные перемнные (local variables)) не инициализируются системой, но должны быть явно инициализированы перед использованием. Например, этот код не откомпилируется:

1. public int wrong() {
2.  int i;
3.  return i+5;
4. }

Ошибка компиляции в строке 3 "Variable i may not have been initialized." (Переменная i, возможно, не инициализирована) возникает часто потому, что некоторые программисты начинают использовать переменные раньше, чем инициализируют их.

1.public double fourthRoot(double d) {
2.  double result;
3.      if (d >= 0) { // использование раньше, чем инициализация
4.          result = Math.sqrt(Math.sqrt(d)); // инициализация
5.      }
6.  return result;
7. }

В шестой строке компилятор выдаст ошибку "Variable result may not have been initialized". Для того, чтобы этого не произошло, перепишем строку 2 следуюшим образом:

2. double result = 0.0; // Инициализация

Теперь переменная result инициализирована. Только что показанная модификация строки 2 демонстрирует, что автоматические перемнные могут быть инициализированы в строке объявления. Хотя инициализация в отдельной строке тоже возможна.

Основы языка Java (Выпуск 1)

2008-04-27T11:09:00.000-07:00

В первом выпуске мы с места в карьер ознакомимся с базовыми понятиями языка программирования Java. Очень можно долго писать вступление и объяснять, что такое Java, и зачем он (язык) нужен, и как он организован. Можно обратить внимание, что для выполнения программ на Jave необходимо генерировать объектный код, а не исполняемый, нудно рассказывать про трансляторы и компиляторы... Я решила, что лучше сразу приступить к изучению. Если что-то не понятно, пишите мне письма, пожалуйста. Я с радостью отвечу на все вопросы.

1. Основы языка

1.1. Исходные файлы

Все исходные файлы (они же "исходники"), написанные в Java, должны заканчиваться расширением .java. Файл должен содержать по крайней мере одно открытое и общедоступное (public) определение класса.

Лирическое отступление для совсем новичков

Java - объектно-ориетированный язык, то есть одним из основных его понятий является "объект", служащий для построения решения проблемы как кирпичи иблоки служат для построения дома). Объект может быть классифицирован (красные и белые кирпичи - они и в Африке кирпичи), отсюда и следует слово "класс", то есть тип строительного материала. Принципы объектно-ориентированного программирования (ООП) мы рассмотрим в следующих выпусках.

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

Если общедоступное определение класса присутствует, оно должно совпадать с именем файла без расширения. Например, если исходник содержит класс Apple, то файл должен называться Apple.java. Исходник может содержать неограниченное число не общедоступных определений классов.

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

Три элемента верхнего уровня известные как единицы компиляции (compilation units) могут также присутствовать в файле:

Объявление пакета (package declaration); например,package exam.problems;
Утверждение импорта (imposrt statement); например, import java.awt.Button; // импортирует специфический класс import java.util.*; // импортирует целый пакет;
Определение класса (class definition); например, public class Test {...}.

Формат объявления пакета очень прост. Сначала идёт ключевое слово package, за которым следует название пакета. А название пакета, в свою очередь, состоит из последовательности определённых элементов, разделённых точкой. Эта последовательность элементов отображает иерархию директорий на диске. В директорию с именем последнего элемента последовательности и находится класс. Рассмотрим пример выше: класс с таким объявлением пакета помещается в директорию problems, которая размещена в директории exam.

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

Лирическое отступление для совсем новичков

Пакеты представляют собой совокупность классов логически связанных между собой. Например, пакет "деньги" может содержать классы "ДолларСША", "Евро", "РоссийскийРубль", "КурсВалют". Пакет(директория) "деньги" может находиться в директории "активы", и тогда объявление пакета имеет вид: package assets.money;, где assets - "активы", а money - "деньги", ясное дело.

Утверждение импорта имеет похожую структуру, за исключением того, что можно импортировать как индивидуальный класс, так и весь пакет целиком. В первом случае, после елючевого слова import вы должны написать полный путь к классу и завершить утверждение точкой с запятой. Во втором случае, нужно просто добавить символ звёздочки после имени директории, в которой находится импортируемый пакет.

Лирическое отступление для совсем новичков

Импортирование пакетов (классов) необходимо объявлять в том случае, если классы этих пакетов (эти классы) используются в текущем классе. Например, в класс "ОплатавМагазине" мы импортируем класс "РоссийскийРубль", то есть пишем: import assets.money.RussianRuble;, где RussianRuble означает "РоссийскийРубль". А в класс "ОплатаНаЧёрномРынке" мы пишем: import assets.money.*;, потому что нам могут понадобиться все заявленные валюты и их курс.

Детальное определение класса мы рассмотрим в следующих выпусках.

Пробелы и коментарии могут предшествовать любой единице компиляции. Например, класс Test может иметь такой вид:

1. // Объявление пакета
2. package exam.prepguide;
3.
4. // Импорты
5. import java.awt.Button; // импортирует специфический класс
6. import java.util.*; // импортирует целый пакет
7.
8. // Определение класса
9. public class Test {...}

Случается, что существуют два класса с одинаковым именем, но в разных пакетах. Например, Date класс в java.util и в java.sql. Если вы используете звёздочку для импорта обоих пакетов, а затем пытаетесь использовать класс названный просто Date, вы получите ошибку компиляции о том, что такое использование неоднозначно. Вы должны или сделать явный импорт класса, или обращаться к классу, используя полный путь к нему.

1.2. Ключевые слова и дентификаторы

В языке Java существует 52 ключевых и зарезервированных слов. Они приведены в Таблице 1.1.

Таблица 1.1: Ключевые и зарезервированые слова в Java
abstract	class	false	import	package	super	try
assert	const	final	instanceof	private	switch	void
boolean	continue	finally	int	protected	syncronized	volatile
break	default	float	interface	public	this	while
byte	do	for	long	return	throw
case	double	goto	native	short	throws
catch	else	if	new	static	transient
char	extends	implements	null	strictfp	true

Слова goto и const являются зарезервированными. Хоть они и не имеют никакого смысла в Java, программисты не могут использовать их как идентификатор.

Идентификатор - это слово, используемого программистом, чтобы дать имя переменной, методу, классу или метке. Ключевые и зарезервированные слова не могут быть использованы в качестве идентификаторов. Идентификатор может начинаться с буквы, символа подчёркивания (_) или символа доллара ($); последующими символами могут быть буквы, цифры, символы подчёркивания или символы доллара. Несколько примеров:

1. foobar // верно
2. BIGinterface // верно, хоть и со встроенным ключевым словом
3. // OK
4. $incomeAfterExpenses // верно
5. 3_node5 // неверно: начинается с цифры
6. !theCase // неверно: должно начинаться с буквы, $, или _

Идентификаторы чувствительны к регистру. Например, Radius и radius - различные идентификаторы.

1.3. Примитивные типы данных

Лирическое отступление для совсем новичков

Типы данных описывают формат, в котором данные хранятся в памяти компьютера. Например: целые и дробные числа, целая строка и отдельный символ, - представляются по-разному. Комплексные типы данных состоят из примитивных. Например, список строк состоит из строки и указателя (целое число) на следующую в списке строку.

Примитивные типы данных в Java: boolen, char, byte, short, int, long, float, double. Размеры этих типов приведены в Таблице 1.2.

Таблица 1.2: Примитивные типы данных и их размер
Тип	Размер (в битах)	Тип	Размер (в битах)

boolean	1	char	16
byte	8	short	16
int	32	long	64
float	32	double	64

Переменные типа boolean принимают только два значения: true и false.

Четыре целочисленных типа со знаком: byte, short, int, long. Их интервалы значений приведены в Таблице 1.3.

Таблица 1.3: Интервалы значений целочисленных типов со знаком
Тип	Размер (в битах)	Минимум	Максимум

byte	8	-2⁷	2⁷-1
short	16	-2¹⁵	2¹⁵-1
int	32	-2³¹	2³¹-1
long	64	-2⁶³	2⁶³-1

Тип char - целочисленный, но без знака. Его диапазон варьируется от 1 до 2^16-2. Java символы (char тип) кодируются в системе Unicode, то есть 16-тибитное представление значительной части символов, используемых в различных письменных системах. Если 9 первых значащих битов установлены в 0, то кодировка остальной части символа совпадает с кодировкой 7-битной
системы ASCII.

Типы с плавающей десятичной запятой: float и double. Они соответсвуют спецификации IEEE 754. Некоторые математические оперции приводят к значению, не имеющему представления в цифрах (например, бесконечность). Для описания таких нецифровых ситуаций и float и double могут представляться специальными битовыми паттернами, которые не соответствуют числам. Эти паттерны определены в классах Float и Double и обращение к ним происходит следующим образом (здесь и далее NaN означает Not a Number, не число):

Float.NaN
Float.NEGATIVE_INFINITY
Float.POSITIVE_INFINITY
Double.NaN
Double.NEGATIVE_INFINITY
Double.POSITIVE_INFINITY

Следующий фрагмент кода показывает пример использования этих паттернов:
1. double d = -10.0 / 0.0;
2. if (d == Double.NEGATIVE_INFINITY) {
3. System.out.println("d только что ушёл в бесконечность: " + d);
4. }

Запомним!
Все численные примитивные типы (то есть кроме boolean и char) - со знаком.