Java - основы языка

Java
основыосновы
ключевые слова, типы, переменные,
операторы, команды, массивы
ключевые слова, типы, переменные,
операторы, команды, массивы
Ставила Леонид
март, 2017

Краткое содержание

Ключевые слова

Типы данных

Литералы

Переменные

Идентификаторы

Инициализация переменных

Операторы

Команды

Массивы

50 предопределённых зарезервированных идентификаторов.
Их нельзя использовать в качестве имён переменных,
методов и классов. В сочетании с синтаксисом операторов и
разделителями - основа языка Java.
abstract, assert, boolean, break, byte, case, catch, char, class,
const, continue, default, do, double, else, enum, extends, final,
finally, float, for, goto, if, implements, import, instanceof, int,
interface, long, native, new, package, private, protected, public,
return, short, static, strictfp, super, switch, synchronized, this,
throw, throws, transient, try, void, volatile, while.

●
Типы: byte, short, int, long, char, float, double, boolean
●
Циклы, ветвления: if, else, switch, case, default, while, do,
for, break, continue
●
Исключения: try, catch, finally, throw, throws
●
Области видимости: private, protected, public
●
Объявление / Импорт: import, package, class, interface,
extends, implements, static, final, void, abstract, native
●
Создание / Возврат / Вызов: new, return, this, super
●
Многопоточность: synchronized, volatile
●
Другие: instanceof, enum, assert, transient, strictfp
●
Не используемые: const, goto

●
Java 1.2: strictfp
●
Java 1.4: assert
●
Java 5: enum
Ключевые слова const и goto зарезервированы,
но не используются.
Идентификаторы true, false и null не являются
ключевыми словами. Это предопределённые
литералы.

Тип данных — характеристика переменной или константы.
Указывает, какого рода значение хранится в отведённой для
него области памяти.
Java - строго типизированный язык. В языке можно выделить
несколько типов данных.

С точки зрения программиста - null это не тип данных. Нельзя
объявить переменную типа null или привести значение к
этому типу. По спецификации это специальный тип
выражения null, не имеющий имени.
Примитивные типы данных:
●
Целые числа со знаком: byte, short, int, long
●
Числа с плавающей точкой: float и double
●
Символы: char
●
Булевы значения: boolean
Ссылочные типы данных: массивы, классы, интерфейсы и
перечисления.

Примитивные типы данных
Тип Размер
бит
Минимум Максимум Класс-
упаковка
boolean - - - Boolean
char 16 'u0000' или 0 'uFFFF' или 216
-1 Char
byte 8 -128 127 Byte
short 16 -215
215
-1 Short
int 32 -231
231
-1 Integer
long 64 -263
263
-1 Long
float 32 -1.4e-45 3.4e+38 Float
double 64 -4.9e-324 1.8е+308 Double

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

Целочисленные значения являются числами со знаком.
●
Тип byte занимает 1 байт. Используется при работе с
потоками данных и при работе с необработанными
бинарными данными.
●
Тип short занимает 2 байта. Он используется реже всего.
●
Тип int занимает 4 байта и применяется чаще всего. Может
принимать значения до 2 миллиардов, что очень много.
Своей популярностью обязан не только диапазону
значений. В выражениях переменные byte и short
повышаются до типа int.
●
Тип long занимает 8 байтов и может принимать очень
большие значения.

Числа с плавающей запятой (действительные числа)
необходимы там, где требуется точность до десятичного
знака, например при вычислении квадратного корня или
синуса угла. Вещественные числа состоят из целой и
дробной части, разделённых десятичной точкой.
●
Тип float (значение одинарной точности) занимает 32 бита.
Этого числа вполне хватает, чтобы хранить стоимость в
рублях и копейках. К тому же, на некоторых процессорах
операции с 32-битными значениями происходят быстрее.
●
Тип double занимает 64 бита и современные процессоры
напротив быстрее работают именно с ним. Его рационально
применять либо для хранения десятков чисел после
запятой, либо при множестве последовательных
вычислений, в результате которых точность вычисления
может упасть. Этот тип используется чаще.

Тип char хранит символы. Это 16-ти битное число без знака,
которого хватает для отображения всех символов кодировки
Unicode. Впрочем, первые 128 значений полностью
совпадают с ASCII, а первые 256 с набором символов
ISO-Latin-1, так что, программисты, привыкшие к
специальным трюкам по вычислению нужной буквы не
остались обделены.
Тип char формально является целочисленным и позволяет
манипулировать значениями в диапазоне от 0 до 65535.
Надо помнить, что 'A' не то же самое, что "A".

Булевский (логический) тип boolean может принимать только
два значения - true (истина) и false (ложь).
Эти логические значения возвращаются всеми операторами
сравнения, к тому же, они обязательны в условных
выражениях, управляющими такими операторами, как if и for.
В отличие от языка Си, булевский тип нельзя представлять в
виде чисел.

Для работы с числами имеются ещё два типа, но они не
являются примитивными.
Числа повышенной точности: BigInteger и BigDecimal не
имеют аналогов среди примитивных типов. Оба класса
содержат методы, выполняющие арифметические операции.
Как правило, эти типы занимают больше памяти, и операции
с ними медленнее.
●
BigInteger: целые числа произвольной точности.
●
BigDecimal: числа с фиксированной запятой произвольной
точности.

Преобразование может быть неявным и явным (приведение типов).
●
Неявное преобразование может выполняться если: типы совместимы
(например — оба целочисленные) и размер «принимающего» типа
больше чем у исходного («преобразование с расширением»)
●
Явное преобразование имеет вид:
переменная_нового_типа = (новый_тип) имя переменной;
Другое название - приведение типов (type casting). Например, можно
выполнить преобразование с сужением, передавая значение типа int в
переменную типа byte:
int a = 257;
byte b = (byte) a;
Число 257 больше допустимого, поэтому в переменной b сохранится
остаток от деления значения переменной на диапазон допустимых
значений типа byte (256), то есть 1.
Преобразование типов

