Что почитать: свежие записи из разных блогов

"Что вы знаете о функции main, какие обязательные условия ее определения?"

1. Всякое приложение должно содержать метод с именем main . Он может быть один на все приложение или содержаться в нескольких его классах. Метод main() записывается как обычный метод, может содержать любые описания и действия, но он обязательно должен быть открытым (public), статическим (static), не иметь возвращаемого значения (void). Его аргументом обязательно должен быть массив строк (String[]). По традиции этот массив называют args, хотя имя может быть любым. Туда передаются параметры из командной строки, с помощью которых можно предоставить приложению нужную информацию или настроить его для запуска нужным образом.

public static void main (String args []) {}

скрытый текст1.1 Эти особенности возникают из-за того, что метод main() вызывается автоматически исполняющей системой Java в самом начале выполнения приложения. При вызове интерпретатора java указывается класс, где записан метод main(), с которого надо начать выполнение. Поскольку классов с методом main() может быть несколько, можно построить приложение с дополнительными точками входа, начиная выполнение приложения в разных ситуациях из различных классов.

1.1.1 Когда вы запускается java.exe (или javaw.exe в Windows), на самом деле происходит несколько вызовов Java Native Interface (JNI). JNI - это инструмент, который мы используем, когда нам приходится соединяться между миром виртуальной машины (JVM) и миром C, С++ и т.д. java.exe - это простое приложение C, которое анализирует командную строку, создает новый массив String в JVM для хранения этих аргументов, анализирует имя класса, указанное при вызове как содержащее main(), использует вызовы JNI для поиска самого метода main(), затем вызывает метод main(), передавая вновь созданный строковый массив в качестве параметра.

1.2. Иногда метод main() заносят в каждый класс с целью отладки. В этом случае в метод main() включают тесты для проверки работы всех методов класса.

2. При вызове интерпретатора java можно передать в метод main() несколько параметров, которые интерпретатор заносит в массив строк. Эти параметры перечисляются в строке вызова java через пробел сразу после имени класса. Если параметр содержит пробелы, надо заключить его в кавычки. Кавычки не будут включены в параметр, это только ограничители.

2.1. Примеры вызова main из класса Echo и соответствующих им значений параметра args:

java Echo Hello XXI century: массив из трех элементов Hello, XXI, century
java Echo "Hello XXI century": массив из одного элемента Hello XXI century
java Echo Hello "XXI century": массив из двух элементов Hello, XXI century

"Как передается значение переменной (по ссылке/значению)?"

1. Термины семантики "pass-by-value" и семантики "pass-by-reference" относятся к параметрам функции.

1.1. Pass-by-value (передача параметра по значению). Действительный параметр (или выражение в аргументе) полностью вычисляется, и значение результата копируется в отдельную ячейку памяти, предназначенную для хранения значения этого параметра во время выполнения функции. То есть функция имеет дело с копией переменной, которую передали в функцию в качестве параметра. Место в памяти под параметр - обычно кусок runtime-стека в приложении (обрабатываемый Java), но другие языки могут выбрать хранение параметра в другом месте.

1.2. Pass-by-reference (передача параметра по ссылке). Формальный параметр действует просто как псевдоним (alias) реального параметра. Функция или метод, которая использует формальный параметр (для чтения или записи), в действительности использует актуальный параметр, существующий где-то вне функции.

скрытый текст2. Спецификация Java утверждает, что всегда передача параметров происходит по принципу pass-by-value. В Java нет такого понятия, как "pass-by-reference". Это очевидно для примитивов; в Java вообще нет такого понятия, как указатель/ссылка на примитив. Но объекты также не передаются по ссылке. Вместо этого передаются значения указателей на них. Т.е. скажем при вызове foo(d) в функцию foo передается значение указателя d, а не объект, на который он указывает. Нет никакого способа передать в качестве параметра сам объект.

2.1. То есть данные объявления идентичны:
//Java: пример объявления указателя.
Dog d;
//C++: пример объявления указателя.
Dog *d;

Используются указатели при этом тоже одинаково:
//Java: вызов метода по указателю.
d.setName("Fifi");
//C++: вызов метода по указателю.
d->setName("Fifi");

2.2. Ключевым понятием для понимания является следующее: на Java переменная myDog не является собакой, это указатель на собаку. То есть, если здесь:

Dog myDog = new Dog("Rover");
foo(myDog);

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

2.3. Предположим, что объект Dog находится в памяти по адресу 42. Это означает, что методу foo будет передано 42. Пусть метод foo определен так:

someDog.setName("Max"); // AAA
someDog = new Dog("Fifi"); // BBB
someDog.setName("Rowlf"); // CCC

