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

Письмак

Дисклеймер

Данная статья не является официальной со стороны университета ИТМО или кафедры ВТ

В мануале с малой долей вероятности могут быть ошибки или неточности. Сообщить о них можно по VK : https://vk.com/apploidxxx

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

Примеры приведенных кодов в каталоге в гитхаб репозитории, там же вы можете найти раздельные файлы по главам в виде markdown разметки: https://github.com/AppLoidx/programming-manual

О Java в целом

Язык Java. Особенности языка.

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

Так в чем же особенность языка Java? Думаю, самая всем известная его особенность - это кроссплатформенность.

Ну, кроссплатформенность это, конечно, хорошо, но каким образом она достигается?

Чтобы понять это, давайте сначала рассмотрим прародитель языка Java, всеми известный C++. Вашу программу, написанную на языке Си, нужно будет компилировать под разные целевые платформы (Windows, Mac и прочее), которые будут работать только под них.

А что значит компиляция? Почему под разные платформы вам нужно создать разные скомпилированные программы?

Опять появляется множество вопросов, на которые ответить, не зная основ компьютерной архитектуры - не так уж и просто ответить.

Начнем с архитектуры вашего любимого устройства:

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

А здесь я попытаюсь рассказать вкратце и поверхностно.

Существует огромная разница между тем, что удобно людям, и тем что могут компьютеры. Мы хотим делать X, но компьютеры в то же время могут делать только Y. Из-за этого возникает проблема.

Эту проблему можно решить двумя способами. Оба подразумевают разработку новых команд, более удобных для человека, чем встроенные машинные команды. Эти новые команды в совокупности формируют язык, который будем называть Я1. Встроенные машинные команды - Я0. Компьютер может исполнять только программы, написанные на его машинном языке Я0.

Логично предположить, что в любом случае нам нужно исполнить программу написанную на Я1, когда компьютеру доступен лишь язык Я0.

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

Трансляторы, которые транслируют программы на уровень 3 или 4 (см. рисунок выше), называются компиляторами.

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

А теперь представим себе виртуальную машину, для которой машинным языком является язык Я1. Назовем такую машину М1, а машину для работы с языком Я0 - М0. Если бы такую машину М1 можно было сконструировать без больших денежных затрат, язык Я0 был бы не нужен. Можно было бы писать программы сразу на языке Я1, а компьютер сразу бы их исполнял. Тем не менее, такие машины, возможно, не удастся создать из-за чрезмерной дороговизны или трудностей разработки. Поэтому и появилось понятие виртуальная машина. Люди вполне могут писать ориентированные на неё программы. Эти программы будут транслироваться или интерпретироваться программой, написанной на языке Я0, а сама она могла бы исполняться существующим компьютером. Другими словами, можно писать программы для виртуальных машин так, будто эти машины реально существуют.

JVM - это виртуальная машина, но не стоит путать её с System virtual machines (которые могут обеспечивать функциональность, необходимую для выполнения целых операционных систем).

JVM относится к Process virtual machines, которые предназначены для выполнения компьютерных программ в независимой от платформы среде. Например, он исполняет байт-код, который можно считать языком Я1, а машина на которой стоит наш JVM (М1) это М0, умеющий выполнять программы Я0. Другими словами, JVM физически не существует - это по сути программа, написанная на языке Я0, которая может обрабатывать программы с языком Я1, интерпретируя его в язык Я0.

Таким образом, JVM разный под каждую платформу, так как ему нужно интерпретировать входную программу (байт-код) в программу, которую может понять конкретная платформа (Windows, Mac etc).

Давайте поймем разницу между байт-кодом (программа для JVM) и двоичным кодом, который понимает "процессор":

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

xxxxxxxxxx
29
1
004: 003 010       lbl adda    #8      immediate value decimal
2
006: 103 010           addb    #010    same thing in octal
3
010: 024 001           lda     b       memory reference
4
012: 235 220           stx     (ptr)   indirect reference
5
014: 306 204           ora     data,x  indexed
6
016: 337 220           lnega   (ptr),x indirect/indexed
7
020:               # jumps and calls
8
020: 344 004           jmp     lbl     unconditional jump
9
022: 043 030           jane    lbl2-2  jump if a not equal 0
10
024: 257 221           jxgt    (ptr+one) jump indirect if x gt
11
026: 364 041           call    sub     call to subroutine
12
030: 174 220           cbeq    (ptr)   call indirect if b eq 0
13
032:               # set and skips
14
032:                   lbl2
15
032: 122 204           set1    fox,2  set bit 2 of data to 1
16
034: 272 205           skp0    data+1,7  skip if bit 7 is 0
17
036:               # shifts and rotates
18
036: 001               shra    1+SHIFT   shift a right 4 plcs
19
037: 361               rolb    2       rotate b left 2 places
20
040: 000               hlt             halt
21
041: 000               sub db 0            return address
22
042: 200               nop             no op
23
043: 023 222           lda #0222
24
045: 123 144           ldb #100
25
047: 360               sys             system call (extension)
26
050: 023 222           sysp 0222,100   system call using parms
27
052: 123 144
28
054: 360
29
055: 354 041           jmp (sub)       return

Не надо вдаваться в подробности, просто пример изнутри.

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

Один из способов проблемы переносимости и сложности это промежуточная виртуальная машина.

Виртуальный процессор работает также, как и реальный: он видит массив чисел, и воспринимает их как команды для выполнения. Байт-код внешне совершенно идентичен двоичному коду. Вот пример байт-кода виртуальной машины Java:

xxxxxxxxxx
8
1
000: 03        iconst_0
2
001: 3b        istore_0
3
002: 84 00 01  iinc 0, 1
4
005: 1a        iload_0
5
006: 05        iconst_2
6
007: 68        imul
7
010: 3b        istore_0
8
011: a7 ff f9  goto -7

Единственная разница заключается в том, что двоичный код исполняет физический процессор, а байт-код — очень простая программа-интерпретатор.

Итак, сделаем заключение:

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

В настоящее время язык программирования Java в значительной степени независим от виртуальной машины Java, так что буква "J" в аббревиатуре "JVM" немного вводит в заблуждение, поскольку JVM в состоянии выполнять любой язык JVM, который может сгенерировать корректный файл класса. Например, Scala, генерирующий байт-код для выполнения в JVM.

Как итог, можно сказать, что если вы напишите вашу программу в Windows (и допустим сделаете из него какой-нибудь jar-файл), то он сможет запуститься на Mac или Unix (по крайней мере, так задумано), если у них стоит JVM.

Практика

Давайте напишем простую программу Hello.java:

xxxxxxxxxx
7
1
public class Hello {
2
        public static void main(String ... args){
3
                for(int i=0;i<10;i++){
4
                        System.out.println("ITMO");
5
                }
6
        }
7
}

Скомпилируем её с помощью команды javac:

xxxxxxxxxx
1
1
javac Hello.java

После того как вы её скомпилируете вы можете увидеть файл Hello.class - ваша скомпилированная программа, иначе говоря байт-код.

Запустить её можно командой java:

xxxxxxxxxx
1
1
java Hello

Прим. не надо указывать его расширение (.class) - необходимо и достаточно указать лишь его имя.