При повышении типа byte>short; short>int; char>int;
int>long; float>double; byte,short,char>float;
int>double; float>double (strictfp) информация не
потеряется. При сужении возможна потеря информации.
При различных операциях может происходить повышение типов в
порядке «усиления» к более информативному типу. Например
складывая int и double получим тип double.
Если значение выражения присваивается переменной, то, чтобы
не было ошибки компиляции, целевой тип должен быть
совместим, равен либо больше типа, возвращаемого
выражением.
Автоматического преобразования для типа boolean нет.
Логический тип не преобразовывается в другие типы. Это не Си,
где 0 == false, !0 == true.

Кратко можно записать такие правила:
●
byte, short, char в выражениях всегда повышаются до int
●
если в выражении участвует тип long — то именно к этому типу
будет приведён результат
●
если в выражении float — то результат приводится к float
●
если один из операндов имеет тип double — то к этому типу
будет приведён весь результат
●
При выборе между длиной и возможностью сохранить дробную
часть — будет выбрана дробная часть.

Причина самого распространённого исключения в Java -
NullPointerException.
Специальный тип данных, единственное значение которого -
пустая ссылка, представленная литералом null. Это тип
выражения null, не имеющий имени. Поскольку у этого типа
нет имени, не удастся объявить переменную типа null, или
сделать приведение к типу null.
На практике программист может игнорировать тип null, и
воспринимать его в качестве специального литерала любого
ссылочного типа.
Тип null

Имеется одна интересная особенность. Даже если значение
ссылочной переменной null, по её имени можно обратиться к
статическим поля и методам её типа:
Math math = null;
System.out.println(math.cos(1));
Статические методы используют статическое (раннее)
связывание, и не выбрасывают NullPointerException.
Так же, если x != null, результат этого выражения:
x.equals(null) == false;

На практике надо стараться избегать использования null.
Например, в случае коллекций лучше возвращать
пустую коллекцию.
На уровне JVM для типа null имеются три инструкции:
aconst_null: присвоить переменной значение null;
ifnull и ifnonnull: сравнение с null.
Где хранится null? Сколько памяти он занимает?
Хранится там же, где и адреса других объектов - в
адресной области памяти. Занимает столько же, сколько
любая другая ссылочная переменная (32 или 64 бита).

Классы, заключающие элементарный тип в объект.
●
Используются, если нужно объектное представление
элементарных типов
●
Для передачи примитивного значения в метод по ссылке
●
Для хранения значений в коллекции
Оболочки типов это: Byte, Short, Integer, Long,
Character, Double, Float и Boolean. Эти классы
представляют широкий диапазон методов, позволяющих в
полной мере интегрировать элементарные типы в иерархию
объектных типов.
Классы-оболочки

Варианты создания класса-обёртки (упаковки примитивного
значения в объект):
Integer i = new Integer(10);
Integer i = 10;
Integer i = Integer.valueOf("10");
Для класса Boolean строка "true", неважно в каком регистре,
станет true, а все остальные строки будут false.

У числовых классов общий предок — класс Number, в
котором описаны методы, возвращающие числовое
значение, приведенное к соответствующему примитивному
типу:
●
byteValue()
●
doubleValue()
●
floatValue()
●
intValue()
●
longValue()
●
shortValue()
Эти методы переопределены в каждом из шести числовых
классов-оболочек.

Это автоматическое преобразование из примитивных типов
данных к ссылочным и наоборот.
●
Значительно упрощает реализацию некоторых алгоритмов
за счёт исключения "лишних" операций.
●
Существенно упрощается работа с коллекциями.
Integer test = 100; // автоупаковка
int i = test // автораспаковка
Автоупаковка и распаковка происходит при передаче и
возвращении значений методам, а так же в выражениях.
Автоматическая упаковка и
распаковка

Если использовать классы-оболочки без лишней
необходимости, может заметно падать эффективность
программы, так как постоянно получаются накладные
расходы на распаковку и упаковку. Оболочки типов следует
использовать только тогда, когда требуется объектное
представление элементарных типов.
Integer itr = null; // нормально
int j = itr; // NullPointerException
Значение null нельзя присвоить примитиву, но, если
присвоить null объекту класса-обертки, а затем присвоить
этот объект соответствующему примитивному типу,
компилятор не отреагирует, но мы будем вознаграждены null
pointer exception во время выполнения.

Оператор равенства сравнивает значения переменных. Если
переменные ссылочные - сравниваются опять-таки их
значения, то есть адреса объектов в памяти, а не сами
объекты.
В таком случае, как объяснить результаты следующего кода:
Integer i1 = 200, i2 = Integer.valueOf(200);
System.out.println(i1 == i2); // false
i1 = 10; i2 = Integer.valueOf(10);
System.out.println(i1 == i2); // true
System.out.println(new Integer(10)==new Integer(10)); // false
Кэширование значений
целых чисел

Надо помнить про:
●
Автоупаковку примитивных значений
●
Кэш целых чисел в диапазоне [-128; 127]
●
Integer i=100 трактуется как Integer i=Integer.valueOf(100);
Метод valueOf(), если это допустимо, использует адрес
объекта из кэша. Экономится память, выше скорость.
В первом выражении i1 и i2 указывают на два разных
объекта в куче, а во втором на один и тот же объект из пула.
В третьем выражении мы явно создаём два объекта типа
Integer, и естественно, у каждого будет свой адрес в памяти.

Верхнюю границу кэша, начиная с Java 6 можно менять во
время запуска JVM.
●
Обёртки Byte, Short, Long имеют аналогичный кэш
целых чисел, в диапазоне [-128;127].
●
У Byte и Short диапазон фиксированный.
●
У Character кэш меньше, [0;127].
●
Классы-обёртки вещественных типов такого кэша не имеют.
●
Класс Boolean без причины не плодит объектов, то есть,
все его значения, как и в случае класса Byte известны и
являются константами.