Параметр someDog установлен в значение 42.

На строке "AAA": someDog следует за объектом Dog по указателю (который находится по адресу 42), так что для этого Dog (находящегося по адресу 42) будет запрошено изменение имени на Max.

На строке "BBB": будет создан новый объект класса Dog. Новый объект получит новый адрес в памяти. Предположим, что этот адрес 74, так что указателю someDog будет присвоено значение 74.

На строке "CCC": someDog следует за объектом Dog по указателю (который находится по адресу 74), так что для этого Dog (находящегося по адресу 74) будет запрошено изменение имени на Rowlf. После этого выполнение метода foo заканчивается.

Если иметь в виду, что myDog является указателем, а не просто объектом Dog, то вне метода foo он все еще имеет значение 42, как и до вызова функции; он все еще указывает на оригинальный объект Dog. Совершенно допустимо следовать по адресу myDog для изменения содержимого объекта, адрес myDog при этом остается однако неизменным.

Т.е. Java работает абсолютно так же, как C. Можно назначить указатель, передать указатель методу, следовать по указателю и изменять данные, на которые указатель указывает. Однако нельзя поменять место расположения объекта, на который указывает указатель.

3. Итого, Java всегда передает параметры по значению.

"Какими значениями инициализируются переменные по умолчанию?"

1. Существует три типа переменных:
- локальные переменные
- переменные экземпляра
- статические переменные (они же переменные класса)

Локальные переменные объявляются в методах, конструкторах или блоках (далее МКБ). Для них не существует значения по умолчанию. Переменные экземпляра и класса объявляются в классе, но за пределами МКБ. Они имеют значения по умолчанию, поэтому явная инициализация не является для них обязательной. С другой стороны обращение к локальной переменной без предварительной инициализации приведет к ошибке при компиляции.

скрытый текст2. Таблица значений по умолчанию для переменных разных типов:

boolean: false
char: u0000 (пустой символ)
int,short,byte / long: 0 / 0L
float /double: 0.0f / 0.0d
ссылочные типы: null

"Что вы знаете о преобразовании примитивных типов данных, есть ли потеря данных, можно ли преобразовать логический тип?"

1. В Java предусмотрено семь видов приведений:

- тождественное (identity);
- расширение примитивного типа (widening primitive);
- сужение примитивного типа (narrowing primitive);
- расширение объектного типа (widening reference);
- сужение объектного типа (narrowing reference);
- преобразование к строке (String);
- запрещенные преобразования (forbidden).

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

2. Иногда возникают ситуации, когда переменной одного типа нужно присвоить значение другого типа. Для некоторых типов это можно проделать и без приведения, в таких случаях говорят об автоматическом преобразовании. В Java оно возможно лишь в случае, когда точности представления чисел переменной-приемника достаточно для хранения исходного значения. Например, при занесении значения переменной типа byte или short в переменную типа int.

скрытый текстЭто называется "расширением" (widening) или "повышением" (promotion), поскольку тип меньшей разрядности "расширяется" ("повышается") до большего совместимого типа. Размера типа int всегда достаточно для хранения чисел из диапазона, допустимого для типа byte, поэтому в подобных ситуациях оператора явного приведения типа не требуется. Обратное в большинстве случаев неверно, поэтому для занесения значения типа int в переменную типа byte необходимо использовать оператор приведения типа. Эту процедуру иногда называют "сужением" (narrowing), поскольку транслятору явно сообщается, что величину необходимо преобразовать, чтобы она уместилась в переменную нужного типа. Для этого перед ней нужно указать данный тип, заключенный в круглые скобки.

int a = 100;
byte b = (byte) a;

2.1. Следующие 19 преобразований являются расширяющими:
- от byte к short, int, long, float, double
- от short к int, long, float, double
- от char к int, long, float, double
- от int к long, float, double
- от long к float, double
- от float к double

2.1.1. Нельзя провести преобразование к типу char от типов меньшей или равной длины (byte, short), или, наоборот, к short от char без потери данных. Это связано с тем, что char, в отличие от остальных целочисленных типов, является беззнаковым.

2.1.2. Даже при расширении данные все-таки могут быть в особых случаях искажены. Это приведение значений int к типу float и приведение значений типа long к типу float или double. Хотя эти дробные типы вмещают гораздо большие числа, чем соответствующие целые, но у них меньше значащих разрядов.

long a=111111111111L;
float f = a;
a = (long) f;
print(a);

Результатом будет: 111111110656

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

byte a = 40;
byte b = 50;
byte с = 100;
int d = a* b / с;