Java поставляется с дизассемблером файлов классов под названием jаvap, который позволяет изучать .сlаss-файлы. Взяв файл класса Hello и запустив javap -с Hello, мы получим следующий результат:

xxxxxxxxxx
22
1
Compiled from "Hello.java"
2
public class Hello {
3
  public Hello();
4
    Code:
5
       0: aload_0
6
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
7
       4: return
8
​
9
  public static void main(java.lang.String...);
10
    Code:
11
       0: iconst_0
12
       1: istore_1
13
       2: iload_1
14
       3: bipush        10
15
       5: if_icmpge     22
16
       8: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
17
      11: ldc           #3                  // String ITMO
18
      13: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
19
      16: iinc          1, 1
20
      19: goto          2
21
      22: return
22
}

Опять же пока не стоит вдаваться в подробности (хотя в моей памяти, вроде и бывало что спрашивали про основные команды, например, goto, bipush или istore)

Осталось чуть-чуть...

Итак, переходя ко второму контрольному вопросу: что же такое JVM, JRE и JDK?

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

JRE и JDK относительно проще, чем определение JVM:

• JRE ( Java Runtime Environment) - это среда выполнения Java - она, помимо прочего, содержит JVM и является тем, что вам нужно для запуска Java-программы. Она не содержит инструментов и утилит, таких как компиляторы или отладчики для разработки приложений.
• JDK (Java Development Kit) - является расширенным набором JRE и содержит все, что есть в JRE, а также такие инструменты, как компиляторы и отладчики, необходимые для разработки.

JIT-компиляция

Еще один из частых вопросов на лабах - что такое JIT-компиляция?

JIT (Just-in-Time, своевременная) компиляция появилась в HotSpot VM (см. приложение A), в котором модули программы (интерпретированные из байт-кода) компилируются в машинный код. Модулями компиляции в HotSpot являются метод и цикл.

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

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

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

Пример инлайнинга JIT-компилятора можно увидеть здесь: https://habr.com/ru/post/305894/

Переходя к программированию

Далее будут материалы касающееся непосредственно программирования на языке Java.

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

Рассмотрим примитивные типы в JVM:

Виртуальная машина Java поддерживает следующие примитивные типы: числовые типы, boolean тип и типы с плавающей точкой

Целые типы

• byte, содержит 8-битовые знаковые целые.

  • Значение по умолчанию - ноль.

• short, содержит 16-битовые знаковые целые.

  • Значение по умолчанию - ноль.

• int, содержит 32-битовые знаковые целые.

  • Значение по умолчанию - ноль.

• long, содержит 64-битовые знаковые целые.

  • Значение по умолчанию - ноль.

• char, содержит 16-битовые беззнаковые целые, представляющие собой кодовые точки таблицы символов Unicode в базовой странице UTF-16.

  • Значение по умолчанию - нулевая кодовая точка ('\u0000')

Типы с плавающей точкой

• float, содержит числа с плавающей точкой одинарной точности.

  • Значение по умолчанию - положительный ноль.

• double, содержит числа с плавающей точкой двойной точности.

  • Значение по умолчанию - положительный ноль.

Значение boolean типа может быть true или false, значение по умолчанию false.

Целочисленные типы и их значения

Существуют следующие диапазоны для целочисленных значений:

• для типа byte от -128 до 127 (-2^7^ до 2^7^ - 1) включительно;
• для типа short от -32768 до 32767 (-2^15^ до 2^15^ - 1) включительно;
• для типа int от -2147483648 до 2147483647 (-2^31^ до 2^31^ - 1) включительно;
• для типа long от -9223372036854775808 до 9223372036854775807 (-2^63^ до 2^63^ - 1) включительно;
• для типа char от 0 до 65535 включительно;

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

Например, может попасться задача такого рода:

xxxxxxxxxx
7
1
public class ExampleWithByte{
2
    public static void main(String ... args){
3
        byte x = 127;
4
        x++;
5
        System.out.println(x);      //  -128
6
    }
7
}

Эта программа при исполнении выводит -128. Объяснить это очень просто, зная диапазоны типов данных. А почему именно -128 это вопрос к дискретке и двоичному представлению чисел в машине.

Типы данных с плавающей точкой, множества значений и значения

Типами данных с плавающей точкой являются типы float и double соответственно 32-х битые значения одинарной точности и 64-х битные значения двойной точности. Формат чисел и операции над ними соответствуют спецификации IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std. 754-1985, New York).

Стандарт IEEE 754 включает в себя не только положительные и отрицательные значения мантиссы, но также и положительные и отрицательные нули, положительные и отрицательные бесконечности, и специальное не числовое значение NaN (Not-a-Number). NaN используется в качестве результата некоторых неверных операций, таких как деление нуля на нуль.

Все значения (кроме не-чисел NaN) множества чисел с плавающей точкой упорядочены. Если числа упорядочить по возрастанию, то они образуют такую последовательность: отрицательная бесконечность, отрицательные конечные значения, отрицательный ноль, положительный ноль, положительные значения и положительная бесконечность.

Сравнивая положительный и отрицательный ноль, мы получим верное равенство, однако существуют операции, в которых их можно отличить; например, деля 1.0 на 0.0, мы получим положительную бесконечность, но деля 1.0 на -0.0 мы получим отрицательную бесконечность.

Не-числа NaN не упорядочены, так что сравнение и проверка на равенство вернёт ложь, если хотя бы один из операндов не-число NaN. В частности проверка на равенство значения самому себе вернёт ложь тогда и только тогда, кода операнд не-число NaN. Проверка на неравенство вернёт истину, когда хотя бы из операндов не-число NaN.

JAR и манифесты

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

Приведу очень простой пример создания Jar-архива. Примеры будут в папке examples/manual-1/jar

Для начала создадим нашу программу и назовем её условно Lab.java:

xxxxxxxxxx
5
1
public class Lab {
2
    public static void main(String ... args) {
3
        System.out.println("it works on my machine");
4
    }
5
}

Скомпилируем:

xxxxxxxxxx
1
1
javac Lab.java

Получим байт-код Lab.class.

Чтобы запаковать его используем команду jar с параметрами c (create) и f(file).

xxxxxxxxxx
1
1
jar cf Labpack.jar Lab.class

На выходе вы получите файл Labpack.jar, который запускается командой:

xxxxxxxxxx
1
1
java -jar Labpack.jar

Но программа не исполнится как задумано, а вместо этого выведет:

xxxxxxxxxx
1
1
no main manifest attribute, in .\Labpack.jar

Дело в том, что в таком jar-пакете может быть несколько файлов и исполняющая машина не может знать какую из них выполнить.

Чтобы указать ему наш класс для выполнения создадим файл MANIFEST.MF.

Есть несколько способов для Unix-подобных систем. Пользуйтесь таким какой вам удобнее

Вот внутренности MANIFEST.MF

xxxxxxxxxx
2
1
Version: 6.6.6
2
Main-Class: Lab

Здесь мы указали версию нашего пакета, а самое главное точку входа (класс Lab)

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

xxxxxxxxxx
1
1
jar cfm Labpack.jar MANIFEST.MF Lab.class

Здесь важно соблюдать порядок:

1. Имя jar-пакета
2. Путь к манифесту
3. Классы

Запустив его предыдущей командой java -jar Labpack.jar мы получим:

