801.89K

Категория:

Программирование

Синтаксис Java. Лекция 2

1.

Лекция 2.
Синтаксис Java
Лекции по Java SE
Максим Букасов, киевский учебный центр NetCracker
© 2013 NetCracker Technology Corporation Confidential

План лекции
• Основы синтаксиса
‒ Кодировка и пробельные символы
‒ Комментарии и JavaDoc-комментарии
‒ Зарезервированные слова
‒ Идентификаторы и соглашения о записи имен
‒ Типы данных и литералы
‒ Объявление переменных
• Операторы
‒ Приоритет операторов
‒ Арифметические операторы
‒ Логические операторы
‒ Приведение типов
• Управление потоком выполнения
‒ Ветвления
‒ Циклы
• Массивы
© 2013 NetCracker Technology Corporation Confidential
2

3.

Основы синтаксиса – Кодировка
• Unicode
• UTF-8
‒ 1 символ = 1..6 байт
• UTF-16
‒ 1 «обычный» символ = 2 байта
‒ редкие символы представляются суррогатными парами
• UTF-32
‒ 1 символ = 4 байта
• Java
• UTF-16 в памяти ВМ
• UTF-8 на диске (.java и .class- файлы)
Обработка Unicode-строк – вещь сложная. Не делайте этого «в ручную».
Используйте стандартные библиотеки!
© 2013 NetCracker Technology Corporation Confidential
3

4.

Основы синтаксиса – Пробельные символы
• Пробел
• Табуляция
• Перевод строки
Пример программы с хорошо расставленными пробелами:
public class HelloWorld {
public static void main (String[] args) {
System.out.println ("Hello World!");
}
}
Пример программы с плохо расставленными пробелами:
public class HelloWorld {public static void main (String[]
args){System.out.println("Hello World!");}}
© 2013 NetCracker Technology Corporation Confidential
4

5.

Основы синтаксиса – Комментарии
• Одна строка // .....
• Несколько строк /* ..... */
• Javadoc /** ...... */
public class HelloWorld {
/**
* Some information about this method.
* You can use <b>HTML</b> and some special tags:
* @param args the command line arguments
*/
public static void main(String[] args) {
// One-line comment
System.out.println("Hello, World!"); // Another one-line comment
/* Multi-line comment
System.out.println("Здравствуй, Мир!");
System.out.println("АААААААААААААААААААА!");
*/
}
}
© 2013 NetCracker Technology Corporation Confidential
5

6.

Основы синтаксиса – Зарезервированные слова
• Ключевые слова
abstract
char
double
for
int
private
strictfp
throws
assert (1.4)
boolean
class
else
goto
interface
protected
super
transient
enum (1.5)
break
const
extends
if
long
public
switch
try
byte
continue
final
implements
native
return
synchronized
void
case
default
finally
import
new
short
this
volatile
catch
do
float
instanceof
package
static
throw
while
• Литералы
true
false
© 2013 NetCracker Technology Corporation Confidential
null
6

7.

Основы синтаксиса – Идентификаторы
• Идентификатор
‒ может состоять из букв, цифр, символов $ и _ (знак подчеркивания)
‒ не может начинаться с цифры
‒ должен отличаться от зарезервированных слов
‒ может иметь произвольную длину
‒ может содержать произвольные символы Unicode
• Допускается, но не рекомендуется
‒ использовать символ $ (этот символ используется в служебных идентификаторах)
‒ использовать символ подчеркивания (исключение – обозначение констант,
например, MAX_LENGTH)
‒ использовать слишком длинные идентификаторы (снижает читаемость)
‒ использовать символы отличные от ASCII
(снижает читаемость; затрудняет использование на системах
с отличающейся локализацией)
• Заглавные и строчные буквы различаются!
‒ Name ≠ name
© 2013 NetCracker Technology Corporation Confidential
7

8.