Литералы представляют собой постоянные значения,
включаемые непосредственно в текст программы. В отличие
от констант и переменных им нельзя присваивать значения.
Тип литерала определяется его содержимым, тем, как
записано постоянное значение.
Целочисленные
int
12
3267890
-144
Литералы
long
12L
3267890l
-144L
byte, short

Способы записи целых чисел:
●
Шестнадцатеричное представление: 0xFF, 0X32
●
Десятичное: 255
●
Восьмеричное: 0377
●
Двоичное: 0b11111111, 0B11001 (Java 7+)
Начиная с Java 7 для большей наглядности числа литерала
можно разделять произвольным количеством знаком
подчёркивания. Знаки подчёркивания не могут быть в начале
и конце числа.
Пример: 1234_5678__1736

Важно. Если число больше допустимого — автоматического
повышения типа не происходит. Литерал 0xFFFFFFFF_F
вызовет ошибку: «integer number too large». Ему надо
явно указать тип long.
Если неоднозначности с типом литерала нет, то компилятор
допускает операции присваивания без суффикса типа:
long l = 100000;
Литералы типа int можно присваивать переменным других
числовых типов, при условии, что значение этого литерала
не выходит за пределы диапазона значений
соответствующего типа. Если это не так — компилятор
выдаст ошибку: «incompatible types: possible lossy
conversion from int to byte».

Вещественные:
●
По-умолчанию — double — 123.45
●
Суффиксы D, d — double — 123.45D
●
Суффиксы F, f — float — 123.45F
Состоят из целой части, десятичной или hex точки, дробной
части, показателя степени и суффикса типа. Могут быть
выражены в десятичном или шестнадцатеричном виде.
В классах-обёртках имеются специальные значения:
Научная нотация:
●
1.39e-43f
●
47e47
POSITIVE_INFINITY = 1.0f / 0.0f;
NEGATIVE_INFINITY = -1.0f / 0.0f;
NaN = 0.0f / 0.0f;

Другие литералы:
●
Логические (boolean): true, false
●
Символьные (char) записываются в одинарных кавычках
●
Строковые (String) записываются в двойных кавычках
●
null: null
Специальный литерал null может использоваться в
качестве значения любого ссылочного типа.
Строковые и символьные типы могут содержать символы,
которые не удаётся ввести с клавиатуры. Например, знаки
табуляции или удаления символа. Для их записи
используется обратный слэш, а следом за ним код символа.

Специальные символы (Escape-последовательности) или
управляющие последовательности.
Символ Описание Код
b Забой (backspace) u0008
t Табуляция (horizontal tab) u0009
n Перевод строки (new line) u000a
f Прогон страницы (form feed) u000c
r Возврат каретки (carriage return) u000d
" Двойная кавычка (double quote) u0022
' Апостроф (single quote) u0027
Обратный слэш (backslash) u005c
uXXXX Произвольный символ Unicode uXXXX

●
Java 8: Unicode 6.2.0.
●
Корректные коды от U+0000 до U+10FFFF.
●
Символы, превышающие U+FFFF - дополнительные.
Пишутся в виде пары 16-ти битовых кодовых слов, первое
из диапазона U+D800 до U+DBFF, второе из диапазона
U+DC00 до U+DFFF.
●
Символы до U+FFFF соответствуют UTF-16.
●
В классе Character символы: 32-битные целые числа.
Символьный и строковый литералы не могут хранить
значение ограничителя строки. Значения 'u000a' или 'u000d'
приводят к ошибке времени компиляции: "illegal line end in
character literal". Вместо них следует использовать
управляющие последовательности 'n' или 'r'.

Строковый литерал: нуль и более символов, заключённых в
двойные кавычки. Длинный литерал можно разбить на
фрагменты и записать как выражение конкатенации строк:
"Hello, World!" == "Hello," + " World!"
Строковый литерал всегда ссылается на один и тот же
экземпляр класса String. Это связано с тем, что строка
литералов интернируются (метод String.intern). Строки,
вычисленные путём конкатенации во время выполнения
являются вновь создаваемыми и отличаются от других.
new String("Hello, World!") != "Hello, World!"
new String("Hello, World!").intern() == "Hello, World!"

●
Именованная область памяти
●
Чтобы получить значение - надо обратиться по имени
●
Основной элемент хранения информации в программе
●
Характеристики: идентификатор, тип, область действия
●
Переменная класса == поле
В зависимости от того, где объявлена переменная:
●
Локальная - внутри метода, блока
●
Глобальная - доступна всем методам данного класса
Локальные области действия объявляются с помощью
фигурных скобок.
Переменные

Обязательное объявление до первого использования:
тип идентификатор [ = значение] [, идентификатор [ = значение ] … ];
●
Тип — один из встроенных типов, или имя ссылочного типа:
класса, интерфейса. Переменные (не локальные), для
которых начальные значения не указаны,
инициализируются автоматически.
●
Идентификатор – имя переменной. Буквы, цифры, "_", "$"
●
Значение - любой литерал или выражение, результатом
которого является значение того же (или совместимого с
указанным в объявлении переменной) типа.
int x = 100
double d;

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

Идентификатор это уникальный признак объекта,
позволяющий отличать его от других объектов. В языке Java
это имена переменных, классов, интерфейсов, методов, и
так далее.
Это последовательность неограниченной длины, состоящая
из букв, цифр, символов подчёркивания и доллара.
Идентификатор не должен начинаться с цифры и не может
совпадать с одним из ключевых слов или предопределённых
литералов. Язык Java чувствителен к регистру, так что
"variable" и "Variable" это разные идентификаторы.
Буквы и цифры для идентификаторов — любые из UTF-16.
Даже русские.
Идентификатор