xxxxxxxxxx
1
1
it works on my machine

Остальные контрольные вопросы

Мне не очень-то уж и хочется рассказывать про синтаксис языка Java - да, в некоторых из них есть не очевидные на первый взгляд нюансы, но проблем с базовыми вещами (for, for-each, while, do-while) быть не должно (тысячи и тысячи статей).

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

xxxxxxxxxx
50
1
1. Что такое JAR, для чего он нужен?
2
1.1 Что такое манифест, основные параметры (Main-Class, Version ...)
3
1.2 Как собирать JAR (консольная команда)
4
​
5
2. Чем отличаются (что такое) JDK, JRE и JVM
6
2.1 Что такое IDE?
7
​
8
3. Что такое компиляция? Какие виды еще есть (интерпретация, трансляция...(на будущее))?
9
3.1 Жизненный цикл Java программы
10
​
11
4. Почему программу написанную на Java можно запускать на любой платформе?
12
4.1 Какую роль в этом играет JVM?
13
4.2 Что такое байт-код?
14
​
15
5. Примитивные типы данных. Сколько их существует? Представление данных и их классификация
16
5.1 В чем различия double и float?
17
5.2 Сколько бит ответедено под каждый примитивный тип?
18
5.3 Константы (final). Можно ли не инициализировать константу при объявлении?
19
5.4 Преобразование и приведение типов. В чем отличие?
20
5.4 (Сложнаааа) В чем отличие примитивных и ссылочных типов данных?
21
5.5 В чем ошибка: byte a = 1, b =2; byte c = a + b;
22
​
23
6. Основные методы библиотеки Math
24
6.1 Вспомогательные пакеты Java. Пакет java.util (для чего он нужен).
25
6.1 Как хранятся эти пакеты?
26
​
27
7. Что такое NaN? В каких случаях он возникает и с какими типами данных?
28
​
29
8. Зарезервированные лексемы (continue, for, break, else ...)
30
​
31
9. Комментарии 3 вида (чучуть про джавадок) 
32
​
33
10. Линейные и нелинейные программы.
34
10.1 синтаксис while, do-while, switch, тернарный оператор, foreach-цикл
35
10.2 Что вы можете рассказать о конструкции: for(;;) { }
36
10.3 Какие типы данных могут быть использованы в операторе switch?
37
10.4 Как работает тернарный оператор?
38
​
39
11. Стандартные потоки (out, err, in)
40
11.1 Как использовать стандартные потоки ввода/вывода в Java?
41
​
42
12. java.util.Arrays - работа с массивами
43
12.1 Как устроены многомерные массивы?
44
12.2 Сколько элементов может хранить массив?
45
​
46
13. (Сложнааа) оператор "new"
47
​
48
14. Работа со строками (trim, replace ...). Тип данных String
49
​
50
15. (Сложнаааа, ни нада) goto в Java. Как ставить label?

Приложение А. AOT- и JIT-компиляция

В этом разделе мы обсудим и сравним раннюю (Ahead-of-Time - AОТ) компиляцию и компиляцию оперативную (Just-in-Time - JIТ)

AOT

Если у вас есть опыт программирования на таких языках, как С или С++, то вы знакомы с AОТ-компиляцией (возможно, вы всегда называли ее просто "компиляцией"). Это процесс, при котором внешняя программа (компилятор) принимает исходный текст (в удобочитаемом для человека виде) и на выходе дает непосредственно исполняемый машинный код.

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

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

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

Это приводит к ситуации, когда AОТ-скомпилированные бинарные файлы не в состоянии в полной мере использовать имеющиеся возможности процессора.

JIT

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

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

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

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

Поэтому JIТ-компиляция выполняется экономно, а VM собирает статистику о вашей программе (ищет "горячие пятна"), чтобы знать, где лучше всего выполнять оптимизацию.

Приложение Б. Использованная литература

• Tim Lindholm, Frank Yellin - JVM Specification Java SE8 Edition
• Брюс Эккель - Философия Java
• Benjamin Evans - Optimizing Java. Practical techniques for improving JVM application performance
• Письмак А.Е. - Конспекты лекций первого семестра
• Э. Таненбаум - Архитектура компьютера
• Ну и как всегда stackoverflow

ООП в контексте Java (редактируется)

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

Письмак

Объектно-Ориентированное Программирование

Мини-вступление

