Hello World на Java. Часть 3 - расчленение Hello World :)

Чтобы не было скучно, я решил расчленить программу, а вернее класс HelloWorld на два класса Hello.java и Word.java, чтобы показать как можно чуть сделать короче долгий оператор вывода на печать, а во вторых, несколько позже, показать как создавать комментарии документации. И как эти комментарии могут помочь в сопровождении кода.

Ну а пока перейдем к коду. И так в студий Hello.java

В данном классе мы используем другой класс Word.java. Как видите оператор вывода на консоль стал чуть короче. Это так сказать примитивный пример библиотеки вывода на консоль.

Теперь посмотрим класс Word.java

А вот он и наш длинный оператор вывода на консоль (System.out.println()).

В данном случае оба файла Hello.java и Word.java находятся в одном каталоге. А их откомпилированные файлы с расширением .class Eclipse складывает в папочку bin.

Как видно на следующем примере, если мы запустим Hello.class на выполнение из каталога bin, то все отработает нормально.

Поскольку второй класс Word.class необходимый для работы Hello.class находится в том же каталоге. А JRE по умолчанию ищет необходимые классы в том же каталоге, что и запускаемый на выполнение класс.

Теперь переместим Hello.class в корневой каталог проекта и попробуем запустить его.

И вылетела куча ошибок. Это произошло потому, что JRE не знает где искать класс Word.

Вот мы и подошли к важному понятию classpath.

Так вот если мы укажем JRE где искать классы необходимые для работы классу Hello.class, то все сработает нормально. Для этого используем ключ –classpath.

Дадим команду java -classpath bin Hello

Как видим все заработало нормально.

Hello World на Java. Часть 2 - аргументы командной строки.

Чтобы стала более понятна эта часть строки программы HelloWorld.java

public static void main(String[] args)

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

И так немного модифицируем нашу программу:

public class HelloWorld {
      public static void main(String[] args) {
          
           System.out.println("Hello World!");

           //выводим количество аргументов заданных в командной строке
           System.out.println("Всего аргументов в командной строке: "+args.length);

       }
}

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

Запустим ее на исполнение из командной строки

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

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

Теперь у нас было передано два аргумента (слова One и Two).

Все передаваемые аргументы помещаются в массив строк args, а поле length содержит количество элементов массива (это упрощенное объяснение, но пока достаточно).

Запускать программу с аргументами можно прямо и из Eclipse. Делаем РАЗ и ДВА

Далее видим это

Обращаем внимание что в параметрах запуска стоит наш проект и его главный класс (содержащий метод main) и щелкаем по вкладке Arguments

Вводим аргументы и жмем кнопку Run и получаем на консоли Eclipse следующий вывод.

Теперь чуток еще усложним нашу программу, чтобы с аргументами стало все еще более понятно.

Теперь наша программа стала чуточку умней, она будет приветствовать переданные ей аргументы

Запустим ее из командной строки чтобы было понятнее

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

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

Все эти операторы будут рассмотрены позже. Мы же пока перейдем к следующей мутации мега программы HelloWorld.java

Вперед! Нас ждут великие открытия!

Первая программа на Java – Hello World! Часть 1.

Даже путь в тысячу ли начинается с первого шага. (千里之行，始于足下).

Традиция использования фразы «Hello, world!» в качестве тестового сообщения в первой программе на изучаемом языке была введена в книге «Язык программирования Си» Брайана Кернигана и Денниса Ритчи, опубликованной в 1978 году.

Не будем нарушать эту хорошую и устоявшуюся традицию и создадим нашу первую программу Hello World на Java.

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

Сейчас же мы создадим и разберем из чего состоит простейшая программа на Java.

Сразу стоит отметить, что в Java все является объектом, исключение составляют только примитивные типы. Что это такое и с чем едят мы рассмотрим чуть позже. А пока программу в студию!

На этот раз я создал программу “Hello World” в Eclipse, дабы дальше было проще работать над ее будущими мутациями.

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