"_" и "$" попали в Java по историческим причинам. Доллар
следует использовать только в автоматически
сгенерированном исходном тексте, или, реже, для доступа к
ранее существовавшим именам в устаревших системах.
Другими словами, использовать в идентификаторах крайне
не рекомендуется.
В соответствии с соглашением имя переменной должно
начинаться именно с маленькой буквы (с заглавной буквы
начинаются имена классов).
int timeToStart = 1000;
class MyVeryUsefulClass { … }

Инициализация переменной это присвоение ей начального
значения, до первого использования. Инициализировать
переменную можно при её объявлении, указав значение
после знака равенства. Динамическая инициализация -
переменной присваивается результат выражения.
byte b; // объявление
b = 17; // инициализация
int i = 1000 * 256 — b; // объявление + инициализация
MyFirstClass myFirstClass; // объявление
MyClass myClass = new MyClass() // объявление + инициализация
При инициализации под объект выделяется память. Без
инициализации запись MyClass myClass; просто резервирует
имя (объявляется переменная myClass типа MyClass).
Инициализация

Поля класса инициализируются автоматически. В
зависимости от типа это: 0, 0.0, 'u0000', false, null.
Локальные при объявлении не инициализируются. При
попытке использовать такую переменную компилятор
сообщит: variable XXX might not have been initialized.
Статические переменные создаются и инициализируются
только при необходимости. Если экземпляр класса со
статическими переменными не создан, и к этим переменным
не было обращений, то они не будут созданы.
Инициализация объектов происходит в специальном методе,
называемом "конструктор". Если он создан - при создании
объекта будет вызван конструктор по умолчанию.

Область видимости (действия) (scope) это область программы, в
пределах которой идентификатор некоей сущности продолжает
быть связанным с этой сущностью и возвращать её значение. За
пределами области видимости этот же идентификатор может быть
связан с другой сущностью, либо вообще не использоваться.
Области видимости создаются с помощью блоков: { }. Блок кода
— логическая единица текста программы. Последовательность
операторов, заключенных в фигурные скобки. Может быть пустым
или содержать вложенные блоки.
Используются там, где:
●
Нужно вместо одного оператора выполнить несколько
●
Повысить читабельность кода
●
Ограничить область видимости переменных
Область видимости
переменной

●
Глобальная область видимости - внутри класса
●
Локальная область видимости - внутри метода или блока
Переменные в глобальной области видимости доступны везде,
если, конечно, у них соответствующие модификаторы доступа.
Локальные видны только в пределах свой области видимости.
Переменная, определённая внутри области видимости начинает
действовать с момента своего своего объявления до конца
содержащего её блока, включая и все вложенные в неё области.
Если ссылочная переменная выходит за область действия — она
исчезает. Однако, объект, на который она указывает, будет
продолжать занимать память. Если он больше не нужен, то со
временем будет удалён сборщиком мусора.

К каждой сущности можно обратиться по её простому, или по
квалифицированному имени.
Квалифицированное имя: полное имя сущности, однозначно
определяющее её место в иерархии классов. Для
переменных это: package.class.name
md.leonis.first.package.FirstClass.classField
Пакеты формируют уникальные пространства имён для
своего содержимого.
Конфликт имён: в одной области видимости сущности с
одинаковыми идентификаторами. В таком случае к ним надо
обращаться по полному квалифицированному имени.
Конфликт имён

Ключевое слово import решает проблему неоднозначности
имён классов. Оно просит компилятор загрузить
определённый пакет, и использовать его классы.
В стандартной библиотеке Java определены тысячи классов,
так что, почти в каждой программе будет один или несколько
импортов.
import java.util.ArrayList
Теперь к классу ArrayList можно обращаться по его простому
имени. Можно импортировать целый набор классов:
import java.util.*
Импорт классов

На нижнем уровне операции с данными в Java
осуществляются посредством операторов. Большинство из
них заимствовано из C++, но есть улучшения и упрощения.
Инструкция или оператор или команда (statement) —
наименьшая исполняемая единица программного кода;
команда или набор команд. Программа обычно представляет
собой последовательность инструкций.
Примеры: объявление переменной, определение типа,
присваивание =, последовательность инструкций ;, блок
инструкций {}, условная инструкция if, переключатель
switch, циклы, вызовы методов, break, continue,
утверждение assert, выход из метода return.
Операторы и операции

Операция (operator) — конструкция в языках
программирования, аналогичная по записи математическим
операциям. Специальный способ записи некоторых
действий.
Операция - действие, которое производится над операндами.
Примеры: >>>, !=, -, *, ...
Поскольку в русскоязычной литературе постоянно путают
операторы и операции, далее по тексту следует
ориентироваться по смыслу. Везде будут операторы.

44 встроенных оператора:
●
Присваивания (assignment)
●
Арифметические (arithmetic), включая конкатенацию строк
и унарные (unary)
●
Сравнения (equality & relational), включая сравнение типа
(type comparision)
●
Условные (conditional)
●
Логические (logical)
●
Побитовая арифметика и сдвиг (bitwise and bit shift)
●
Приведения типа

Оператор получает один или несколько аргументов и
создаёт на их основе новое значение.
По-сути, это функция, но записываемая особым образом. По
этой причине логично иметь возможность определять
операции для произвольных типов таким же образом, как и
методы — чтобы можно было работать с ними точно так же,
как и с элементарными типами.
Эта возможность называется «перегрузка операций» и
присутствует в большинстве языков 4—5 поколений. В таких
языках транслятор фактически подставляет вместо
выполнения операции вызов соответствующей ей функции.
Java, в отличие от C++ не допускает перегрузку операторов.

Поскольку операции аналогичны по записи алгебраическим
выражениям, для них, как и для последних, существует 3
варианта синтаксиса:
●
префиксная (польская) (+ab) нотация;
●
инфиксная (a+b) нотация;
●
постфиксная (обратная польская) (ab+) нотация.
Слово постфиксный означает, что операция применится к
операнду после вычисления всего выражения, в которое
операнд входит. Аналогично префиксный означает, что
операция применится до вычисления выражения.