Чтобы понять "Что такое ООП?" мне понадобилось 3 недели (если не считать, что задолго до этого пытался изучить ООП в контексте C# и Python), я уже мог пользоваться этими объектами и использовать в своем Java-коде (к слову, это была усложненная версия первой лабы).

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

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

Для "опытных" пользователей компьютера

Если вы уже знаете что такое ООП на уровне свободного использования объектов на любом языке поддерживающим парадигму ООП, то сразу можете переходить к главе "ООП в Java"

Далее, мы рассмотрим ООП в общем плане, не привязывая чисто к Java, но для примеров будем использовать его.

Канон

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

Но я поступлю иначе, и сначала попытаюсь объяснить "что такое объект?".

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

Кузнечик

Представим себе кузнечика. Пусть, это будет наш объект.

Какие у него есть свойства? Например, длина, окрас и пускай у него еще будет имя Боб.

Итак, попробуем записать нашего Боба:

xxxxxxxxxx
5
1
Grig(кузнечик){
2
    length: 5;
3
    color: brown;
4
    name: "Bob";
5
}

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

xxxxxxxxxx
8
1
Grig{
2
    length: 5;
3
    color: brown;
4
    name: "Bob";
5
    
6
    function jump(){ "jump 25 cm" };
7
    function eat(){ "eat green grass" };
8
}

Теперь, у нас есть объект - у него свойства (length, color, name) и методы (действия в данном случае)(jump, eat). Здесь важно понимать, что jump и eat - это функции, то есть выполняют какую-то операцию.

Но, насколько бы он не был интровертом, думаю, ему все равно нужна пара, поэтому давайте создадим ему девушку:

xxxxxxxxxx
8
1
Grig{
2
    length: 4.9;
3
    color: green;
4
    name: "Alice";
5
    
6
    function jump(){ "jump 25 cm" };
7
    function eat(){ "eat green grass" };
8
}

Когда у нас есть два объекта, попробуем сравнить их. У них те же имена свойств (length, color, name), но разные значения. В том числе, у них одинаковые имена методов (jump, eat).

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

xxxxxxxxxx
8
1
class Grig {
2
    length: null;
3
    color: null;
4
    name: null;
5
    
6
    function jump(){ "jump 25 cm" };
7
    function eat(){ "eat green grass" };
8
}

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

Мы представили объект и класс как кузнечиков. А теперь попробуйте посмотреть вокруг себя внутри комнаты, на улице. Все является объектом! И ведь правда, любой встреченный человек - это объект из шаблона ( класса) человек. Или, например, лампа - у нее есть свой цвет, размер (свойства), к тому же она может светить (метод).

Здесь я бы хотел привести цитату, которую повторял мой учитель информатики. Она, вроде как я помню, была от Брюса Ли, а оригинал я не нашел, но суть была такая:

Видеть Кунг-Фу во всем

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

И вот однажды после пар на Кронверкской я направлялся на Горьковскую и неожиданно меня осенило:

-- "Так вот же объекты, вот они проходят мимо меня, эти чертовы люди! Вот стоит машина, а ведь это тоже объект".

Так, восприятие моего мира изменилась, хотя на жизнь это вряд ли повлияло.

ООП в Java

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

Предисловие: если вы понимаете парадигмы ООП и умеете применять их в стеке Java, то сразу можете переходить к главе со звездочкой Стек и Куча.

Итак, погружаемся в ООП...

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

Примеры исходников можно найти в examples/manual-2

Давайте реализуем наши классы кузнечиков в контексте Java:

Листинг 1.1 FirstExample.java

xxxxxxxxxx
39
1
class Grig {
2
    double length;
3
    String color;
4
    String name;
5
​
6
    void jump(){
7
        System.out.println(name + " is jumping");
8
    }
9
​
10
    void eat(){
11
        System.out.println(name + " is eating grass");
12
    }
13
}
14
​
15
public class FirstExample {
16
    public static void main(String[] args) {
17
​
18
        // создаем объект-кузнечик Bob
19
        Grig bob = new Grig();
20
        bob.name = "Bob";
21
        bob.length = 5d;
22
        bob.color = "brown";
23
​
24
        // создаем объект-кузнечик Alice
25
        Grig alice = new Grig();
26
        alice.name = "Alice";
27
        alice.length = 4.9d;
28
        alice.color = "green";
29
​
30
        
31
        bob.jump();     // output: Bob is jumping
32
        alice.jump();   // output: Alice is jumping
33
        
34
        bob.eat();      // output: Bob is eating grass
35
        alice.eat();    // output: Alice is eating grass
36
​
37
    }
38
​
39
}

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

xxxxxxxxxx
1
1
System.out.print("hello, onii-chan!")

Не сказал бы, что это совсем удачный пример, так как здесь затрагиваются статические поля, но не суть. Сначала вы обращаетесь к out и затем от него вызываете метод print()

По сути, out это статическое поле в классе System , который имеет несколько методов, в том числе и print (что такое статическое разберем позже)

Вернемся к листингу и разберем все по полочкам:

1. Сначала мы объявляем переменную bob с типом Grig. Замечаете определенные сходства со String (тут же и вопрос почему String нужно сравнивать через equals)?
2. А затем нам нужно создать объект из класса кузнечика и присвоить это значение к нашей переменной bob. Если с присвоением все понятно, то как создавать объекты из класса? По сути, также как и массивы - через оператор new . Его мы тоже разберем чуть позже.
3. Теперь как вы помните класс не может быть объектом, поэтому его поля не инициализированы то есть не имеют значений или же если быть корректнее - имеют значения по умолчанию. Если вы не помните или не знаете значения по умолчанию посмотрите предыдущий мануал. Значит, их нужно инициализировать, а сделали мы это очень тривиально и понятно.
4. Теперь можем попробовать вызвать методы класса, общаясь к ним через объекты (экземпляры)

Конструкторы

Согласитесь, неприятно и в общем-то неудобно задавать поля (свойства) класса вот так:

xxxxxxxxxx
4
1
Grig bob = new Grig();
2
bob.name = "Bob";
3
bob.length = 5d;
4
bob.color = "brown";

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

Листинг 1.2 SecondExample :

xxxxxxxxxx
30
1
public class SecondExample {
2
    static class Grig {
3
        double length;
4
        String color;
5
        String name;
6
        
7
        Grig(String grigsName, String grigsColor, double grigsLength){
8
            name = grigsName;
9
            color = grigsColor;
10
            length = grigsLength;
11
        }
12
        
13
        void jump(){ System.out.println(name + " is jumping"); }
14
        void eat(){ System.out.println(name + " is eating grass"); }
15
    }
16
​
17
    public static void main(String[] args) {
18
        // создаем объект-кузнечик Bob
19
        Grig bob = new Grig("Bob", "brown", 5d);
20
        
21
        // создаем объект-кузнечик Alice
22
        Grig alice = new Grig("Alice", "green", 4.9d);
23
​
24
​
25
        bob.jump();     // Bob is jumping
26
        alice.jump();   // Alice is jumping
27
        bob.eat();      // Bob is eating grass
28
        alice.eat();    // Alice is eating grass
29
    }
30
}

В основном все также, но сравните предыдущий пример инициализации полей, и вот такую:

xxxxxxxxxx
2
1
Grig bob = new Grig("Bob", "brown", 5d);
2
​

Здесь было бы уместно сказать : "Краткость - сестра таланта"

Не обращайте внимания на модификатор static перед объявлением класса, сейчас это к делу не относится! Вернемся к ней позже

Итак, если посмотреть изменения, то мы добавили что-то похожее на функцию, которое имеет такое же имя как у класса и к тому же не имеющий типа возвращаемого значения (даже void здесь не видно!):

xxxxxxxxxx
6
1
Grig(String grigsName, String grigsColor, double grigsLength){
2
    name = grigsName;
3
    color = grigsColor;
4
    length = grigsLength;
5
}
6
​

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

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

Так, Grig() - это метод или нет? Попробуйте использовать Grig() как обычный метод :)

У вас будет ошибка компиляции, потому что, Grig() - это действительно метод (это можно сказать по его схожести объявления в классе), но как вы могли заметить - он особенный .

Если коротко, то:

Конструктор - это специальный метод, который вызывается при создании нового объекта

Подождите! Мы же их вызывали раньше, а там ведь не было никаких методов!

xxxxxxxxxx
2
1
Grig bob = new Grig();
2
​

Да, если попробовать запустить его, добавив конструктор такого вида (который ничего не делает):

xxxxxxxxxx
4
1
Grig(){
2
    
3
}
4
​

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

Это можно увидеть в байт-коде через команду javap (пример из предыдущего мануала):

xxxxxxxxxx
8
1
public class Hello {
2
        public static void main(String ... args){
3
                for(int i=0;i<10;i++){
4
                        System.out.println("ITMO");
5
                }
6
        }
7
}
8
​

Компилим и смотрим его байт-код:

xxxxxxxxxx
23
1
Compiled from "Hello.java"
2
public class Hello {
3
  public Hello();       // <--- вот эта вот!
4
    Code:
5
       0: aload_0
6
       1: invokespecial #1    // Method java/lang/Object."<init>":()V
7
       4: return
8
​
9
  public static void main(java.lang.String...);
10
    Code:
11
       0: iconst_0
12
       1: istore_1
13
       2: iload_1
14
       3: bipush        10
15
       5: if_icmpge     22
16
       8: getstatic     #2    // Field java/lang/System.out:Ljava/io/PrintStream;
17
      11: ldc           #3    // String ITMO
18
      13: invokevirtual #4    // Method java/io/PrintStream.println:(Ljava/lang/String;)V
19
      16: iinc          1, 1
20
      19: goto          2
21
      22: return
22
}
23
​

Мы не объявляли никакого конструктора, но в скомпилированной версии он есть. Его также именуют "конструктором по умолчанию" или в документации Java "no-arg constructor"

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

Идем дальше, так в чем же заключается особенность конструктора?

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

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

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

К слову, в классе может быть несколько конструкторов, но они как и методы, должны иметь разную сигнатуру (входные аргументы).

Также обязательно посмотрите главу Блоки инициализации

Стек и куча