Результат промежуточного выражения (а*b) вполне может выйти за диапазон допустимых для типа byte значений. Именно поэтому Java автоматически повышает тип каждой части выражения до типа int, так что для промежуточного результата (а*b) хватает места.

3.1. Если в выражении используются переменные типов byte, short и int, то во избежание переполнения тип всего выражения автоматически повышается до int. Если же в выражении тип хотя бы одной переменной — long, то и тип всего выражения тоже повышается до long. Надо учитывать, что целые литералы, в конце которых не стоит суффикс L, имеют тип int.

3.2. Если выражение содержит операнды типа float, то и тип всего выражения автоматически повышается до float. Если же хотя бы один из операндов имеет тип double, то тип всего выражения повышается до double. По умолчанию Java рассматривает все литералы с плавающей точкой, как имеющие тип double. Приведенная ниже программа показывает, как повышается тип каждой величины в выражении для достижения соответствия со вторым операндом каждого бинарного оператора.

3.3. Автоматическое преобразование типа иногда может оказаться причиной неожиданных сообщений транслятора об ошибках. Например, показанный ниже код, хотя и выглядит вполне корректным, приводит к сообщению об ошибке на фазе трансляции. В нем значение 50*2, которое должно уместиться в тип byte, записывается в байтовую переменную. Из-за автоматического преобразования типа результата в int получаем сообщение об ошибке от транслятора — ведь при занесении int в byte может произойти потеря точности.

byte b = 50;
b = b* 2;

^ Incompatible type for =. Explicit cast needed to convert int to byte.
(Несовместимый тип для =. Необходимо явное преобразование int в byte)

Исправленный текст :
byte b = 50;
b = (byte) (b* 2);

4. Если попытаться поместить в переменную-контейнер то, что туда не помещается, то в ней останется лишь то, что туда «влезло». К примеру, у чисел с плавающей точкой будет «отсекаться» дробная часть.

double a=11.2345;
int b=(int)a;
System.out.println(b); // в консоли получится число 11

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

4.1. При этом могут возникнуть особые случаи:

- если исходное дробное значение является NaN, то результатом первого шага будет 0 выбранного типа (т.е. int или long);
- если исходное дробное значение является положительной или отрицательной бесконечностью, то результатом первого шага будет, соответственно, максимально или минимально возможное значение для выбранного типа (т.е. для int или long);
- наконец, если дробное значение было конечной величиной, но в результате округления получилось слишком большое по модулю число для выбранного типа (т.е. для int или long), то, как и в предыдущем пункте, результатом первого шага будет, соответственно, максимально или минимально возможное значение этого типа. Если же результат округления укладывается в диапазон значений выбранного типа, то он и будет результатом первого шага.

4.2. Надо учитывать, что дробная часть не округляется, а именно отбрасывается. Т.е. 2.7 -> 2. А если в byte (диапазон от -128 до 127) положить число 128, то результатом будет не 1, а -128 (значения старших битов будут потеряны). Значение переменной при таком преобразовании можно рассчитать, но цель программиста – не допускать ситуации, когда значение выходит за допустимые границы, поскольку это может привести к неправильной работе программы. Если число больше своего контейнера, результат будет непредсказуемым.

4.2. Следующие 23 преобразования являются сужающими:
- от byte к char
- от short к byte, char
- от char к byte, short
- от int к byte, short, char
- от long к byte, short, char, int
- от float к byte, short, char, int, long
- от double к byte, short, char, int, long, float

"На какие основные группы можно поделить типы данных?"

3. Все типы, кроме примитивных, относятся к ссылочным. Это все классы (включая String), интерфейсы, массивы. Они создаются комбинированием примитивных типов на основании класса. Класс похож на план для определения ссылочного типа.

3.1. Существуют классы-обертки: Byte, Short, Integer, Long, Float, Double, Character, Boolean. В отличие от примитивных типов, они пишутся с заглавной буквы. Эти типы соответствуют примитивным типам, однако являются ссылочными. Их классы cодержат методы для преобразования типов, а также другие константы и методы полезные при работе с примитивными типами данных. Например минимальное значение типа int можно узнать использовав константу Integer.MIN_VALUE.

скрытый текст3.1.1. Если требуется создать ссылку на один из примитивных типов данных, необходимо использовать соответствующий класс-обертку. Оборачивание примитива в объект называется упаковкой (boxing), а обратный процесс распаковкой (unboxing).

int i;
Integer boxed;
// Обычное создание объекта
boxed = new Integer(i);
// Фабричный метод
boxed = Integer.valueOf(i);
// Автоматическая упаковка, компилятор просто вставит вызов Integer.valueOf
boxed = i;

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