Java до мозга костей объектно-ориентированный язык.

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

И так быстренько пробежимся по строчкам программы чтобы понять что они значат.

Строка

public class HelloWorld

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

Модификатор public означает что класс доступен другим классам и программам извне. О модификаторах доступа будем говорить позже.

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

В следующей строке идет объявление метода класса

public static void main(String[] args)

Модификатор public мы уже упоминали, модификатор static означает, что данным метод main, может быть вызван без создания экземпляра класса. Пока все это может быть не понятно, но все равно топаем дальше. Модификатор void означает что наш метод main ни чего не возвращает, то есть не возвращает ни каких значений. Единственный метод нашей программы называется main – это точка входа в программу, то есть то от куда она начинает исполнятся.

Далее идут параметры (String[] args) которые принимает метод main. Это массив строк. Сюда передаются параметры (аргументы) командной строки. Мы это рассмотрим чуть позже.

Следующая строка

System.out.println("Hello World!")

выводит фразу Hello World на консоль. Но поскольку Java у нас вся сплошь и рядом использует объекты, то в данном случае происходят вещи, которые мы вкратце рассмотрим, но скорей всего не все и не всем будет понятно. Но чтобы в мозгу осело можно кратко рассказать.

Строка System.out.println означает, что в классе System, входящем в стандартную библиотеку Java, существует константа с именем out, содержащая указатель на экземпляр одного из классов Java, в данном случае класса PrintStream, в котором есть метод println(). Все это, пока, может звучать как заклинания Гарри Поттера, но позднее все станет ясно и понятно. Такова магия Java!

Действие метода println() заключается в выводе заданного ему аргумента в выходной поток, связанный обычно с выводом на экран текстового терминала. После вывода курсор переходит на начало следующей строки экрана, на что указывает окончание ln, само слово println — сокращение слов print line. В составе стандартной библиотеки Java есть и метод print(), оставляющий курсор в конце выведенной строки.

Приведу кусочек скрина из класса System (файл System.java) стандартной библиотеки:

Тут как раз таки показана наша константа out. Далее еще немного посмотрим на класс PrintStream:

И на его метод println() c аргументом String:

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

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

Отцы основатели Java озаботились этим на самых ранних стадиях развития языка и выпустили такой документ, который называется "Code Conventions for the Java Programming Language". Я его уже не однажды упоминал в блоге. Так вот, опять же рекомендую с ним настоятельно ознакомится. Некоторые правила из него приведу тут, вдруг кто не умеет читать на ангельском языке:

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

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

Но вообще, 24 страницы данного документа может осилить каждый.

Ну и теперь обещанные видео по мега программе HelloWorld. Некоторые я уже публиковал, а некоторые нет.

Hellow World in Java. IntelliJ IDEA

Hello World in Java. Eclipse

Hello World in Java.

Hello World in Java.

Следующее видео просто для коллекции и хохмы. Какой-то отрывной человечек его создал

Hello World in Java с реальным пацанчиком :)

Hello World in Java. IntelliJ IDEA

Hello World in Java. NetBeans

Hello World in Java.

Hello World in Java.

Ну я думаю более чем достаточно уже видео смотреть не пересмотреть

Лексическая структура Java. Часть 3 - практика

Теперь немного попрактикуемся по всем пунктам предыдущей части.

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

Внимание! Все предлагающиеся ниже исходные тексты программ доступны на bitbucket во всех вариантах. Чтобы увидеть разные варианты, смотрите историю изменений файлов в Git.

Теперь переходим к комментариям. На скрине представлены три вида комментариев в Java: однострочные, блочные и комментарии документации.

Обратите внимание, что блочный комментарий может быть и без звездочек в начале каждой строки, а так же занимать только часть строки.

Однострочный комментарий может располагаться в любой части строки и вся строка от начала комментария и до конца считается комментарием.

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