Основы синтаксиса – Соглашения о записи имен
• Пакеты
‒ все буквы строчные
‒ package helloworld;
• Классы и интерфейсы
‒ c заглавной буквы
‒ каждое следующее слово с заглавной буквы
‒ class String {...},
class HelloWorld{}, interface Runnable {...}
• Методы, поля, переменные
‒ с маленькой буквы
‒ каждое следующее слово с заглавной буквы
‒ public static void main(String[] args) {...}
‒ public void doSomething() {...}
‒ int myNewVariable;
• Константы
‒ все буквы заглавные
‒ слова разделяются знаком подчеркивания
‒ MAX_LENGTH, MIN_DOUBLE
© 2013 NetCracker Technology Corporation Confidential
8

9.

Основы синтаксиса – Типы данных
• Примитивные
‒ byte
‒ short
‒ char
‒ int
‒ long
‒ float
‒ double
‒ boolean
• Ссылочные (ссылка на объект в динамической памяти)
‒ все остальное
Java – строго типизированный язык
‒соответствие типов проверяется на этапе компиляции
В Java отсутствует возможность прямого обращения к памяти
и адресная арифметика
© 2013 NetCracker Technology Corporation Confidential
9

10.

Основы синтаксиса – Примитивные типы данных
Целочисленные типы данных
Название
типа
byte
short
int
long
char
Размер
байты
биты
1
8
2
16
4
32
8
64
2
16
Название
типа
float
double
Размер
байты
биты
4
32
8
64
Название
типа
boolean
Область значений
-27 .. 27-1
-215 .. 215-1
-231 .. 231-1
-263 .. 263-1
0 .. 216-1
-128 .. 127
-32 768 .. 32 767
-2 147 483 648 .. 2 147 483 647
-9 223 372 036 854 775 808 .. 9 223 372 036 854 775 807
'\u0000' .. '\uffff' ( 0 .. 65 535)
Дробные типы данных
Область значений
± 3.40282347*1038 .. ± 1.40239846*10-45
± 1.79769313486231570*10308 .. ± 4.94065645841246544*10-324
Булевский (логический) тип данных
Область значений
true, false
© 2013 NetCracker Technology Corporation Confidential
10

11.

Основы синтаксиса – Ссылочный тип
• В Java все объекты находятся в динамически выделяемой памяти (heap)
‒ невозможно создать объект в стэке
• Доступ к объектам осуществляется только с помощью ссылок (reference)
‒ объектного типа нет; есть только ссылки на объекты в куче
• Специальное значение null говорит о том, что ссылка не связана ни с одним
объектом
• Отличия ссылок в Java от указателей в С/С++
‒ В Java отсутствует адресная арифметика (с помощью ссылки невозможно обратиться к
предыдущему или следующему объекту в памяти).
‒ В Java ссылки работают только для объектов. Невозможно создать ссылку на переменную
примитивного типа или функцию.
‒ В Java невозможно преобразовать ссылку в значение примитивного типа или наоборот.
© 2013 NetCracker Technology Corporation Confidential
11

12.

Основы синтаксиса – Литералы
• целочисленный (integer)
• с плавающей точкой (floating-point)
• булевый (boolean)
• символьный (character)
• строковый (string)
• null-литерал (null-literal)
© 2013 NetCracker Technology Corporation Confidential
12

13.

Основы синтаксиса – Целочисленные литералы
• По умолчанию применяется десятичная система исчисления
‒ для типа long в конце буква ‘l’ или ‘L’ (лучше ‘L’)
• Шестнадцатеричная система исчисления
‒ используются символы 0..9, a..f, A..F
‒ начинается с ‘0x’ или ‘0X’
‒ регистр значения не имеет
• Восьмеричная система исчисления
‒ используются символы 0..7
‒ начинается с ‘0’
byte b = 12;
short s = 32000;
int n = 100000;
int oct = 0123; // запись числа в восьмеричном виде. ЭТО НЕ
123 !!!
number too large
с единицей
int hex = 0xCAFE; // запись числа в шестнадцатеричном виде
int hex2 = 0XBeDaBeDa;
int maxInteger = 2147483647;
long badLong = 3000000000; // Ошибка компиляции : integer
long goodLong = 3000000000L; // А так гораздо лучше
long smallL = 3000000000l; // букву ‘L’ легко можно перепутать
© 2013 NetCracker Technology Corporation Confidential
13