3.1.2. Получить примитив из объекта-обертки можно методом <имя примитивного типа>Value.

Integer boxed;
int i;
// Явная распаковка
i = boxed.intValue();
// Автоматическая распаковка
i = boxed;

3.2. Тип String предназначен для хранения строк текста. Он не является примитивным типом данных. Это один из наиболее используемых типов в Java. Строковые литералы записываются в двойных кавычках.

//Создание строки с помощью конструктора
String myString = new String("The weather was fine");
//Можно также создать строку используя кавычки ""
String myString = "The weather was fine";

Второй вариант помогает инициализировать строки так же просто, как и переменные примитивных типов.

3.2.1. Для строк определен оператор «+»

String s1 = "I have ";
String s2 = " apples ";
int num = 3;
String s = s1 + num + s2;

Результат: "I have 3 apples".

"На какие основные группы можно поделить типы данных?"
"Какие примитивные типы вы знаете? Назовите размерность в байтах для каждого типа."

1. Типы данных делятся на две категории:
- примитивные
- ссылочные

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

2. Примитивные типы можно разделить на четыре группы:
- Целые. К ним относятся типы byte, short, int и long. Эти типы предназначены для целых чисел со знаком.
- Типы с плавающей точкой — float и double. Они служат для представления чисел, имеющих дробную часть.
- Символьный тип char. Этот тип предназначен для представления элементов из таблицы символов, например, букв или цифр.
- Логический тип boolean. Это специальный тип, используемый для представления логических величин.

скрытый текст2.1. Целочисленные типы различаются между собой только диапазонами возможных значений. В языке Java понятие беззнаковых чисел отсутствует. Все числовые типы этого языка — знаковые.

byte (8 бит): от -128 до 127
short (16 бит): от -32768 до 32767
int (32 бит): от -2147483648 до 2147483647
long (64 бит): от -9223372036854775808 до 9223372036854775807

2.1.1. Переменные типа byte полезны при работе с потоком данных, который поступает из сети или файла. Тип int при работе с целочисленными данными используется чаще, нежели byte и short, даже если их диапазона хватает. Это происходит потому, что всякий раз, когда в одном выражении фигурируют переменные типов byte, short, int и целые литералы, тип всего выражения перед завершением вычислений приводится к int. Тип long удобен для работы с большими целыми числами. Его диапазон допустимых значений достаточно велик даже для таких задач, как подсчет числа атомов во вселенной.

2.1.2. Не надо отождествлять разрядность целочисленного типа с занимаемым им количеством памяти. Исполняющий код Java может использовать для ваших переменных то количество памяти, которое сочтет нужным, лишь бы только их поведение соответствовало поведению заданных вами типов. Фактически, нынешняя реализация Java из соображений эффективности хранит переменные типа byte и short в виде 32-битовых значений, поскольку этот размер соответствует машинному слову большинства современных компьютеров.

2.1.3. Тип int для целочисленных литералов считается видом значения по умолчанию. Чтобы он интерпретировался, как long, можно поставить в конец L: например, 100L. Для прочих целочисленных типов аналогичных суффиксов нет, и используется явное приведение типа:

byte foo = (byte)0;
short bar = (short)0;

2.2. Числа с плавающей точкой, часто называемые в других языках вещественными числами, используются при вычислениях, в которых требуется использование дробной части. В Java реализован стандартный набор типов для чисел с плавающей точкой — float и double и операторов для работы с ними.

double (64 бита) 1. 7е-308.. 1. 7е+ 308
float (32 бита) 3. 4е-038.. 3. 4е+ 038

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

float f;
float f2 = 3. 14F;
double d;
double pi = 3. 14159265358979323846;

Все "трансцендентные" (тригонометрические, показательные, логарифмические, и.т.п.) математические функции, такие, как sin, cos, sqrt, возвращают результат типа double.

2.3. В Java для представления символов в строках используется кодировка Unicode. Это объединение десятков кодировок символов, он включает в себя латинский, греческий, арабский алфавиты, кириллицу и многие другие наборы. Диапазон типа char — 0..65536. Иногда его тоже относят к целочисленным типам из-за особенностей представления в памяти и традиций.

char (16 бит): один символ UTF-16 (буквы и цифры)

2.3.1. Хотя величины типа char и не используются, как целые числа, с ними можно оперировать, как если бы они были целыми. Это дает возможность сложить два символа вместе или инкрементировать значение символьной переменной.

int three = 3;
char оne = '1';
char four = (char) (three+ оne);

Тип переменной one в приведенном выше выражении повышается до типа int, так что перед занесением результата в переменную four приходится использовать оператор явного приведения типа.