Операторы присваивания, инкремента и декремента
обладают побочными эффектами, меняя значение своего
операнда.
+ - * / = почти во всех языках работают одинаково.
Почти все операторы в Java, кроме =, == и != работают
только с примитивами. Для класса String имеются
перегруженные операции + и +=.
Возможные ошибки:
●
При распаковке целочисленной ссылки null получаем
NullPointerException.
●
Деление целого числа на нуль: ArithmeticException
●
Инкремент, декремент: OutOfMemoryError, если нужна
упаковка, но недостаточно памяти.

По количеству принимаемых аргументов операции можно
разделить на:
●
унарные
●
бинарные
●
тернарные
Унарные операции выполняются над одним операндом, и т.д.
Операнд - переменная или какое-либо значение.
Унарные: постфиксные и префиксные инкремент и
декремент, а так же префиксные: унарные +, -, логическое
или побитовое НЕ, приведение типа.
Бинарные: все остальные, кроме тернарного оператора.
Арность операций

Присваивание выполняется оператором =. Значение из
правой части копируется в переменную в левой части.
Значением может быть любая константа, переменное или
выражение. Слева может быть только переменная.
int x = 144;
int y = 12 - x;
Оператор присваивания позволяет выполнять цепочечные
присваивания. Благодаря этому можно одной командой
присвоить одно и то же значение сразу нескольким
переменным:
x = y = 12;
Присваивание

После присваивания объектов обе переменные ссылаются
на один объект. Происходит копирование ссылки а не самого
объекта.
Object obj1 = obj2;
Для упрощения записи выражений, операторы присваивания
могут комбинироваться с бинарными арифметическими и
побитовыми операторами. Так называемая, укороченная
форма записи операции и присваивания.
+=, >>>=
Стек
obj1
obj2
Куча
Экземпляр
объекта

Приводят значение к требуемому типу. В некоторых случаях Java
самостоятельно преобразует данные к другим типам. Приведение
используется для того, чтобы сделать такие преобразования
явными, либо для выполнения сужающего приведения.
int i = (int) 100; // явное приведение к типу int. Избыточно
long l = i; // тип int автоматически расширится до long
i = (int) l; // сужающее приведение
При сужающем приведении есть риск потери данных, поэтому
компилятор автоматическое сужение типа не выполняет. При
сужающих преобразованиях из вещественных типов в
целочисленные отбрасывается дробная часть. К тому же, если
целевой тип не int и не long, то число округляется до одного из
этих типов, а потом приводится к целевому, например byte.
Операторы приведения

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

●
Если и делимое и делитель целочисленные, то происходит
деление с остатком, возвращается целая часть частного.
●
++, --, % применимы к целым и вещественным типам.
●
Операторы + и += могут использоваться для конкатенации
строк. Если в выражении встречается строка, то и все
остальные не-строковые операнды перед суммированием
приводятся к своему строковому представлению.
Арифметические операторы

Унарные "+" и "-" внешне не отличаются от бинарных аналогов.
Компилятор выбирает нужный, в соответствии с контекстом
использования.
Унарный минус меняет знак своего единственного операнда, в то
время, как унарный плюс просто возвращает его значение.
Инкремент и декремент увеличивают или уменьшают значение
переменной на единицу. Могут быть записаны в префиксной и
постфиксной формах.
Префиксный вид — сначала выполняется операция, а потом
возвращается результат. Постфиксный вид — сначала выдаётся
значение переменной, и только потом выполняется операция
инкремента/декремента.
Унарные
арифметические операторы

Определяют отношение одного
операнда с другим и возвращают
логический результат true/false.
Часто используются в управляющих
выражениях условных операторов
и циклов.
На равенство и неравенство проверять любые типы данных.
Сравнение с помощью операторов упорядочения применимо
только к типам, значения которых могут быть упорядочены, то
есть, с любыми числовыми типами, включая целочисленные, char,
и вещественные типы, но не boolean.
При сравнении ссылочных типов сравниваются ссылки. Внешне
два объекта могут быть одинаковыми, но расположены в разных
областях памяти. Ссылки будут различаться. equals().
Операторы сравнения

Логические операторы работают только с операндами типа
boolean. Они используют два логических значения для
получения одного результирующего.
boolean b = true, b2 = false;
boolean b3 = b & b2;
Таблица истинности
Логические операторы

Сокращённые логические операторы применяются для
вычисления значения истинности условия команд if, while, do.
Если по значению первого операнда можно понять результат
выражения, то второй операнд не вычисляется.
Как правило "условный И" и "условный ИЛИ" применяются там,
где необходимы операторы булевой логики, а их односимвольные
версии используются для побитовых операций. Впрочем, в сильно
замороченных выражениях они тоже находят место быть:
if (x == 10 & y++ < 100) z = 256;
В этом выражении одиночный символ & гарантирует выполнение
инкремента в любом случае.
Условные операторы

Это троичный условный оператор, с помощью которого
можно организовать ветвление программы. Может заменить
некоторые определённые типы операторов if-else.
В отличие от if-else он производит значение.
ЛогическоеУсловие ? выражение1 : выражение2
ЛогическоеУсловие - если true - выполняется первое
выражение, иначе выполняется второе. Оба этих выражения
должны возвращать значение одинакового, либо
совместимого типа, но не void.
result = x == 0 ? 0 : x / 5;
Тернарный оператор

Побитовые операции манипулируют отдельными битами
целых чисел. Результат их работы - булева алгебра с
соответствующими битами двух операндов.
Java разрабатывался как язык управления бытовой техникой,
работа с битами в начале 90-х была нужна.
Используются
редко.
Побитовые операции

Все операторы, кроме операций сдвига обозначаются как
логические операторы и работают по тому же принципу, но
обрабатывают свои операнды бит за битом.
Все, кроме ~ можно комбинировать со знаком равенства.
Например:
&= - побитовый И с присваиванием.
Поразрядные операции (кроме ~) применимы и к типу
boolean. В этом случае он рассматривается как 1 бит
информации. В отличие от логических операций, можно
дополнительно выполнять операцию XOR.

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