14.

Основы синтаксиса – Целочисленные литералы JDK7+
Начиная с версии 7:
• Двоичная система исчисления
‒ используются символы 0,1
‒ начинается с ‘0b’ или ‘0B’ (регистр значения не имеет)
• Разделитель разрядов для длинных чисел
‒ в любом месте в середине числа можно вставить символ ‘_’ для повышения читаемости
int binary = 0b0101010110101010;
int million = 1_000_000_000;
long billion = 1_000_000_000_000L;
long trillion = 1_000_000_000_000_000L;
© 2013 NetCracker Technology Corporation Confidential
14

15.

Основы синтаксиса – Литералы с плавающей точкой
• Используется десятичная система исчисления
• По умолчанию подразумевается двойная точность (тип double)
‒ для double суффикс ‘d’/’D’ можно не указывать
‒ для float нужно в явном виде указывать ‘f’ или ‘F’
double pi=3.14159265359; // По умолчанию double
double e=2.71828182846d; // 'd' на конце ни на что не влияет
double speedOfLight = 3e8; // 'научный формат': = 3 * 10^8
float badFloat = 1.0; // Ошибка компиляции cannot convert from
double to float
float goodFloat = 1.0f;
© 2013 NetCracker Technology Corporation Confidential
15

16.

Основы синтаксиса – Булевы литералы
• true или false
‒ именно в нижнем регистре! TRUE или False – ошибка!
boolean toBeOrNotToBe = true;
boolean iAlwaysLie = false;
© 2013 NetCracker Technology Corporation Confidential
16

17.

Основы синтаксиса – Символьные литералы
• Один символ в одинарных кавычках
• Для записи специальных символов используются спец. последовательности:
\b
\t
\n
\f
\r
\"
\'
\\
\ооо
\u0008
\u0009
\u000a
\u000c
\u000d
\u0022
\u0027
\u005c
от \u0000 до \u00ff
\uXXXX
от \u0000 до \uffff
backspace BS – забой
horizontal tab HT – табуляция
linefeed LF – конец строки
form feed FF – конец страницы
carriage return CR – возврат каретки
double quote " – двойная кавычка
single quote ' – одинарная кавычка
backslash \ – обратная косая черта
любой из первых 256 символов, где ооо – код
символа в восьмеричном формате
любой UTF-16 символ
Символы являются целыми числами типа char (0..65535)
char b = 'a' + 1;
© 2013 NetCracker Technology Corporation Confidential
17

18.

Основы синтаксиса – Строковые литералы
• Любое количество символов в двойных кавычках
• Могут содержать специальные символы (см. пред. слайд)
• Используется для создания объектов типа String
String s1 = ""; // строковый литерал нулевой длины
String s2 = "Hello, World!"; // неявное создание объекта String
String s3 = new String ("Hello, World!"); // явное создание
объекта String
© 2013 NetCracker Technology Corporation Confidential
18

19.

Основы синтаксиса – null-литерал
• Используется с переменными ссылочного типа
• Неинициализированные поля объектов имеют значение null
• Очищайте ссылки на ненужные больше объекты, чтобы Garbage Collector
мог раньше очистить занимаемую ими память
String hw = "Helo, World!";
// ...
// ...
hw = null;
© 2013 NetCracker Technology Corporation Confidential
19

20.

Основы синтаксиса – Объявление переменных
• Синтаксис:
[<модификаторы>] <тип> <название> [= <выражение>];
final int tattuqoltuae = 42;
int four = 2*2;
int noInit;
• Допускается, но не рекомендуется, объявлять несколько переменных в
одной строке
double a,b,c,d,x1,x2; // Не делайте так!
• Для локальных переменных значения по умолчанию автоматически не
присваиваются. Локальные переменные обязательно нужно
инициализировать до того, как они будут прочитаны.
int x;
System.out.println(x); // Ошибка компиляции
© 2013 NetCracker Technology Corporation Confidential
20