Ну и для полноты картины покажем что выводит эта программа на консоль

Теперь переходим к лексемам языка Java. И начинаем с идентификаторов. На скрине исходника оранжевым цветом подсвечены идентификаторы. Обратите внимание что идентификатор 5Int является не правильным и поэтому он закомментирован. Если его раскомментировать, то среда разработки покажет ошибку. Так же и компилятор выдаст ошибку.

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

Ключевые слова Java в данном случае подсвечены бордовым цветом.

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

Запустим программу и посмотрим на ее вывод:

В данном случае я запустил программу прямо из Eclipse.

Таким образом мы уже рассмотрели и разделители с операторами. Разделители это всевозможные скобки, точки и т.п., а операторы это, в данном случае, оператор присваивания = и оператор конкатенации строк +. Естественно что тут они рассмотрены не в полном объеме, так как их лучше рассматривать и изучать в совокупности с типами данных, классами и операциями над ними.

Это просто небольшая практика для закрепления материала по лексической части Java.

Лексическая структура Java. Часть 2 – составляющие части Java программы

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

Сразу стоит отметить, что Java чувствительна к регистру символов. Поэтому, к примеру, идентификаторы demo, Demo, DEMO и т.п. не являются в Java одним и тем же идентификатором, это все РАЗНЫЕ идентификаторы.

Это надо усвоить сразу, раз и на всегда!

 

Условно код программы на Java можно условно разделить на три части:

• Незначащие символы
• Комментарии
• Лексемы

Незначащие символы – символы не служащие для генерации какого-либо кода или данных

• пробелы
• табуляция
• ограничители строк (LF – символ новой строки, CR – возврат каретки, CR+LF)

Комментарии – служат для пояснения текста программы или генерации документации, не генерируют ни какой исполняемый код

• однострочные // текст комментария
• блочные /* текст комментария */
• комментарии документации /** документация */

Лексемы – это элементарные конструкции языка, из которых транслятор javac генерирует исполняемый байт-код, который может быть выполнен виртуальной машиной Java.

Незначащие символы и комментарии являются разделителями для лексем, но ни как не влияют на скомпилированный код.

В Java существуют следующие виды лексем:

• Идентификаторы
• Ключевые слова
• Литералы
• Разделители
• Операторы

Идентификатором является любое символическое имя какого-либо элемента в Java программе. Идентификатором может выступать имя класса, метода, параметра и переменной. Идентификатор должен начинаться с буквы, символа подчеркивания (_) или с валютного символа Unicode (например, $, £, ¥). За начальным символом может следовать любое количество букв, цифр, символов подчеркивания или валютных символов. Следует помнить, что Java использует множество символов Unicode, куда входит довольно много букв и цифр, не входящих во множество символов ASCII. Ниже представлены разрешенные идентификаторы:

i
engine3
theCurrentTime
the_current_time
θ
переменная

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

В состав идентификатора может входить любой разрешенный символ UTF-8, именно поэтому идентификаторы переменная и θ являются допустимыми идентификаторами в Java. Хотя использование не-ASCII идентификаторов является допустимым в Java, но обычно этим не пользуются и предпочитают символы латинского алфавита.

Еще одно существенное ограничение: в качестве идентификаторов нельзя применять ключевые слова и литералы (такие как true, false и null), являющиеся частью самого языка Java.

На заметку! Начиная с версии JDK 8, сам знак подчеркивания не рекомендуется употреблять в качестве идентификатора.

Ключевые слова языка Java сейчас насчитывают 50 слов ко­торые вместе с синтасисом операторов и разделителей образуют основу языка Java. Их нельзя использовать ни в качестве идентификаторов, ни для обозначения имен переменных, классов или методов.

Кроме ключевых слов, в Java зарезервированы так же слова true, false и null, являющиеся литералами. Они представляют значения, определенные в специикац языка Java. Их, так же нельзя использовать для обозначения имен переменных классов и т.п.