В этой главе речь пойдет о хранении данных в Java, в том числе про стек(stack) и кучу(heap). И перед тем как приступить к этой главе, я бы настоятельно рекомендовал получше изучить объекты и их работу с ними. Попробуйте, например, воссоздать объекты из реального мира.

Самое главное, вам нужно понять как работать с ними.

Далее, идет глава не самая легкая для понимания. Если вы впервые сталкиваетесь с ООП, то тем более. Но это не говорит о том, что эту главу можно пропустить. Почитайте. Таким образом, вы восполните свой словарный запас и хотя бы на каком-то (очень абстрагированном ) уровне поймете принцип работы ООП в Java.

Когда-то, я начал читать книгу Джоша Лонга "Java EE для предприятий" . Там рассказывалось про архитектуру приложений в Java EE, но не суть. Дело в том, что мой уровень не позволял понять полностью, о чем в этой книге говорится, но я все равно читал.

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

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

Ссылочные типы

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

Так, bob и alice (наши переменные) являются ссылками на объекты.

Существуют три разновидности ссылочных (reference) типов: тип класса, тип массива и тип интерфейса. Значения этих типов представляют собой ссылки на экземпляр класса, ссылки на массив и ссылки на имплементацию интерфейса соответственно (про интерфейсы еще далеко).

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

Тип reference может принимать специальное нулевое значение, так называемая ссылка на не существующий объект, которое обозначается как null. Значение null изначально не принадлежит ни к одному из ссылочных типов и может быть преобразовано к любому.

Конструкторы копирования

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

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

xxxxxxxxxx
21
1
class Point {
2
    private String name;
3
    public void setName(String name){
4
      this.name = name;
5
    }
6
​
7
    public String getName(){
8
      return this.name;
9
    }
10
}
11
​
12
// ...
13
​
14
Point p1 = new Point();
15
p1.setName("v1");
16
​
17
Point p2 = p1;
18
p2.setName("v2");
19
​
20
System.out.println(p1.getName()); // output: v2
21
System.out.println(p2.getName()); // output: v2

Изменение значения переменной name в p2 вызвало изменения в p1. Почему же это произошло?

Все из-за того, что p1 и p2 это ссылки на действительный объект, поэтому когда мы выполняем операцию присваивания со ссылками, то просто назначаем ссылку на объект. Если смотреть более детально, то сначала мы создали ссылку на объект Point с именем p1. Затем ссылке p2 присвоили ссылку p1. Теперь они оба указывают на один и тот же объект, в следствие чего изменения состояния через одну ссылку, несут изменения на другую.

Чтобы таких случаев не было, обычно создают так называемые "конструкторы копирования" - это такие конструкторы, которые на вход получают объект своего же класса и создают идентичный объект. Здесь существенное отличие в том, что при присваивании мы должны будем вызвать new в следствие чего создастся новый объект, а не ссылка.

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

xxxxxxxxxx
17
1
class Point {
2
    public Point() {}
3
    
4
    public Point(Point p){
5
      // конструктор копирования
6
      this.name = p.getName();
7
    }
8
​
9
    private String name;
10
    public void setName(String name){
11
      this.name = name;
12
    }
13
​
14
    public String getName(){
15
      return this.name;
16
    }
17
}

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

xxxxxxxxxx
9
1
Point p1 = new Point();
2
p1.setName("v1");
3
​
4
Point p2 = new Point(p1);
5
​
6
p2.setName("v2");
7
​
8
System.out.println(p1.getName()); // v1
9
System.out.println(p2.getName()); // v2

Здесь нужно быть осторожным, особенно когда у вас много полей.

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

Для решения такой проблемы есть несколько путей.

Во-первых, вы можете ссылаться на this() , то есть другой конструктор встроенный в ваш класс. Здесь вас может постигнуть неудача, если нету конструктора, который инициализирует все поля. Тогда вам все равно придется присваивать значения некоторым оставшимся полям вручную.

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

Области данных в рантайме

Регистр PC

Виртуальная машина Java может поддерживать множество потоков, выполняющихся одновременно. Каждый поток виртуальной машины Java имеет свой регистр pc (program counter). В каждый момент времени каждый поток виртуальной машины исполняет код только одного метода, который называется текущим методом для данного потока. Если метод платформенно независимый (т.е. в объявлении метода не использовано ключевое слово native) регистр pc содержит адрес выполняющейся в данный момент инструкции виртуальной машины Java. Если метод платформенно зависимый (native метод) значение регистра pc не определено.

Стек виртуальной машины Java

Каждый поток виртуальной машины имеет свой собственный стек виртуальной машины Java, создаваемый одновременно с потоком. Стек виртуальной машины хранит фреймы.

Стек виртуальной машины Java аналогичен стеку в традиционных языках программирования: он хранит локальные переменные и промежуточные результаты и играет свою роль при вызове методов и при возврате управления из методов. Поскольку работать напрямую со стеком виртуальной машины Java запрещено (кроме операций push и pop для фреймов), фреймы могут быть также расположены в куче. Участок памяти для стека виртуальной машины Java не обязательно должен быть непрерывным.

В следующих случаях виртуальная машина Java формирует исключение при работе со стеком:

• Если вычисления в потоке требуют памяти более чем позволено размером стека, виртуальная машина Java формирует исключение StackOverflowError.
• Если стек виртуальной машины Java допускает динамическое увеличение размера и попытка такого увеличения была выполнена, однако вследствие нехватки памяти не завершена успешно либо не достаточно памяти при инициализации стека при создании потока, то виртуальная машина Java формирует исключение OutOfMemoryError.

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

Куча

Виртуальная машина Java содержит область памяти, называемую кучей, которая находится в пользовании всех потоков виртуальной машины. Куча – это область памяти времени выполнения, содержащая массивы и экземпляры всех классов.

Куча создаётся при запуске виртуальной машины Java. Удаление неиспользуемых объектов в куче производится системой автоматического управления памятью (известной как сборщик мусора (к этой теме мы еще вернемся))

Объекты никогда не удаляются явно. Виртуальная машина Java не предполагает какого-либо одного алгоритма для системы автоматического управления памятью; алгоритм может быть произвольно задан разработчиком виртуальной машины в зависимости от системных требований. Куча может быть фиксированного размера, либо динамически расширяться и сужаться при удалении объектов.

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

Что и где хранится?

Мы рассмотрели два хранилища данных программы - стек и куча. Почему же их две и чем они отличаются?

Сначала, рассмотрим что такое стек и как она работает.

Во-первых, под стеком подразумевается некоторый принцип хранения данных и обращения к данным. Обычно здесь можно привести в пример стопку тарелок. Мы можем положить тарелку сверху и взять тоже только сверху. Такой принцип называется LIFO (Last-In-First-Out).

Согласитесь, довольно странный способ хранения информации, правда?

Давайте разберемся как он может пригодиться в нашей программе.

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

И также, обязательно к прочтению глава this - это просто необходимо знать.

Зачем нужен стек в Java?

Давайте внесем немножко Java в свою жизнь:

Листинг 2.1 DataExample.java