21.

22.

Операторы – Приоритет операторов
Порядок
выполнения
Оператор
-
. [ ] ( ) (вызов метода)
R to L
++ -- +(унарный) –(унарный) ~ ! (преобразование типов)
L to R
*/%
L to R
+-
L to R
<< >> >>>
L to R
< > <= >= instanceof
L to R
== !=
L to R
&
L to R
^
L to R
|
L to R
&&
L to R
||
R to L
?:
R to L
= *= /= %= += -= <<= >>= >>>= &= ^= |=
© 2013 NetCracker Technology Corporation Confidential
22

23.

Операторы – Логические операторы
• Для boolean выражений:
!
&
|
Отрицание
Логическое «И»
Логическое
«ИЛИ»
^
Логическое
«исключающее
ИЛИ»
• Для целочисленных выражений:
~
&
|
Дополнение
Побитовое «И»
Побитовое
«ИЛИ»
^
Побитовое
«исключающее
ИЛИ»
При выполнении этих операций всегда вычисляются оба операнда
© 2013 NetCracker Technology Corporation Confidential
23

24.

Операторы – Short-circuit логические операторы
• Для boolean выражений:
&&
||
Короткозамкнутое логическое «И»
Короткозамкнутое логическое «ИЛИ»
Второй операнд вычисляется только если первого недостаточно
Можно использовать чтобы избегать NullPointerException:
MyDate d;
//...
if ((d != null) && (d.day() > 31)) {
// do something with d
}
© 2013 NetCracker Technology Corporation Confidential
24

25.

Операторы – Конкатенация строк оператором +
String name = "Иван";
String surname = "Иванов";
String fullName = surname + " " + name;
Если один из операндов строка, а второй нет, то он тоже преобразуется
в строку
Вычисления происходят слева направо:
String s1 = "abc" + 2 + 2;
String s2 = 2 + 2 + "abc";
© 2013 NetCracker Technology Corporation Confidential
// В s1 запишется abc22
// В s1 запишется 4abc
25

26.

Операторы – Операторы сдвига
• Арифметический или знаковый сдвиг вправо (>>). При сдвиге знаковый бит
копируется
‒ 128 >> 1 128 / 21 = 64
‒ 256 >> 4 256 / 24 = 16
‒ -256 >> 4 -256 / 24 = -16
• Логический сдвиг вправо (>>>). Используется для работы с битовыми
полями. Знаковый бит не копируется (заполняется нулями)
• Сдвиг влево (<<). Знаковый бит не копируется (теряется)
‒ 128 << 1 128 * 21 = 256
‒ 16 << 2 16 * 22 = 64
© 2013 NetCracker Technology Corporation Confidential
26

27.

Операторы – Приведение типов
• Перед выполнением операций над данными разных типов они приводятся к
одному типу
• Приведение типов бывает:
• Явное (указывается программистом)
‒ Возможна потеря точности
‒ Возможна потеря значимости
• Неявное (создается компилятором автоматически)
‒ Возможна потеря точности
long lVal = 1000; // OK. int неявно преобразовалось в long
int iVal= lVal; // ОШИБКА! long не может быть неявно
преобразовано в int
int iVal2 = (int)lVal; // Компилируется. Возможна потеря
значимости
© 2013 NetCracker Technology Corporation Confidential
27

28.

Операторы – Явное приведение типов
• Программист указывает какое выражение к какому типу следует привести:
(новый_тип) выражение;
• Возможны потери точности
• Возможны потери значимости
double d=3.14159265359;
float f=(float) d; // Потеря точности
System.out.println(f); // 3.1415927
int i = 257;
byte b = (byte) i; // Потеря значимости
System.out.println (b); // 1
© 2013 NetCracker Technology Corporation Confidential
28

29.