Выполняют побитовый сдвиг первого операнда на количество
разрядов, заданных вторым операндом. Работают только с
примитивными целочисленными типами. Позволяют быстро
делить и умножать на степень двойки. Порядок операндов имеет
значение.
●
При сдвиге влево << освободившиеся справа биты заполняются
нулями.
●
Беззнаковый сдвиг вправо >>> делает то же самое, но в другую
сторону. В Си такой операции нет.
●
Знаковый сдвиг вправо >> сдвигает биты, но при этом, знаковый
бит (крайний слева) остаётся на месте, а все освободившиеся
биты заполняются его значением.
При операциях сдвига необратимо теряются биты информации.
Операции сдвига

Операнды типа char, byte и short перед выполнением
сдвига приводятся к типу int.
При работе с типом int, из второго операнда используются
значения только пяти крайних правых битов. В случае типа
long значимыми являются крайние шесть битов второго
операнда (значения от 0 до 61 включительно).
Операторы сдвига так же можно комбинировать с операцией
присваивания, но есть подводный камень для операции >>>=
и отрицательных чисел. Если она используется с типами byte
или short, то они сперва преобразуются к типу int, потом
происходит сдвиг, затем обрезание до исходного типа.
Результирующее значение не совпадёт с ожидаемым.

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

1. ( ) [ ] .
2. постфиксные ++ --
3. префиксные ++ --, унарные + - ~ !
4. new (тип)
5. * / %
6. + -
7. >> >>> <<
8. > >= < <= instanceof
9. == !=
10. &
11. ^
12. |
13. &&
14. ||
15. ?:
16. = op=
17. ,

Используются для реализации переходов и ветвлений в
потоке выполнения команд в программе.
Это операторы выбора, цикла и перехода:
●
if-else
●
switch
●
while
●
do-while
●
for, "foreach"
Для того, чтобы определить способ выполнения, все
конструкции с условием вычисляют истинность или ложность
условного выражения.
Управляющие операторы

Два оператора выбора: if и switch. Они управляют порядком
выполнения команд программы в соответствии с условиями,
которые известны только во время выполнения.
Оператор if можно использовать для направления выполнения
программы по двум различным ветвям. Общая форма:
if (условие) оператор1 [else оператор2]
Каждый оператор это одиночный оператор, завершённый точкой с
запятой, блок операторов. Условие - любое булево выражение.
Принцип работы: если условие истинно, программа выполняет
оператор1. В противном случае она выполняет оператор2, если
он существует. Какое бы ни было условие, оба оператор не
выполнятся никогда.
Операторы выбора

Для удобства чтения и предупреждения возможных ошибок в,
даже одиночные операторы заключаются в фигурные скобки.
Пример ошибки, которую, из-за отступов не сразу можно понять:
int x=1, y=10;
if (x!=1)
x*=2;
y*=3;
else // error: 'else' without 'if'
x=0;
y+=x;
Если забыть указать фигурные скобки после if - компилятор на это
укажет. Но в этом примере так же нет фигурных скобок после else,
хотя, судя по отступам, выражение y+=x должно выполняться
внутри выражения else.

Вложенный оператор if это оператор if, являющийся целью другого
оператор if или else.
При использовании вложенных операторов if надо помнить, что
else всегда связан с ближайшим оператором if, расположенным с
ним в одном блоке и ещё не связанным с другим оператором if.
if (x<10) {
if (y>50) x=y;
if (z==100) y=0; // этот if
else x=y/2; // связан с этим else
}
else z=x; // if (x<10)

На практике так же используется конструкция if-else-if.
if (условие)
оператор1;
else if (условие)
оператор2;
...
else операторX;
Эти операторы выполняются в последовательности сверху-вниз.
Как только одно из условий возвращает значение true -
выполняется оператор, связанный с этим оператором if, после
чего остальная часть конструкции пропускается.
Если ни одно из условий не выполняется, будет выполнен
последний оператор else, либо, если его нет - ничего выполнено
не будет.