Обратите внимание, что const и goto являются зарезервированными словами, но не представляют собой часть языка Java.

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

• целый (integer) – по умолчанию имеет тип данных int
  примеры: 55 (десятичное), 555_555 (десятичное 555555, этот формат введен в Java 7),
  7000000000L (десятичное тип long, ASCII символ L в любом регистре)
  07 (восьмеричное начинается с нуля, цифры 8 и 9 запрещены),
  0xFF, 0XFF или 0xff (шестнадцатеричное, ASCII символ X в любом регистре, шестнадцатеричные значения A, B, C, D, Е и F, так же могут записывать в любом регистре),
  0b0101 или 0B0101 (двоичное, ASCII символ B в любом регистре, введен в Java 7) 
• вещественный (floating-point) – по умолчанию имеет тип данных double
  примеры: 5.5 (тип double), 5.5f или 5.5F (тип float, ASCII символ F в любом регистре),
  5. (5.0 тип double), .24f (0.24 тип float), 0.125e4 или 0.125E4 (тип double, ASCII символ Е в любом регистре), 1600e-2 (тип double)
• логический (boolean) – пример: true или false
• символьный (charaster) – может содержать один символ из набора Unicode, заключенный в одинарные кавычки, специальную последовательность (управляющие символы) начинающуюся со знака косой черты – \ 
  Управляющие символы:
  \b – backspase BS - забой
  \t – horizontal tab HT - табуляция
  \n – line feed LF – конец строки
  \f – form feed FF – конец страницы
  \r – carriage return CR – возврат каретки
  \” – двойная кавычка
  \’ – одинарная кавычка
  \\ – backslash \ – обратная косая черта
  \uxxxx – символ Unicode, где xxxx цифровой код символа Unicode
  \xxx – символ кодовой таблицы Latin-1, где xxx восьмеричный код символа Latin-1
  примеры: ‘A’, \u0950, \b, \t, \333 и т.п.
• строковый (string) – всегда имеет тип String и ссылается на экземпляр класса String. Состоит из нуля или большего количества символов, каждый символ может быть предствлен Unicode последовательностью, так же может содержать строковый литерал.
  примеры: “”, “string”, “symbol \u0950”, “test \t test” 
• null-литерал (null-literal) – это литерал ссылочного типа, причем эта ссылка null ни куда не ссылается.
  пример: null

Логические литералы true и false, а так же null литерал являются зарезервированными словами в Java. Их относят к литералам, поскольку с их помощью задаются значения для переменных или ссылок.

Так же тут были затронуты разные типы данных (int, long, double и float), которые мы рассмотрим чуть позже, в другом разделе.

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

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

Более подробно мы их рассмотрим чуть позже.

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

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

Лексическая структура Java. Видео 1

Лексическая структура Java. Видео 2

Лексическая структура Java. Видео 3

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

Лексическая структура Java. Часть 1 – Unicode и другие кодировки

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

Сразу скажу, что программы на Java лучше создавать в кодировке Unicode (UTF-8), так как если вы будете писать их в других кодировках, то могут быть проблемы с отображением символов национальных алфавитов, отличных от латинского. Хотя они могут быть даже если вы их пишете в Unicode и сейчас мы в этом убедимся.

Теперь в бой! Посмотрим все на примерах. Возьмем классическую программу Hello World и допишем в нее строчку выводящую сообщение “Привет Мир!” на русском языке. Текст программы запишем как и полагается в кодировке UTF-8.

И теперь откомпилируем ее с параметрами по умолчанию. То есть просто дадим команду

javac HelloWorld.java

И выполним нашу программу командой

java HelloWorld

И смотрим результат

Текст на русском языке “Привет Мир!” отобразился кракозябрами. Что же случилось? Почему такая не справедливость? Ведь мы же записали текст программы в Unicode! Сделали все как положено!

Но дело в том, что компилятор javac, по умолчанию, компилирует программу в кодовой странице операционной системы.