Операторы – Неявное приведение типов
Если один из операндов
имеет тип
то второй тоже
преобразовывается в
double
double
float
long
float
long
иначе оба преобразовываются к типу
int
© 2013 NetCracker Technology Corporation Confidential
29

30.

Операторы – Неявное приведение типов
char
byte
shor
t
int
long
float
double
без потери точности
© 2013 NetCracker Technology Corporation Confidential
с возможной
потерей точности
30

31.

Операторы – Пример 1
int chinaPopulation = 1360000000;
int indiaPopulation = 1240000000;
int total = chinaPopulation +
indiaPopulation;
System.out.println(total); // ???
___________________________________________________________
byte b1=1;
byte b2=2;
byte b3=b1+b2; // Ошибка компиляции
© 2013 NetCracker Technology Corporation Confidential
31

32.

Операторы – Пример 2
int i = 123456789;
float f = i;
double d = i;
short s = (short) i;
System.out.println("int: " + i);
System.out.println("float: " + f);
System.out.println("double: " + d);
System.out.println("short: " + s);
© 2013 NetCracker Technology Corporation Confidential
32

33.

Операторы – Пример 3
int a=1;
int b=0;
int c=a/b;
System.out.println(c);
© 2013 NetCracker Technology Corporation Confidential
33

34.