2.3.2. Символы char можно задавать также при помощи соответствующих чисел.

char symb1=1067;
char symb2 ='Ы';

2.3.3. Пример, как узнать, какому числу соответствует символ. Основан на претиповании данных:
char ch = 'J';
int intCh = (int) ch;

2.4. В языке Java имеется простой тип boolean, используемый для хранения логических значений.

boolean (8 бит в массивах, 32 бита не в массивах, т.к. используется int): true (истина) или false (ложь)

2.4.1. Значения типа boolean возвращаются в качестве результата всеми операторами сравнения, например (а < b). Также boolean — это тип, требуемый всеми условными операторами управления — такими, как if, while, do.

"Что значит слово «инициализация»?"
"Какими значениями инициализируются переменные по умолчанию?"

1. Переменная — это именованная область памяти, куда может быть (пере)записано и откуда может быть прочитано значение определенного типа. Тип и имя переменной обязательно задаются при ее создании (= объявлении) и не могут быть изменены по ходу выполнения программы.

1.1. Тип данных определяет размер и размещение переменной в памяти.

1.2. Основная форма объявления переменной:

тип данных переменная [ = значение], [переменная [= значение], ...] ;

После объявления переменной ее нужно явно инициализировать с помощью оператора присваивания, поскольку использовать переменную, которой не присвоено никакого значения, невозможно. Язык Java обладает возможностью совмещать объявление и ини­циализацию переменной в одной строке. Чтобы определить более, чем одну переменную типа, можно использовать список с запятыми в качестве разделителей.

скрытый текстint a, b, c; // Объявление трех целых a, b, и c.
int a = 10, b = 10; // Пример инициализации.
byte b = 22; // Инициализация переменной b типа byte.
double pi = 3.14159; // Объявление и присвоение величины пи.
char a = 'a'; // Переменной a типа char присваивается значение 'a'.

1.3. Существует три типа переменных:

- локальные переменные
- переменные экземпляра
- статические переменные или переменные класса

1.3.1. Локальные переменные объявляются в методах, конструкторах или блоках (далее МКБ). Они создаются, когда МКБ запускается; уничтожаются после его завершения; видны только в его пределах. Для них нельзя использовать модификаторы доступа. Реализуются на уровне стека. Для них не существует значения по умолчанию.

1.3.2. Переменные экземпляра объявляются в классе, но за пределами МКБ. Создаются тогда, когда объект создан (ключевое слово new); уничтожаются вместе с ним; являются видимыми для всех МКБ в классе. Внутри класса доступны через имя переменной; в статических методах и других классов — через полное имя (ObjectReference.VariableName). Возможно использование модификаторов доступа. В них хранятся значения, на которые должен ссылаться более одного МКБ; а также основные состояния объекта. Когда для объекта выделяется пространство в стеке, для переменной экземпляра создается соответствующий ей слот. Они имеют значения по умолчанию (для чисел это 0, для логических false, для ссылок на объект null.

1.3.3. Переменные класса (они же статические переменные) объявляются с ключевым словом static в классе, но за пределами МКБ. Создаются при запуске программы; уничтожаются при ее завершении. Видимость аналогична переменной экземпляра, но часто рекомендуется модификатор public, т.к. обычно они используются как константы и должны быть доступны пользователям класса. Константы - переменные, которые объявлены как public/private, final и static. Константы никогда не меняются от первоначального значения. Значения по умолчанию аналогичны переменным экземпляра. Значения могут быть присвоены также в специальных блоках статического инициализатора, код которых выполняется при первой загрузке класса.

"Из каких символов может состоять имя переменной (корректный идентификатор)?"

1. Переменная — это именованная область памяти, куда может быть (пере)записно и откуда может быть прочитано значение определенного типа. Тип и имя переменной обязательно задаются при ее создании (= объявлении) и не могут быть изменены по ходу выполнения программы.

2. Имя или идентификатор переменной — это последовательность из строчных и заглавных латинских букв, цифр, а также символов «$» и «_». Имя переменной может начинаться с любого из перечисленных символов, кроме цифры. Она не должно совпадать с ключевым или зарезервированным словом.

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

2.2. Язык Java чувствителен к регистру символов в идентификаторах.

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

3.1. Если имя переменной состоит из нескольких слов, пробелы недопустимы. Каждое следующее слово рекомендуется писать с большой буквы. Желательно подбирать такие имена, чтобы код был максимально читаем. Например: superCounter, myDomesticAnimal

3.2. Если переменная сохраняет постоянное значение, то каждое слово следует писать заглавными буквами и отделять при помощи символа подчеркивания. Например, static final int NUMBER_OF_HOURS_IN_A_DAY = 24