Теперь откомпилируем эту же программу, но уже укажем в какой кодировке у нас исходный код программы c помощью следующей команды

javac -encoding utf8 HelloWorld.java

И запустим программу на выполнение

Ну вот теперь русский текст “Привет Мир!” отображается правильно.

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

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

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

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

И так я создал такую же простую программу как “Hello World”, но в разных кодировках (866, 1251 и UTF-8).

Код абсолютно одинаковый только создан в разных кодировках.

Теперь скомпилируем их с параметрами по умолчанию и запустим.

Но сперва отметим такую команду консоли Windows как chcp. Про нее мало кто знает. Она отображает текущую кодовую страницу консоли, а так же может ее устанавливать.

Посмотрим текущую кодовую страницу консоли, откомпилируем программу Example866.java и запустим ее.

Как видим вывод русского текста не правильный, одни кракозабры, зато слово Java и восклицательный знак (!) вывелись правильно. Это происходит потому что Unicod код латинских символов (первых 128) совпадает с ASCII и Latin-1. Поэтому если в вашей программе вы используете только латинский алфавит для отображения строк и т.п., то можно не беспокоится. Все всегда будет отображаться корректно, но с символами других алфавитов это не так.

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

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

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

И так в чем же проблема? А проблема в том, что как уже я говорил, по умолчанию компилятор использует кодовую страницу операционной системы, в нашем случае это CP1251, так как Windows у нас настроен на использование кириллической кодировки CP1251.

Произошло следующее, компилятор, перевел символы кодировки 866 в UTF-8, полагая что это кодировка CP1251. Поэтому в данном случае, как бы мы не меняли кодовую страницу мы уже не получим правильного отображения русского текста. Давайте зададим для консоли кодировку cp1251 и посмотрим что будет.

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

Чтобы исправить эту ситуацию надо откомпилировать программу Exemple866.java с использованием кодовой страницы 866. И чтобы проверить это вернем консоли кодировку по умолчанию 866, дабы все было по честно по правилам.

Теперь у нас все правильно выводится.

Далее откомпилируем программу Example1251.java и запустим ее. Ее можно компилировать с параметрами по умолчанию, так как javac будет использовать для нее кодировку 1251, что нам и нужно.

Все тоже отображается правильно. Ну и тоже самое с программой ExampleUTF8.java

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

Теперь небольшой ликбез об UTF8. Данная кодировка использует ДВА БАЙТА для хранения кода символа, что позволяет представить 65535 символов – это покрывает почти все символы всех языков Земли. Кодировка ASCII может представить только 256 символов.

Теперь посмотрим нашу самую русскую букву Ё в кодировке 1251 (ASCII) и в кодировке UTF8.

В кодировке 1251 ASCII буква Ё представлена одним байтом (A8).

В кодировке UTF-8 буква Ё представлена двумя байтами (D0 81).

И теперь посмотрим бинарные файлы классов Example866.class и Example1251.class

Как видим наш текст на русском “Это Java программа!” в обоих бинарниках отображается одинаково, хотя один из них сделан из исходника в кодировке 866, а другой в кодировке 1251. Это произошло потому, что компилятор javac, перевел символы из этих кодировок в кодировку UTF-8.

Так же я подчеркнул байты CA FE BA BE – это так называемое магическое число java. По нему виртуальная машина определяет что перед ней именно класс Java, а не что-то еще. Эта комбинация присутствует в начале всех откомпилированных  файлов классов Java с расширением .class.

Ну и чтобы все было более наглядней приведу еще одни скрин сравнения этих файлов

 

Так вот! К чему я это все?

Граждане, храните деньги в сберегательной кассе!

Пишите исходники в UTF-8. Надежно, выгодно, удобно.

И да! Храните ваши исходники на bitbucket.org – надежно, выгодно, удобно!

P.S. Все исходники примеров тут: https://bitbucket.org/n0tb0dy/studyingjava