xxxxxxxxxx
17
1
public class App {
2
 public static void main(String[] args) {
3
     System.out.print("Enter a:");
4
     int a = Integer.parseInt(System.console().readLine());
5
     System.out.print("Enter b:");
6
     int b = Integer.parseInt(System.console().readLine());
7
     System.out.println("a+b=" + pow(a,b));
8
 }
9
 public static Long pow(int base, int exponent) {
10
     Long result = 1L;
11
     for (int i = 0; i < exponent; i++) {
12
          result *= base;
13
     }
14
     return result;
15
 }
16
}
17
​

Давайте сначала рассмотрим только метод main.

Какие у нас данные? Во-первых, это наши переменные a,b. Также, у нас входные данные args. Итого, мы насчитали 3, давайте это проверим, запустив команду:

xxxxxxxxxx
2
1
javap -v -c DataExample
2
​

Пропускаем оттуда пул констант и переходим сразу к этому:

xxxxxxxxxx
49
1
  public DataExample();
2
    descriptor: ()V
3
    flags: ACC_PUBLIC
4
    Code:
5
      stack=1, locals=1, args_size=1
6
         0: aload_0
7
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
8
         4: return
9
      LineNumberTable:
10
        line 4: 0
11
​
12
  public static void main(java.lang.String[]);
13
    descriptor: ([Ljava/lang/String;)V
14
    flags: ACC_PUBLIC, ACC_STATIC
15
    Code:
16
      stack=4, locals=3, args_size=1    // <----------- [ ЗДЕСЬ ] !!!
17
         0: getstatic     #2         
18
         3: ldc           #3         // String Enter a:
19
         5: invokevirtual #4                  
20
         8: invokestatic  #5                  
21
        11: invokevirtual #6                  
22
        14: invokestatic  #7                  
23
        17: istore_1
24
        18: getstatic     #2                  
25
        21: ldc           #8         // String Enter b:
26
        23: invokevirtual #4                  
27
        26: invokestatic  #5                  
28
        29: invokevirtual #6                  
29
        32: invokestatic  #7                  
30
        35: istore_2
31
        36: getstatic     #2                  
32
        39: new           #9          // class java/lang/StringBuilder
33
        42: dup
34
        43: invokespecial #10                 
35
        46: ldc           #11         // String a+b=
36
        48: invokevirtual #12                 
37
        51: iload_1
38
        52: iload_2
39
        53: invokestatic  #13         // Method pow:(II)Ljava/lang/Long;
40
        56: invokevirtual #14                 
41
        59: invokevirtual #15                 
42
        62: invokevirtual #16                 
43
        65: return
44
    
45
     public static java.lang.Long pow(int, int);
46
     // к методу pow мы вернемся позже
47
}
48
SourceFile: "DataExample.java"
49
​

Давайте обратим внимание на строку : stack=4, locals=3, args_size=1. Как видно из неё, мы оказались правы - 3 локальные переменные, в том числе одна из них это входные данные

Разберем значения этих трех свойств:

• stack - максимальный размер стека, необходимый для выполнения процедуры
• locals - локальные переменные
• args_size - входные данные. Есть парочка интересных моментов с ней, поэтому мы еще вернемся к этому параметру.

Теперь посмотрим на метод pow :

xxxxxxxxxx
37
1
  public static java.lang.Long pow(int, int);
2
    descriptor: (II)Ljava/lang/Long;
3
    flags: ACC_PUBLIC, ACC_STATIC
4
    Code:
5
      stack=4, locals=4, args_size=2
6
         0: lconst_1            
7
         1: invokestatic  #14   
8
         4: astore_2
9
         5: iconst_0
10
         6: istore_3
11
         7: iload_3
12
         8: iload_1
13
         9: if_icmpge     29
14
        12: aload_2
15
        13: invokevirtual #15  
16
        16: iload_0
17
        17: i2l
18
        18: lmul
19
        19: invokestatic  #14    
20
        22: astore_2
21
        23: iinc          3, 1
22
        26: goto          7
23
        29: aload_2
24
        30: areturn
25
      LineNumberTable:
26
        line 10: 0
27
        line 11: 5
28
        line 12: 12
29
        line 11: 23
30
        line 14: 29
31
      StackMapTable: number_of_entries = 2
32
        frame_type = 253 /* append */
33
          offset_delta = 7
34
          locals = [ class java/lang/Long, int ]
35
        frame_type = 250 /* chop */
36
          offset_delta = 21
37
​

Здесь для выполнения операций нужно четыре слота стека

Также, мы имеем два аргумента и еще две локальные переменные - result и i

Задачка для тех, кто умеет работать с ООП

xxxxxxxxxx
9
1
public class Test {
2
   public void plus(){
3
        int a = 1;
4
        int b = 3;
5
   }
6
 }
7
// stack=1, locals=3, args_size=1
8
​
9
​

Разберите в этом примере, почему в стеке операндов нам нужен лишь один слот и почему у нас три локальных переменных. (Подсказка: args_size тоже входит в их число)

Смотрите сюда, если вы не смогли узнать сами почему там args_size = 1 или сделали какое-нибудь предположение, следующая подсказка:

xxxxxxxxxx
9
1
public class Test {
2
   public static void plus(){
3
    int a = 1;
4
    int b = 3;
5
   }
6
 }
7
// stack=1, locals=2, args_size=0
8
​
9
​

Ответ

Во-первых, у нас есть две переменные a, b - уже две локальные переменные, а где же третья?

Третья переменная - это this (ссылка на экземпляр класса, если вы не знаете, что это, то разберем дальше). Вам могла помочь последняя подсказка, когда мы объявили метод plus статической.

Теперь, почему же в стеке нам нужен лишь один слот? - потому что нам нужно только сохранить 1 и присвоить переменной, затем нам эта единица в стеке уже не нужна, поэтому мы можем заменить её уже тройкой, а еще один слот нам уже не нужен.

Таинственный this и static

Что же это за this , который передается нестатическим методам?

this - это ссылка на экземпляр класса. Иначе, если мы создаем объект из нашего класса, то мы можем ссылаться на его экземпляр через переменную this , поэтому в байт-коде, как вы могли видеть, присутствует args_size=1.

Зачем нам это нужно?

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

Например, первый наш пример можно заменить таким образом:

xxxxxxxxxx
20
1
public class SecondExample {
2
    static class Grig {
3
        double length;
4
        String color;
5
        String name;
6
        
7
        Grig(String name, String color, double length){
8
            this.name   = name;
9
            this.color  = color;
10
            this.length = length;
11
        }
12
        
13
        // some methods
14
    }
15
​
16
    public static void main(String[] args) {
17
        // something actions
18
    }
19
}
20
​

Такой код читается лучше и понятнее.

Разумеется, это не единственное предназначение ссылки this

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

Допустим, у вас есть метод который принимает пользовательский тип:

xxxxxxxxxx
2
1
public void func(MyClass clazz){ /* something actions */};
2
​

Использовать её не составляет труда:

xxxxxxxxxx
3
1
MyClass ex = new MyClass();
2
func(ex);
3
​

Но вдруг мы хотим использовать её внутри реализации нашего класса.

То есть, у нас есть некоторый метод в MyClass, который должен вызывать функцию func , передавая экземпляр самого себя. Без this это практически было бы нереализуемо, по крайней мере, очень сложно.

А здесь мы можем использовать:

xxxxxxxxxx
6
1
public MyClass{
2
    public void myMethod(){
3
        func(this);
4
    }
5
}
6
​