Оператор switch является оператором ветвления. Ещё его называют
оператором выбора. Позволяет выбирать из нескольких альтернатив, в
зависимости от значения управляющего выражения. Зачастую switch
эффективнее конструкции if-else-if.
switch (выражение) {
[case значение1:
// последовательность операторов
[break;]]
[case значение2:
// последовательность операторов
[break;]]
…
[default:
// операторы, выполняемые по умолчанию]
}
Оператор switch

Выражение должно иметь тип byte, short, int, char или тип
перечисления, а, начиная с Java 7 выражение так же может иметь
тип String. Каждое значение в операторе case должно быть
уникальным константным значением. Дублирование не
допускается. Тип значения должен быть совместимым с типом
выражения.
Оператор switch сравнивает выражение на равенство с
предложенными значениеми.
Принцип работы. Значение выражения сравнивается с каждым
значением оператора case. При совпадении программа
выполняет последовательность кода, следующую за этим
оператором case. Если значения не совпали - выполняется
команда, следующая за оператором default. Если значения не
совпали и оператора default нет - просто ничего не
выполняется.

Оператор break организует выход из оператора switch.
В операторе default есть смысл ставить break только тогда, когда
ниже него по тексту есть ещё операторы case. Впрочем, принято
default помещать в конец блока switch.
Встречаются вложенные операторы switch. Так как каждый из них
определяет собственный блок - путаницы не происходит.
●
switch в отличие от if выполняет только проверку равенства.
●
Константы case в одном операторе switch не могут иметь
одинаковые значения.
●
Как правило, switch эффективнее вложенных операторов if.
●
Так как значение констант заранее известно, компилятор на их
основе строит таблицу переходов. При выборе в большом
количестве значений, switch работает быстрее if-else.

Операторами цикла многократно выполняют один и тот же
набор инструкций, пока не будет удовлетворено условие
завершения цикла.
Разновидности:
●
while
●
do-while
●
for
●
"foreach"
Циклы можно имитировать оператором if.
Операторы цикла

Цикл с предусловием while используется чаще других. Он
повторяет оператор, или блок операторов до тех пор, пока
значение его управляющего выражения истинно.
while (условие) оператор;
while (условие) {
//тело цикла
}
Так как значение условия вычисляется в начале каждого цикла,
тело цикла может быть не выполнено ни разу, если условие
ложно. Тело цикла while может быть пустым.
int x=5, y=25;
while (++x < --y);
Цикл while

Цикл do-while (цикл с постусловием) аналогичен циклу while, но
условие проверяется в конце цикла. Это гарантирует, что тело
цикла выполнится хотя бы один раз.
do {
// тело цикла
} while (условие)
Цикл do-while

Цикл for, начиная с JDK 5 представлен двумя формами. Первая -
традиционная, и вторая "for-each".
for (инициализация; условие; шаг) {
// тело цикла
}
Если в теле цикла только один оператор - фигурные скобки можно
не писать.
Цикл for

●
Инициализация выполняется только один раз при первом
запуске цикла. В общем случае это выражение,
устанавливающее значение управляющей переменной цикла,
которая действует в качестве счётчика, управляющего циклом.
●
Затем выполняется проверка условия, которое должно быть
булевым выражением. Как правило, сравнивается значение
управляющей переменной и целевым значением. Если значение
истинно - программа выполняет тело цикла, в другом случае
выполнение цикла заканчивается.
●
В конце каждой итерации осуществляется «приращение»,
обычно это изменение управляющей переменной. Дальше цикл
повторяется.
Цикл for

Инициализация переменных в теле цикла (не в секции
инициализации, а между фигурными скобками) выполняется при
каждой итерации:
for (int i = 0; i < 5; i++) {
int x = 10;
x -= i;
System.out.print(x + ", ");
}
Вывод: 10, 9, 8, 7, 6,
Любое из трёх выражений цикла (инициализация, условие и шаг)
можно пропустить. Бесконечный цикл: for(;;)
Цикл for

Оператор-запятая может использоваться только в управляющем
выражении цикла for. Не следует путать с запятой-разделителем,
которая разграничивает определения и аргументы функций.
Как в секции инициализации цикла, так и в его управляющем
выражении можно записать несколько команд, разделённых
запятыми. Они будут обработаны последовательно слева
направо.
Оператор-запятая позволяет определить в цикле for сразу
несколько переменных, правда, они должны принадлежать одному
типу. Кстати, объявлять переменные в управляющих выражениях
можно только в цикле for.
for (int i=1, j=i+10; i<5; i++, j=i*2) { ... }
Оператор-запятая

Более компактная форма оператора for для перебора массивов и
коллекций.
for (тип итерПеременная : коллекция) блок операторов
Тип итерационной переменной должен совпадать (или быть
совместимым) с типом элементов в коллекции. На каждой
итерации цикла программа извлекает следующий элемент
коллекции и сохраняет его в итерационной переменной. Цикл
будет выполняться до тех пор, пока не будут получены все
элементы коллекции. Итерационная переменная является
переменной "только для чтения". Этот цикл отлично подходит для
поиска, вычисления суммы, среднего значения, итд.
Этот оператор так же работает для любого объекта,
поддерживающего интерфейс Iterable.
Цикл "foreach"

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

Оператор break немедленно завершает цикл. Следующие за ним
операторы цикла не выполняются. При вложенных циклах break
прерывает выполнение цикла, в котором находится. Есть
возможность выходить сразу из нескольких блоков кода. Важно,
чтобы эти блоки были вложенными.
break метка;
Метка ставится в начале нужного блока (в том числе, и перед
операторами цикла). Это идентификатор с последующим
двоеточием.
Переход к метке, указанной в неположенном месте приведёт к
«label undefined». Операторы break/continue в обычном блоке
приведут к «unreachable statement», если после этих операторов в
блоке есть код.
Оператор break

Оператор continue останавливает выполнение текущей итерации
цикла и переходит к началу цикла, чтобы начать выполнение
нового шага. Как и break, continue позволяет использовать метку.
continue метка;
Осуществляет выход из внутреннего цикла. При этом, начинается
следующая итерация цикла после метки.
Оператор continue

Массив - набор однотипных данных, к которым можно обращаться
по общему имени. Массивы определяются и используются с
помощью оператора индексирования []. Доступ к отдельным
элементам массива осуществляется по индексу. В отличие от
списков, к элементам массива можно обращаться в произвольном
порядке.
Массивы отличаются от коллекций своей эффективностью,
типизацией и возможностью хранения примитивных типов. Это
самое эффективное средство хранения ссылок на объекты.
Массивы

●
Массивы с одним индексом - одномерные.
●
Многомерные массивы - массивы массивов.
●
Обычные и динамические. Динамические массивы позволяют
менять свой размер при выполнении программы. В отличие от C
и Delphi, в Java нет динамических массивов, хотя, структура
данных с таким поведением реализована с помощью коллекций,
например, ArrayList.
●
Неоднородные (нерегулярные) массивы могут иметь различные
размеры второго и последующих измерений. Идеальное
решение, если требуется очень большой двухмерный
разреженный массив.
●
Гетерогенные массивы. В них элементы могут быть различных
типов данных. В Java не представлены. Массивы ссылок на
объекты не являются гетерогенными.
Разновидности массивов

Физически массив, как и любой другой объект располагается в
динамической памяти. Элементы массива располагаются в
памяти один за другим, что позволяет быстро к ним обращаться.
Правда, размер массива всегда строго фиксирован и на
протяжении его жизненного цикла не может меняться.
Индексация начинается с нуля.
Массив является объектом, то есть, у него имеются все методы
класса Object, но программно он определён в JVM и посмотреть
исходный код не получится.

Java допускает создание массивов любого типа. Массивы могут
иметь одно или несколько измерений (размерностей).
Одномерный - вектор, двумерный - матрица, и т.д. В Java
допустимы только массивы массивов. Размерность массива — это
количество индексов, необходимое для однозначной адресации
элемента в рамках массива. Форма или структура массива —
количество размерностей плюс размер (протяжённость) массива
для каждой размерности; может быть представлена одномерным
массивом.
Двухмерный массив в Java с технической точки зрения является
одномерным массивом, элементами которого являются также
одномерные массивы.
тип[][] имя=new тип[размер_1][размер_2];

Векторы, образующие матрицу могут иметь разную длину.
Ступенчатый массив.
Размер (длина) массива — количество всех его элементов.
В памяти массивы занимают больше места чем можно было бы
предположить. Размеры всех элементов массива выравниваются
по 8 байт. Размер можно узнать (но не изменить) из специального
поля массива - length.

Объявление переменной массива: int[] al;
Объявление в стиле Си, с тем же эффектом: int al[];
При объявлении переменной массива, размер массива задать не
получится. Это обычная ссылочная переменная. Чтобы
зарезервировать для него память, необходимо выражение
инициализации.
Массив можно инициализировать при его создании: динамическая
агрегатная инициализация. Набор данных перечисляется в
фигурных скобках, и компилятор сам заботится о выделении
памяти (эквивалент new):
int[] al = { 1, 2, 3, 4, 5 };
Даже при такой инициализации, память под массив выделяется
динамически, во время выполнения программы.

Имеется ограничение на инициализацию массивов. По-сути,
набор данных заменяется байт-кодом, который при выполнении
программы заносит в массив значения, одно за другим. Если
захардкодить данных более чем на 64 Кб — получим при
компиляции ошибку "Error: code too large". Дело в том, что методы
в Java не могут быть больше 64 Кб.
Динамическое (явное) выделение места под массив:
int[] a;
a = new int[20];
Если элементам массива не заданы явные значения, они
получаются значения по умолчанию, характерные для своего типа.
По спецификации, массивы в Java индексируются типом int (со
знаком), размер не может превышать ~2 миллиарда.

Принятые способы прохода массива:
int[] mas = new int[10];
// for
for (int i = 0; i < mas.length; i++) {
mas[i]++;
}
// foreach
for (int element: mas) {
element++; // не влияет на значения в самом массиве
System.out.println(element);
}

При выводе на печать символьного массива его содержимое
отображается в виде обычной строки.
О выходе за границу массива сигнализирует ошибка времени
выполнения ArrayIndexOutOfBoundsException. Правда,
проектировать код, который его перехватывает, например, для
завершения цикла обработки - плохая практика. Код не должен
выходить за пределы массива.
Массивы не могут инициализироваться параметризованными
типами:
Peel<Banana> peels = new Peel<Banana>[10]; // ошибка
Стирание удаляет информацию о параметре типа, а массив
должен знать точный тип хранящихся в нём объектов, чтобы
обеспечивать безопасность типов. Но никто не помешает создать
ссылку на параметризованный массив, вроде List<String>[] и потом
задать ей (List<String>[]) (new List[10])

Достоинства применения массивов:
●
лёгкость вычисления адреса элемента по его индексу
(поскольку элементы массива располагаются один за другим)
●
одинаковое время доступа ко всем элементам
●
малый размер элементов: они состоят только из
информационного поля.
Недостатки:
●
отсутствие динамики, невозможность удаления или
добавления элемента без сдвига других
●
в Java нет настоящих многомерных массивов, как, например,
в C# или Delphi
●
нет встроенных высокоуровневых инструментов работы с
элементами, например, проверки, сравнения, и т. д., в
отличие от ArrayList. Это ограничение решается за счёт
служебного класса Arrays.

У класса Arrays есть несколько удобных методов для работы с
массивами:
●
Arrays.fill() - заполняет каждый элемент массива
заданным значением
●
equals() - сравнивает два массива
●
deepEquals() - сравнивает многомерные массивы
●
sort() - сортировка массива
●
binarySearch() - поиск в отсортированном массиве
●
toString() и hashCode() работают как и аналогичные
методы класса Object
●
toList() - преобразование массива в список

Сравнение массивов. Массивы будут равными, если они содержат
одинаковое количество элементов, и каждый элемент
эквивалентен соответствующему элементу другого массива
(проверка вызовом equals() для каждой пары). В случае
примитивов используется метод equals() объектной обётки.
Сортировка применима, если элементы массива реализуют
интерфейс Comparable, либо, с помощью отдельного класса,
реализующего интерфейс Comparator.
System.arraycopy() использует нативный код для скорейшего
копирования массивов. Не выполняет автоматической
упаковки/распаковки - типы должны строго совпадать. Правда, в
случае объектных массивов копируются только ссылки из первого
измерения, но не сами объекты. Так называемое, поверхностное
копирование.

Способны содержать заранее неизвестное количество аргументов
неизвестного типа.
До выхода Java SE5 реализовывались через массив типа Object.
Сейчас для этого используется многоточие.
void printArray(Object... args)
Метод, который принимает переменное число аргументов,
называют методом переменной арности, или просто методом
varargs.
Обрабатываются как обычный массив.
Параметр переменной длины должен быть последним
параметром, объявленным методом.
Списки аргументов
переменной длины (varargs)

●
Википедия
●
Эккель - Философия Java
●
Язык программирования Java SE 8. Подробное описание
●
Сеттер - Изучаем Java на примерах и задачах
●
Васильев - самоучитель Java с примерами
●
Десятки замечательных сайтов с учебниками, или просто
интересными статьями по Java
Мои рецензии на прочитанные книги: http://bibla.ru/Leonis/
Благодарю за внимание!! :)
Список литературы

Java - основы языка

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Java - основы языка (20)

Java - основы языка