Операторы – Пример 4
double a=1;
double b=0;
double c=a/b;
System.out.println(c);
System.out.println("c+1 = " + (c + 1));
System.out.println("+0.0 == -0.0 : " + (0.0
== -0.0));
System.out.println("a/(+0.0) = " +
(a/(+0.0)));
System.out.println("a/(-0.0) = " + (a/(-
© 2013 NetCracker Technology Corporation Confidential
34

35.

Операторы – Пример 5
double a=0;
double b=0;
double c=a/b;
System.out.println("c
System.out.println("c+0
=" + c);
=" + (c + 0));
System.out.println("c<0
System.out.println("c>0
=" + (c < 0));
=" + (c > 0));
System.out.println("c==0 =" + (c == 0));
System.out.println("c!=0 =" + (c != 0));
System.out.println("c==c =" + (c == c)); // :)
System.out.println("c!=c =" + (c != c)); // :)
System.out.println("c == NaN: " + (c == Double.NaN)); // :)))
System.out.println("c is NaN: " + Double.isNaN(c)); // Делайте
именно так
© 2013 NetCracker Technology Corporation Confidential
35

36.

37.

Управление потоком выполнения – Блоки
public class BlockDemo{
static int a=0; // Переменная на уровне класса
public static void main(String[] args) {
int a=1; // Переопределяем. Так делать допускается.
{
a=2; // Ok
int a=3; // Error: already defined
int b=4; // Ok
}
b=5; // Error: cannot find
int b=6; // Ok
}
}
© 2013 NetCracker Technology Corporation Confidential
37

38.

Управление потоком выполнения – Ветвления if
if ( булевое_выражение) {
команда_или_блок;
}
if (булевое_выражение) {
команда_или_блок;
} else {
команда_или_блок;
}
© 2013 NetCracker Technology Corporation Confidential
38

39.

Управление потоком выполнения – Ветвления if (2)
if (d<0) {
System.out.println ("Нет корней!");
return;
}
if (d<0) {
System.out.println ("Нет корней!");
return;
} else {
// x1 = ....
// x2 = ....
}
© 2013 NetCracker Technology Corporation Confidential
39

40.

Управление потоком выполнения – Ветвления if (3)
• Антипаттерн! Допускается, но крайне не рекомендуется опускать фигурные
скобки, если блок состоит всего из одной команды.
hours++;
if (hours == 24)
hours=0;
• Всегда ставьте фигурные скобки
hours++;
if (hours == 24) {
hours=0;
}
• Исключение – цепочки if - else if (см. след. слайд)
© 2013 NetCracker Technology Corporation Confidential
40

41.

Управление потоком выполнения – Ветвления if (4)
• Цепочка if – else if – else if – ... – else
if (d < 0) {
System.out.println("Нет корней!");
// ...
} else if (d == 0) {
System.out.println("Один корень");
// x = ...
} else {
System.out.println("Два корня");
// x1 = ...
// x2 = ...
}
© 2013 NetCracker Technology Corporation Confidential
41

42.

Управление потоком выполнения – Ветвления switch
switch (выражение) {
case constant1:
команды;
break;
case constant2:
команды;
break;
//...
default:
команды;
break;
}
• Не забывайте писать break
• Раздел default – не обязательный
• Выражение/константа могут быть типа byte, short, int или char
• В Java7 выражение/константа также может быть String
© 2013 NetCracker Technology Corporation Confidential
42

43.

Управление потоком выполнения – Ветвления switch (2)
Пример
switch (colorNum) {
case 0:
setBackground(Color.RED);
break;
case 1:
setBackground(Color.GREEN);
break;
default:
setBackground(Color.BLACK);
break;
}
© 2013 NetCracker Technology Corporation Confidential
43

44.

Управление потоком выполнения – Циклы for
for (инициализация; условие; обновление) {
команда или блок;
}
• Каждое из выражений «инициализация», «условие», «обновление» может
отсутствовать
• for(;;) {} – «вечный» цикл
• если в «инициализации» объявлена переменная, считается, что она
объявлена в блоке тела цикла и не видна за его границами (ниже
закрывающейся фигурной скобки)
• «условие» проверяется перед выполнением итерации (т.е. может быть, что
тело цикла не выполнится ни разу)
• «обновление» происходит после выполнения итерации
• в «обновлении» может быть записано несколько выражений через запятую
(например «i++, j++»)
© 2013 NetCracker Technology Corporation Confidential
44

45.

Управление потоком выполнения – Циклы for (2)
• Примеры:
for (int i = 0; i < 10; i++) {
System.out.println("Hello, World!");
}
for (int i=0, j=10; i<=10; i++, j--){
System.out.println(i + " " + j);
}
© 2013 NetCracker Technology Corporation Confidential
45

46.

Управление потоком выполнения – Циклы while
while (условие) {
команда или блок;
}
• «условие» проверяется перед выполнением итерации (т.е. может быть, что
тело цикла не выполнится ни разу)
• while (true) {} – «вечный» цикл
© 2013 NetCracker Technology Corporation Confidential
46

47.

Управление потоком выполнения – Циклы while (2)
• Пример:
int i=0;
while (i < 10) {
System.out.println("Hello, World!");
i++;
}
© 2013 NetCracker Technology Corporation Confidential
47

48.

Управление потоком выполнения – Циклы do-while
do {
команда или блок;
} while (условие);
• «условие» проверяется после выполнением итерации (т.е. тело цикла
выполнится как минимум 1 раз)
• do {} while (true) – «вечный» цикл
• если «условие» == true, то переход на следующую итерацию. (Не путать с
Pascal конструкцией repeat-until, в которой «условие» == true приводит к
выходу из цикла)
• После while («условие» ) не забывайте ставить «;»
© 2013 NetCracker Technology Corporation Confidential
48

49.

Управление потоком выполнения – Циклы do-while (2)
• Пример:
int i=0;
do {
System.out.println("Hello World");
i++;
} while (i < 10);
© 2013 NetCracker Technology Corporation Confidential
49

50.

Управление потоком выполнения – break
• используется для преждевременного выхода из циклов for, while, do-while
• вместе с метками позволяет выйти из любого блока (почти как “goto”)
do {
выражение_или_блок;
if (условие_преждевременного_выхода)
break;
выражение_или_блок;
} while (условие_продолжения_цикла);
© 2013 NetCracker Technology Corporation Confidential
50

51.

Управление потоком выполнения – break
• Пример:
int i=0;
while (true) { // Вечный цикл
System.out.println("Hello, World!");
i++;
if (i>5)
break; // Досрочный выход из цикла
}
• Пример 2 (не делайте так):
label:{
System.out.println(1);
if (true) {
break label;
}
System.out.println(2);
}
© 2013 NetCracker Technology Corporation Confidential
51

52.

Управление потоком выполнения – continue
• используется для преждевременного окончания текущей итерации циклов
for, while, do-while и перехода на следующую итерацию
• Пример:
// вычисление суммы первых 20 чисел, кроме
числа 13
int s=0;
for (int i=1; i<=20; i++) {
if (i == 13)
continue;
s = s + i;
}
© 2013 NetCracker Technology Corporation Confidential
52

53.

Управление потоком выполнения – метки
• break и continue влияют на работу текущего цикла. Для работы с
вложенными циклами эти команды применяются с метками:
outer: do {
выражение_или_блок;
do {
выражение_или_блок;
if (условие)
break outer;
} while (условие);
выражение_или_блок;
} while (условие);
• меткой можно пометить любой блок (не только цикл) и с помощью break
выйти из него. Не делайте так
© 2013 NetCracker Technology Corporation Confidential
53

54.

55.

Массивы
• Массивы предназначены для хранения большого количества однотипных
данных (+полиморфизм для объектов)
• В Java массивы являются объектами
‒ как и все другие объекты хранятся в Heap
‒ имя массива = ссылка на массив
‒ массив имеет поля (length) и методы (унаследованные от Object)
• У массива есть поле length (длина массива)
• Нумерация ячеек zero-based
‒ первый элемент находится в ячейке № 0
‒ последний элемент находится в ячейке № (length-1)
• Невозможно выйти за границы массива
‒ при попытке выбрасывается исключение IndexOutOfBoundsException
• Размер массива изменить нельзя
‒ но можно создать новый массив другого размера, скопировать в него данные и
использовать ссылку на него вместо ссылки на старый массив
© 2013 NetCracker Technology Corporation Confidential
55

56.

Массивы – Объявление массивов
• Предпочтительный вариант:
тип[] имя;
• Допускается:
тип []имя;
// то же самое
тип имя[]; // почти то же самое
• Пример:
int []a, b; // объявляется 2 массива: a и b
int c[], d; // объявляется массив с и переменная d
int[] e, f; // чтобы не было путаницы пробелы лучше ставить так
String[] s; // для объектов точно так же как для примитивов
© 2013 NetCracker Technology Corporation Confidential
56

57.

Массивы – Создание массивов
• Создание пустого массива:
int[] a;
a= new int[10];
int[] b = new int[10];
Обязательно указывается размер
Заполняется значениями по умолчанию:
0 – для чисел
false – для boolean
null – для объектов
• Создание + инициализация
int[] a = {1,2,3,4,5};
Размер массива не указывается
(подсчитывается компилятором)
int[] b = new int[] {2, 4 ,6};
© 2013 NetCracker Technology Corporation Confidential
57

58.

Массивы – Создание многомерных массивов
• В Java многомерный массив =
массив со ссылками на массивы
int twoDim [][] = new int [4][];
twoDim[0] = new int[5];
twoDim[1] = new int[5];
twoDim[2] = new int[5];
twoDim[3] = new int[5];
Heap
Stack
int[][]
twoDim
int[]
Можно создавать
непрямоугольные массивы
int[]
int[]
int[]
• Для прямоугольных массивов
можно проще
int twoDim [][] = new int [4][5];
© 2013 NetCracker Technology Corporation Confidential
58

59.

Массивы – Изменение размера массивов
• Размер массива изменить НЕЛЬЗЯ
• Можно создать новый массив, скопировать в него элементы и использовать
ссылку на него вместо старого
int[] elements = { 1, 2, 3, 4, 5 }; // массив из 5 элементов
int[] tmp = new int[10];
System.arraycopy(elements, 0, tmp, 0, elements.length);
elements = tmp;
for (int e : elements) {
System.out.println(e);
}
© 2013 NetCracker Technology Corporation Confidential
59

60.

61.

English Русский Правила