Возвращаясь к хранениям данных, то мы уже знаем, что этому методу неявно передается ссылка на this (см. главу "Зачем нужен стек")

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

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

xxxxxxxxxx
7
1
class MyClass {
2
    public static void func(int a){ /*something action...*/};
3
}
4
​
5
// еще где-то в исходниках:
6
MyClass.func(12);
7
​

Как видите, мы не создавали экземпляр класса MyClass, а сразу обратились к методу.

Статические поля или методы объявляется с ключевым словом static

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

Давайте рассмотрим пример:

Листинг 3.1 StaticExample.java

xxxxxxxxxx
40
1
public class StaticExample {
2
    static class MyClassNonStatic {
3
        int a = 0;
4
        void inc(){
5
            a++;
6
        }
7
    }
8
​
9
    static class MyClassWithStatic {
10
        static int a = 0;
11
        void inc(){
12
            a++;
13
        }
14
    }
15
​
16
    public static void main(String ... args) {
17
        MyClassNonStatic a = new MyClassNonStatic();
18
        MyClassNonStatic b = new MyClassNonStatic();
19
        a.inc();
20
        b.inc();
21
        
22
        System.out.println(a.a + " " + b.a);    // 1 1
23
        
24
        a.inc();    
25
​
26
        System.out.println(a.a + " " + b.a);    // 2 1  
27
​
28
        MyClassWithStatic c = new MyClassWithStatic();
29
        MyClassWithStatic d = new MyClassWithStatic();
30
        
31
        c.inc();
32
        d.inc();
33
        System.out.println(c.a + " " + d.a);    // 2 2
34
​
35
        c.inc();
36
        System.out.println(c.a + " " + d.a);    // 3 3
37
    }
38
}
39
​
40
​

Здесь мы создаем два класса: MyClassNonStatic - без статического поля, MyClassWithStatic - со статическим полем.

Из примера все видно - наглядно и просто.

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

Практика: попробуйте в классе MyClassNonStatic объявить метод func статическим и обратится к полю "а"

Преимущество стека и области видимости

У многих мог возникнуть вопрос, а почему мы используем стек?

Для этого рассмотрим еще один термин области видимости.

У каждой переменной есть область видимости - область, внутри которой можно обращаться к переменной.

Простой пример,

xxxxxxxxxx
10
1
public class MyClass {
2
    static void func(){
3
        int a = 2;
4
    }
5
    public static void main(String ... args){
6
        func();
7
        System.out.println(a);  // error: cannot find symbol
8
    }
9
}
10
​

Здесь мы пытаемся обратится к переменной a из другого метода, но получаем ошибку, так как область видимости переменной a ограничена блоком кода функции func, иными словами, переменная объявленная внутри функции func может использоваться только внутри неё самой.

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

Теперь посмотрим пример того, как область видимости может содержать другие области видимости:

xxxxxxxxxx
9
1
public class MyClass {
2
    
3
    static int a = 5;
4
    
5
    public static void main(String ... args){
6
        System.out.println(a);  // 5
7
    }
8
}
9
​

Область видимости main содержится внутри области видимости тела класса, поэтому мы можем использовать переменную a.

Выходит что мы не можем объявить переменную с именем a? Нет, мы можем её объявить, и тогда мы будет обращаться уже к ней - тут все дело в том, как JVM ищет нужную переменную.

Сначала мы ищем эту переменную в своей области видимости, где она объявлена, если мы не находим там, то ищем в той области, где находится наша область и т.д. Если мы ничего не найдем, то компилятор выведет ошибку cannot find symbol.

Как это все организовано?

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

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

Да-да, в потоке программы есть несколько стеков, но углубляться мы не будем, так как лишь хотим узнать как хранятся данные нашей программы.

Итак, что такое стек операндов, который мы ранее разбирали? Он используется при выполнении инструкций байт-кода.

Например, когда мы хотим объявить переменную

xxxxxxxxxx
2
1
int i;
2
​

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

xxxxxxxxxx
7
1
    // Положить 0 наверху стека операнодов:
2
    0:  iconst_0
3
    
4
    // вытолкнуть верхнее значение из стека операндов 
5
    // и сохранить как локальную переменную 1
6
    1:  istore_1    
7
​

После этой операции в стеке операндов не остается значений - все лишнее и не используемое в конкретный момент - убирается из стека операндов.

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

xxxxxxxxxx
8
1
public class Test {
2
   public static void plus(){
3
    int a = 1;
4
    int b = 3;
5
   }
6
 }
7
// stack=1, locals=2, args_size=0
8
​

Возвращаемся к листингу 2.1:

Листинг 2.1 DataExample.java

xxxxxxxxxx
17
1
public class DataExample {
2
 public static void main(String[] args) {
3
     System.out.print("Enter a:");
4
     int a = Integer.parseInt(System.console().readLine());
5
     System.out.print("Enter b:");
6
     int b = Integer.parseInt(System.console().readLine());
7
     System.out.println("a+b=" + pow(a,b));
8
 }
9
 public static Long pow(int base, int exponent) {
10
     Long result = 1L;
11
     for (int i = 0; i < exponent; i++) {
12
          result *= base;
13
     }
14
     return result;
15
 }
16
}
17
​

Упростим себе представление стека (не стек операндов) и посмотрим что там происходит:

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

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

Здесь важно еще то, что аргументы функции (base, exponent) являются отдельными местами в памяти. Может показаться, что раз в нашей программе мы передаем в функцию pow a и b, то внутри неё мы будем общаться с этими местами в стеке.

Это мнение ошибочно. Код вызываемой функции pow не может менять переменные внешней функции main, поэтому когда при исполнении программа доходит до строки с вызовом функции pow(a, b), значения, которые хранятся в соответствующих местах копируются в места выделенные под base и exponent. В момент, когда внутренняя функция заканчивает свою работу, то место в стеке используемое под неё очищается и может быть использовано дальше. Например, для вызова следующей функции.

Давайте подробнее остановимся на моменте с очищением места в стеке.

Простой код:

xxxxxxxxxx
11
1
public class App {
2
   public static void main(String[] args){
3
       int a = 3;
4
       int b = 4;
5
       int c = func1(a, b);    
6
       c++;
7
       d = func2(c, a);
8
   }
9
    // something methods
10
}
11
​

Допустим, что программа сейчас исполняет func1 внутри метода main .

Стек будет выглядеть следующим образом:

Очень важно, понимать, что в этот момент времени в стеке нет ничего, что имеет отношение к функции func2.

В тот момент, когда мы войдем в func2 часть стека используемая под func1 будет стёрта, а на её месте будет func2

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

Наконец-то мы закончили со стеком, а теперь осталась куча. Что же это такое и как она работает?

Ссылочные типы данных и зачем нужна куча в Java?

Ранее в аргументах функции мы использовали простые типы данных, а что если нам необходимо использовать некоторые структуры?

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

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

А что если функции передавать не само значение, а адрес, где оно лежит? К сожалению или к счастью, стек не предоставляет операции, где мы можем получить доступ к определенному месту в нем. К тому же, мы позволим какой-то функции func1 влезть в данные функции func2 , что не есть хорошо.

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

Таким образом, использование стека не предвещает ничего хорошего.

Тогда нам нужно еще одно хранилище данных, не имеющее вышеописанных минусов.

Для решения этих проблем было предложено сделать отдельную область памяти и назвать её кучей (heap). Куча будет хранить какие-то долгоживущие объекты. Например нашу информацию о людях или о котиках.

Теперь давайте представим, что у нас есть такой код на Java:

xxxxxxxxxx
13
1
class Cat {
2
   String name;
3
   int age;
4
}
5
 
6
class App {
7
   public static void main(String[] args) {
8
      int number = 4;
9
      String vasya = "Барсик"; // Внешность обманчива :)
10
      Cat myCat = new Cat(vasya, number);
11
   }
12
}
13
​

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

Исходя из всего вышеописанного, не трудно догадаться, что созданный нами объект Cat будет хранится в куче по какому-то адресу памяти. Собственно, этот адрес будет хранится как переменная myCat, иными словами myCat только указывает на место хранения объекта и не хранит его значения.

Выглядит это так:

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

К слову, была популярная задачка про сравнение String. Я её слегка изменил, но суть не изменилась:

xxxxxxxxxx
14
1
public class Task {
2
  public static void main(String ... args){
3
      String s1 = "123";
4
      func(s1);
5
  }
6
​
7
  static void func(String s1){
8
    String s2 = "123";
9
    System.out.println(s1 == s2);           // false
10
    System.out.println(s1 + " == " + s2);   // 123 == 123
11
    
12
  }
13
}
14
​

Раньше я уже упоминал про String - это не примитивный тип данных.

Стринги в Java это отдельная тема разговоров, где используются различные паттерны для их оптимизации (такие как String pool). Про них можно почитать в javarush.

Вернемся к куче.

Давайте представим, что у нашего кота появилась дополнительная информация о его владельце (отдельное поле в классе Cat), которая представлена информацией об имени и количестве денег у него:

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

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

Ластхит по стеку и куче

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

Парадигмы ООП

Давайте оставим байт-коды и прочее углубление в JVM и поднимемся на уровень выше - уровень абстракций.

В этой главе рассмотрим три основные парадигмы (абстракцию смотрите сами).

Инкапсуляция

Определение из википедии:

Инкапсуляция — в информатике упаковка данных и функций в единый компонент.

Вроде бы верно, но это что-то слишком общее, что нельзя считать нормальным ответом.

Посмотрим, что пишут в методичке кафедры ВТ:

Инкапсуляция - сокрытие данных внутри объекта и обеспечение доступа к ним с помощью общедоступных методов.

Это уже похоже на более внятный ответ. Разберем его получше.

Во-первых, следовало бы оговориться, что такие парадигмы ООП как инкапсуляция и полиморфизм - не относятся только к ООП, это лишь её парадигмы. Но здесь мы будем разбирать именно в контексте ООП.

Зачем нам нужно скрывать данные объекта?

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

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

Приведу, очень простой пример, где инкапсуляция может помочь:

xxxxxxxxxx
18
1
class MyClass{
2
    String val = "default";
3
​
4
    void printValLength(){
5
        System.out.println(val.length());
6
    }
7
​
8
}
9
public class Main {
10
    public static void main(String[] args) {
11
        MyClass a = new MyClass();
12
        a.printValLength();   // 7
13
​
14
        a.val = null;         // произвольно меняем значение
15
        a.printValLength();   // java.lang.NullPointerException
16
    }
17
}
18
​

Здесь, как вы видите, мы создаем класс с полем val, значение которой любая внешняя система может изменить. Как мы видим, в методе printValLength мы вызываем метод legnth , чтобы узнать длину строки. Но мы не можем знать, что значение val не равен null и поэтому, когда мы выполняем эту функцию, то есть шанс получить NPE(NullPointerException) .

xxxxxxxxxx
23
1
class MyClass{
2
    private String val = "default";
3
​
4
    void printValLength(){
5
        System.out.println(val.length());
6
    }
7
​
8
    public void setVal(String val){
9
        if (val == null) this.val = "";
10
        else this.val = val;
11
    }
12
​
13
}
14
public class Main {
15
    public static void main(String[] args) {
16
        MyClass a = new MyClass();
17
        a.printValLength();   // 7
18
​
19
        a.setVal(null);      
20
        a.printValLength();   // 0
21
  }
22
}
23
​

Здесь мы добавили проверку на null и можем гарантировать, что val не будет равен null.

Как же мы этого добились?

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

Во-вторых, мы создали сеттер - setVal. По конвенции Java, следует называть сеттеры так:

set<ИМЯ-ПОЛЯ>, как сделали мы (в camelCase). Таким образом, другим программистам использующим ваш код или библиотеку, станет легче ориентироваться и он сразу будет знать как называется переменная, значение которой он изменяет.

По сути, мы сделали метод, который изменяет внутреннее состояние объекта. Здесь важно то, что объект сам изменяет своё состояние (совокупность свойств). То есть, изменяя переменную через такую функцию (сеттер), мы можем быть уверены, что никакой ошибки не будет (как например, NPE).

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

К слову, есть обратное действие сеттеру - геттер, когда мы хотим не изменить значение поля, а получить его значение. Ведь, мы все равно не можем обратится к private переменной. Поэтому необходимо будет создать и метод, который возвращает значение поля:

xxxxxxxxxx
29
1
class MyClass{
2
    private String val = "default";
3
​
4
    void printValLength(){
5
        System.out.println(val.length());
6
    }
7
​
8
    public void setVal(String val){
9
        if (val == null) this.val = "";
10
        else this.val = val;
11
    }
12
​
13
    public String getVal(){
14
        return this.val;
15
    }
16
​
17
}
18
public class Main {
19
    public static void main(String[] args) {
20
      
21
        MyClass a = new MyClass();
22
        a.printValLength();   // 7
23
        System.out.println(a.getVal()); // default
24
​
25
        a.setVal(null);;      
26
        a.printValLength();   // 0
27
  }
28
}
29
​

Модификаторы доступа

Будьте бдительны! (с) Цопа

Есть 4 вида доступа ко внутренним свойствам класса, которые мы рассмотрели недавно:

• package-private(package-visible, default) - модификатор доступа по умолчанию. Его нельзя прописать вручную, так как в этом нет необходимости - можно просто не указывать модификатор доступа. Ограничивает область видимости пакетом класса, внутри которого он объявлен.
• public - неограниченная область видимости. Метод, поле или класс объявленный с этим модификатором можно использовать в любом месте проекта, если класс в котором он объявлен, также является публичным.
• private - ограничение области видимости в рамках тела класса.
• protected - ограничение области видимости внутри пакета и потомками, наследующих от класса, в котором он объявлен

Тут нужно быть очень внимательным, так как даже, если ваш метод объявлен как public, а класс в котором он находится private, то вы все равно не сможете получить к нему доступ.

Например,

xxxxxxxxxx
7
1
class Point {
2
    private class A {
3
      public void foo(){
4
        System.out.println("VT: krya krya!");
5
      }
6
    }
7
}

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

Также вас могут смутить модификаторы доступа в конструкторах:

xxxxxxxxxx
10
1
class Point {
2
    
3
    public Point(){}
4
    
5
    protected Point(int a){}
6
​
7
    Point(int a, int b){}
8
​
9
    private Point(int a, String s){}
10
}