Java разработка приложений для windows

Время на прочтение
13 мин

Количество просмотров 80K

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

Если вы не знаете Electron, то это по сути веб-браузер (Chromium) в котором работает только ваше веб-приложение… словно настоящая десктопная программа (нет, это не шутка)… это даёт возможность использовать веб-стек и разрабатывать кросс-платформенные десктопные приложения.

Самые новые, хипстерские десктопные приложения в наше время сделаны на Electron, в том числе Slack, VS Code, Atom и GitHub Desktop. Необычайный успех.

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

Десять лет назад невозможно было себе представить, что стек веб-технологий можно использовать для создания десктопного приложения. Но наступил 2017 год, и много умных людей полагают, что Electron — отличная идея!

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

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

Я решил взглянуть и создать реальное приложение на одной из этих технологий.

Альтернативы Electron

Ели вы не возражаете, что несколько групп разработки будут создавать разные версии приложения под разные ОС, то варианты выглядят примерно так: AppKit для MacOS, WPF для Windows (я не специалист по разработке под конкретные платформы, так что дайте знать, пожалуйста, какие варианты в наши дни более популярны).

Однако реальные конкуренты Electron — это мультиплатформенные фреймворки. Думаю, среди них самыми популярными сегодня являются GTK+, Qt и JavaFX.

GTK+

GTK+ написан на C, но связан со многими другими языками. Этот фреймворк использовался для разработки прекрасной платформы GNOME-3.

Qt

Qt кажется самой популярной альтернативой Electron в дискуссиях, которые попадались мне на глаза… Это библиотека C++, но тоже связанная с другими языками (хотя кажется, что никакие из них не поддерживаются на коммерческой основе, и сложно сказать, насколько они доработаны). Qt вроде бы популярный выбор для встроенных систем.

JavaFX

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

Что бы вы ни думали о JVM, не существует никакой другой платформы (кроме, может быть, самого Electron!), настолько простой для кросс-платформенной разработки. Как только вы создали свой jar, на любой платформе, вы можете распространять его среди пользователей всех ОС — и он просто будет работать.

При большом разнообразии языков, которые сейчас поддерживаются в JVM, выбор языка тоже не должен стать проблемой: определённо найдётся такой, какой вам понравится (в том числе JavaScript, если вы не способны от него отказаться), и вы можете использовать JavaFX с любым языком JVM без особых проблем. В этой статье, кроме Java, я покажу немного кода на Kotlin.

Сам UI создаётся просто кодом (если у вас есть замечательная поддержка IDE от IntelliJ, Eclipse или NetBeans: это всё отличные бесплатные IDE, которые, наверное, превосходят любых конкурентов и, кстати, представляют собой самые лучшие образцы десктопных приложений на Java) или в визуальном конструкторе UI: SceneBuilder (который умеет интегрироваться в IntelliJ) или NetBeans Visual Debugger.

История JavaFX

JavaFX — не новая технология. Она появилась в декабре 2008 года и сильно отличалась от того, что мы видим сегодня. Идея заключалась в создании современного фреймворка UI для замены устаревшего Swing Framework, который являлся официальным фреймворком JVM с конца 90-х.

Oracle чуть не испортила всё с самого начала, приступив к созданию особого, декларативного языка, который предполагалось использования для создания UI приложений. Это не очень хорошо восприняли Java-разработчики, и та инициатива чуть не погубила JavaFX.

Заметив проблему, Oracle решила выпустить JavaFX 2 в 2011 году без собственного особого языка, а вместо этого применив FXML в качестве опции для чистого Java-кода (как мы увидим позже).

Около 2012 года JavaFX обрёл некую популярность, а Oracle приложила значительные усилия для улучшения и популяризации этой платформы. С версии 2.2 фреймворк JavaFX стал достаточно цельным фреймворком, но его по-прежему не включали в стандартную среду выполнения Java (хотя он всегда поставлялся вместе с JDK).

Только с версии JavaFX 8 (изменение версии сделано для соответствия Java  он стал частью стандартного рантайма Java.

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

Создание приложения JavaFX

В своём приложении для просмотра логов LogFX, я решил просто использовать Java (потому что там в основном довольно низкоуровневый код, а я хотел сконцентрироваться на скорости и малом размере пакета) и IntelliJ в качестве IDE. Я почти решился писать на Kotlin, но поддержка Java в IntelliJ оказалась настолько хорошей, так что писать на Java (точнее, позволить IntelliJ делать это за меня — это ближе к истине) стало не такой большой проблемой, чтобы оправдать лишние 0,9 МБ в дистрибутиве.

Я решил не использовать FXML (язык описания GUI для JavaFX на основе XML) или визуальный конструктор UI, потому что интерфейс у программы очень простой.

Итак, посмотрим на какой-нибудь код!

Java Hello World

Приложение JavaFX — это просто класс, который расширяет javafx.application.Application и показывает JavaFX Stage.

Вот как пишется Hello World на JavaFX:

 public class JavaFxExample extends Application {

     @Override
     public void start(Stage primaryStage) throws Exception {
         Text helloWorld = new Text("Hello world");
         StackPane root = new StackPane(helloWorld);
         primaryStage.setScene(new Scene(root, 300, 120));
         primaryStage.centerOnScreen();
         primaryStage.show();
     }

     public static void main(String[] args) {
         launch(JavaFxExample.class, args);
     }
 }

src/main/java/main/JavaFxExample.java

На «маке» этот код покажет примерно такое:

FXML+Java Hello World

Если вам трудно писать код для UI и вы предпочитаете использовать язык разметки, вот эквивалент того же кода с FXML:

 <?xml version="1.0" encoding="UTF-8"?>

 <?import javafx.scene.layout.StackPane?>
 <?import javafx.scene.Scene?>
 <?import javafx.scene.text.Text?>
 <Scene xmlns="http://javafx.com/javafx"
        width="300.0" height="120.0">
     <StackPane>
         <Text>Hello world</Text>
     </StackPane>
 </Scene>

src/main/resources/main/Example.fxml

 public class JavaFxExample extends Application {

     @Override
     public void start(Stage primaryStage) throws Exception {
         Scene scene = FXMLLoader.load(getClass().getResource("Example.fxml"));
         primaryStage.setScene(scene);
         primaryStage.centerOnScreen();
         primaryStage.show();
     }

     public static void main(String[] args) {
         launch(JavaFxExample.class, args);
     }
 }

src/main/java/main/JavaFxExample.java

Обратите внимание, что IntelliJ поддерживает FXML и свяжет его содержимое с соответствующим кодом Java и наоборот, подсветит ошибки, сделает автодополнение, справится с импортом, покажет встроенную документацию и так далее, что довольно круто… но как я раньше сказал, решено было не использовать FXML, поскольку задуманный UI был очень простым и довольно динамичным… так что я больше не покажу кода FXML. Если интересно, изучите руководство по FXML.

Hello World на Kotlin+TornadoFX

Прежде чем двигаться дальше, давайте посмотрим, как такой код выглядит на современном языке вроде Kotlin с его собственной библиотекой для написания приложений JavaFX, которая называется TornadoFX:

 class Main : App() {
     override val primaryView = HelloWorld::class
 }

 class HelloWorld : View() {
     override val root = stackpane {
         prefWidth = 300.0
         prefHeight = 120.0
         text("Hello world")
     }
 }

src/main/kotlin/main/app.kt

Многим может показаться привлекательным использовать Kotlin и JavaFX, особенно если вы предпочитаете безопасность типов (в TornadoFX есть приятная функция «типобезопасные таблицы стилей») и если добавить лишние 5 МБ в приложения для вас не проблема.

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

Стили и темы для пользовательского интерфейса JavaFX

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

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

Предположим, что мы хотим сделать тёмный фон и белый текст, как показано на скриншоте:

Программные и встроенные стили

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

 root.setBackground(new Background(new BackgroundFill(
         Color.DARKSLATEGRAY, CornerRadii.EMPTY, Insets.EMPTY)));

 helloWorld.setStroke(Color.WHITE);

Более простой программный способ — установить стили в CSS:

 root.setStyle("-fx-background-color: darkslategray");
 helloWorld.setStyle("-fx-stroke: white");

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

Если вы используете FXML:

 <StackPane style="-fx-background-color: darkslategray">
     <Text style="-fx-stroke: white">Hello world</Text>
 </StackPane>

То же самое…

Использование отдельных таблиц стилей

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

Для этого сначала создаём таблицу стилей:

 .root {
     -fx-base: darkslategray;
 }

 Text {
     -fx-stroke: white;
 }

src/main/resources/css/hello.css

Теперь добавляем её в Scene:

 primaryStage.getScene().getStylesheets().add("css/hello.css");

И всё.

Заметьте, что таблицы стилей устанавливают не только фоновый цвет StackPane как darkslategray, но и меняют основной цвет темы.

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

Например, в нашем случае более подходящим цветом текста станет не белый, а «противоположный» цвет относительно основного цвета темы, чтобы текст всегда оставался читаемым:

 -fx-stroke: ladder(-fx-base, white 49%, black 50%);

Таблицы стилей JavaFX довольно умные, для дополнительной информации см. CSS Reference Guide.

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

Слева: стили по умолчанию JavaFX. Справа: кастомные стили, созданные выше

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

Вот как LogFX выглядит в итоге с темой по умолчанию:

Обратите внимание, что для кнопок я использовал иконки FontAwesome. Было довольно просто стилизовать кнопки в CSS. Просто убедитесь в том, чтобы шрифт устанавливался как можно раньше с помощью такой инструкции:

 Font.loadFont( LogFX.class.getResource( "/fonts/fontawesome-webfont.ttf" ).toExternalForm(), 12 );

С кастомными таблицами стилей можно кардинально изменить внешний вид приложения. Например, вот очень зелёная тема в Linux Mint:

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

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

В JavaFX это делается просто. Вот что у меня получилось (я сделал экран на основе образца GroovyFX):

И вот какая таблица стилей соответствует этому стартовому экрану:

 Text {
     -fx-fill: white;
 }

 #logfx-text-log {
     -fx-font-family: sans-serif;
     -fx-font-weight: 700;
     -fx-font-size: 70;
     -fx-fill: linear-gradient(to top, cyan, dodgerblue);
 }

 #logfx-text-fx {
     -fx-font-family: sans-serif;
     -fx-font-weight: 700;
     -fx-font-size: 86;
     -fx-fill: linear-gradient(to top, cyan, dodgerblue);
     -fx-effect: dropshadow(gaussian, dodgerblue, 15, 0.25, 5, 5);
 }

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

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

Дизайн, отладка и перезагрузка кода

Практически невозможно создавать интерфейс пользователя без возможности мгновенно просматривать изменения. Поэтому важной частью любого фреймворка UI является «горячая» перезагрузка кода или некая разновидность конструктора UI.

У JavaFX (и у самой JVM) есть несколько вариантов решения этой проблемы.

SceneBuilder

Первое из них — это SceneBuilder, визуальный конструктор UI, который позволяет создавать FXML, просто перетаскивая компоненты UI.

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

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

Если вы так сделаете, а потом откроете вид в SceneBuilder, он по-прежнему будет нормально работать, так что можно поочерёдно редактировать код вручную или в SceneBuilder — и просматривать результат.

ScenicView

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

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

Для запуска ScenicView со своим приложением просто скачайте jar и передайте параметр -javaagent:/path-to/scenicView.jar в JVM.

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

Горячая перезагрузка кода JVM

Если хотите изменить код приложения, который напрямую не связан с UI, то длоя этого подходит отладчик Java с горячей заменой кода во время работы приложения. Базовая поддержка перезагрузки кода имеется в Oracle JVM и HotSpot. Думаю, что она есть и в OpenJDK JVM.

Однако базовая поддержка этой функции очень ограничена: вам позволено менять только реализацию уже существующих методов.

Зато есть расширение HotSpot VM под названием DCEVM (Dynamic Code Evolution VM) с гораздо большей функциональностью: добавление/удаление методов и полей, добавление/удаление классов, изменение значения итоговых переменных и прочее. В другой статье я уже писал о нём и о других способах перезагрузки кода в работающей JVM.

Я использовал это расширение при разработке LogFX — и оно отлично себя проявило. Если не закрыть и заново не открыть окно, то вид не меняется автоматически при перезагрузке кода, но это не такая большая проблема, если менять что-то в Stage… к тому же, если вы хотите изменить только компонент UI, то можно использовать ScenicView или просто вернуться в ScenicBuilder и как угодно поменять дизайн.

Для запуска DCEVM нужно только установить его и сверить номера версий расширения и JVM. После этого приложение запускается с отладчиком — и каждый раз после перекомпиляции в IDE новый код автоматически подгрузится в работающую программу.

В IntelliJ после изменения класса и перекомпиляции вы увидите нечто подобное (Cmd+F9 на «маке»):

Обновление таблиц стилей

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

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

Но он работает только если стили поставляются из отдельного файла, а не из самого приложения (из jar).

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

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

Для выбора таблицы стилей как файла (в отличие от ресурса jar), к сожалению, придётся использовать разный синтаксис под Unix/Mac и Windows. Вот такой метод я применил, чтобы решить проблему:

 private static String toAbsoluteFileUri( File file ) {
     String absolutePath = file.getAbsolutePath();
     if ( File.separatorChar == '\\' ) {
         // windows stuff
         return "file:///" + absolutePath.replace( "\\", "/" );
     } else {
         return "file:" + absolutePath;
     }
 }

Это работает на Mac, Windows и Linux Mint. Но это только первая из двух проблем, которые возникают на разных ОС (вторая — то, что не отображается иконка в системном трее на Mac, хотя есть уродливое обходное решение этой проблемы). В остальном JavaFX всё абстрагирует довольно хорошо по большей части.

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

 Runnable resetStylesheet = () -> Platform.runLater( () -> {
     scene.getStylesheets().clear();
     scene.getStylesheets().add( stylesheet );
 } );

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

Заключение

Создание приложения на JavaFX стало довольно приятным опытом. У меня имелась некоторая практика написания JavaFX-приложений для работы несколько лет назад (когда JavaFX находился на ранней стадии развития, что теперь уже осталось в прошлом), так что у меня определённо была некая фора… но я также работал как веб-разработчик и теперь не могу поверить, что кто-то предпочтёт использовать веб-стек вместо такой вменяемой среды как JVM.

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

curl -sSfL https://jcenter.bintray.com/com/athaydes/logfx/logfx/0.7.0/logfx-0.7.0-all.jar -o logfx.jar

Хотя это полностью функциональное приложение, файл jar весит всего 303 килобайта. Это 0,3 МБ, включая несколько картинок и файл шрифта TTF, и ещё несколько файлов HTML и CSS, помимо файлов классов Java!

Конечно, приложение не включает саму виртуальную машину JVM, но JVM не является частью программы и может использоваться для многих приложений! В Java 9 вы можете вообще создавать нативные исполняемые файлы, включая в них только необходимые части JVM, так что если вашим пользователям не нравится простой jar, то упакуйте его как нативное приложение, как я показывал в предыдущей статье (небольшое нативное приложение JVM займёт примерно 35 МБ или 21 МБ после оптимизации).

Для работы LogFX требуется около 50 МБ RAM (не для самого приложения, а в основном для JavaFX). В этом можно убедиться, запустив программу такой командой:

java -Xmx50m -jar logfx.jar

Это кардинально отличается от приложений Electron, которые обычно жрут 200 МБ уже в момент запуска.

JavaFX не идеальна и есть много областей, которые всё ещё нуждаются в улучшении. Одна из них — распространение и автоматическое обновление программ. Текущее решение, JNLP и Java WebStart, кажется слабо реализованным, хотя имеются альтернативы от сообщества, такие как Getdown и FxLauncher, а если вы хотите правильный нативный инсталлятор, то имеется и коммерческое решение Install4J (кстати, у Install4J есть бесплатные лицензии для проектов open source).

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

• Привязывание свойств позволяет легко внедрять реактивные UI.
• Диаграммы на JavaFX выглядят великолепно.
• Поддержка 3D в JavaFX.
• Тестировочные фреймворки для JavaFX: TestFX и Automaton (дисклеймер: я являюсь автором Automaton и работал с командой, которая изначально разработала TestFX).
• Демо-приложения JavaFX Ensemble показывают бóльшую часть возможностей JavaFX в реальной работе.

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

Скачать готовую программу можно по следующей ссылке – “yadi.sk/d/Kf5A7CQYrQTfE”

Приступим к созданию данной программы:

1. Устанавливаем бесплатную программу Eclipse

Официальный сайт “eclipse.org/downloads/”

Скачиваем “Eclipse IDE for Java EE Developers”:

Здесь есть Eclipse как для 32 разрядной операционной системы, так и для 64 разрядной системы.

Как узнать какая у вас система?
Наведите правой клавишей мыши на ярлык “Мой компьютер”, выберите пункт “Свойства”:

Скачается zip-архив, если вы попробуете распаковать его встроенным в windows архиватором, то здесь могут возникнуть проблемы – процесс может затянуться на длительное время или вовсе с ошибкой. Лучше всего это сделать с помощью программ WinRAR или 7-zip.

2. Далее устанавливаем Комплект Разработчика Приложений на языке Java – Java Software Development Kit (Java SDK или JDK).

Скачать его (JDK) можно с официального сайта – “oracle.com/technetwork/java/javase/downloads/index.html”

Здесь вам также предложат скачать JDK для различных операционных систем, замечу, что 32 разрядной для windows – вы не найдете, JDK для Windows x32 – можно скачать здесь – Скачать JDK для windows x32 и как его установить

После установки JDK стоит проверить его работу – для этого – откройте командную строку снова (Пуск > Выполнить. В текстовом поле наберите «cmd» и нажмите «Enter».). Наберите команду «javac» (без кавычек, конечно).

Если у вас выводится сообщение как на скриншоте выше, то все нормально.

Если нет и показывается следующее сообщение:

То прочтите мою статью по следующей ссылке – Скачать JDK для windows x32 и как его установить.

3. Скачайте бесплатную программу launch4j.
Она предназначена для компиляции всех ваших java файлов в один исполняемый “exe” файл.
Вы можете скачать launch4j с сайта “sourceforge.net/projects/launch4j/files/launch4j-3/3.1.0-beta1/”
или по следующей ссылке:
“https://mnogoblog.ru/wp-content/uploads/2016/04/launch4j-3.8-win32.zip”

4. Теперь осталось написать простенькую программу на языке программирования JAVA в программе Eclipse.

Для изучения языка программирования Java есть хороший youtube канал – ZhirniToni – “youtube.com/user/ZhirniToni” и в нем есть плейлист “Java для Чайников”, так вот на основе уроков 7, 8 и 14:

Урок 7: “youtu.be/lBE20G5l0YU”
Урок 8: “youtu.be/L-Ivs-ZfbT8”
Урок 14: “youtu.be/XUJsJ_loOkE”

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

———————-

Благодаря урокам 7 и 8 у меня в программе Eclipse получилось 2 файла: main.java и reader.java.

Код файла main.java:

package ru.proekt;

import javax.swing.JFrame;

public class main {

	public static void main(String[] args) {
		reader r = new reader("Моя программа");
		r.setVisible (true);
		r.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
		r.setSize(300, 200);

	}

}

Код файла reader.java:

package ru.proekt;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class reader extends JFrame {

	JButton b1, b2;
	JLabel l1, l2, l3, l4;
	JTextField t1, t2;
	int i, k;
	String a, b;
	eHandler handler = new eHandler();
	
	
	public reader(String s) {
		super(s);
		setLayout(new FlowLayout());
		b1=new JButton ("Очистить");
		b2=new JButton ("Посчитать");
		l1=new JLabel ("Введите первое число:");
		l2=new JLabel ("Введите второе число:");
		l3=new JLabel ("");
		l4=new JLabel ("");
		t1=new JTextField (10);
		t2=new JTextField (10);
		add(b1);
		add(b2);
		add(l1);
		add(l2);
		add(l3);
		add(l4);
		add(t1);
		add(t2);
		b2.addActionListener(handler);
		b1.addActionListener(handler);
		
		
	}
	
	public class eHandler implements ActionListener {
		
		public void actionPerformed(ActionEvent e) {
			try {
			if (e.getSource()==b2){
				i=Integer.parseInt(t1.getText());
				k=Integer.parseInt(t2.getText());
				i++;
				k++;
				a = "Ваше первое число теперь равно: " + i;
				b = "Ваше второе число теперь равно: " + k;
				l3.setText(a);
				l4.setText(b);
							
			}
			if (e.getSource()==b1){
				t1.setText(null);
				t2.setText(null);
				l3.setText("");
				l4.setText("");
				
			} 
						
				
			}catch (Exception ex){JOptionPane.showMessageDialog(null, "Введите в поле число.");}
			
		}
		
	}
}

———————-

После того как вы напишите программу на Eclips сохранить её аналогично уроку 14, только тип файла нужно выбрать “Runnable JAR file”, а именно, вот так:

– кликаем мышкой на проект, который хотим сохранить:

– далее щелкните правой кнопкой мыши по вашему проекту и нажмите “Export” (Экспорт).

– откройте папку “Java” и дважды нажмите опцию “Runnable JAR file” (исполняемый архив JAR).

– Первое, что вы должны сделать, это выбрать главный класс (класс с основным методом) из выпадающего меню под “Launch configuration” (конфигурации запуска).
Во-вторых, выберите “Export destination” (Место экспорта) с помощью кнопки “Browse…” (Обзор) или вручную, вводя месторасположение.
И в-третьих, обеспечьте выбор переключателя “Extract required libraries into generated JAR”(Извлечь необходимые библиотеки в созданные JAR) “.
И, наконец, нажмите кнопку “Finish” (Готово).

———————-

Выкладываю вам JAR файл, который у меня получился – скачать JAR файл можно по следующей ссылке – “yadi.sk/d/o0Q8iWE7rQTZp”

5. А далее сохраним нашу программу на JAVA с помощью программы launch4j в exe файл.

Запускаем launch4j.

В первом текстовом поле введите или выберите с помощью просмотра место, где исполняемый файл хотите сохранить. Убедитесь, что имя файла имеет “.exe” в конце названия!

Во втором текстовом поле введите или выберите с помощью просмотра файл .jar, ранее экспортированного из Eclipse.

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

На вкладке “JRE” в верхнем меню выберите “Min JRE version” и введите “1.4.0”. Это гарантирует, что пользователи имеют нужную версию Java для использования вашей программы. Вы можете изменить это, но 1.4.0 является безопасной версией.

Нажмите кнопку передач под названием “Build wrapper” в верхней части экрана.

Программа вместе с exe файлом создаст и файл .xml, дайте ему соответствующее имя и нажмите “Save”. Файл .xml является стандартным, не волнуйтесь об этом. Сразу после создания .xml файла будет создан exe файл.

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

Первый шаг при разработке Java-приложения для Windows — установка необходимого программного обеспечения. Для начала вам потребуется скачать и установить JDK (Java Development Kit) на ваш компьютер. JDK включает в себя все необходимые инструменты для разработки Java-приложений, включая компилятор Java и среду разработки. Вы можете скачать JDK с официального веб-сайта Oracle.

После установки JDK вам также понадобится установить IDE (Integrated Development Environment) для разработки Java-приложений. Существует множество IDE, которые можно использовать для разработки Java-приложений, таких как Eclipse, IntelliJ IDEA и NetBeans. В данной инструкции мы будем использовать Eclipse, так как он является одним из наиболее популярных и широко используемых IDE для разработки Java-приложений.

Если у вас уже установлены JDK и Eclipse, вы можете начать разработку своего Java-приложения. Запустите Eclipse, создайте новый проект и выберите тип проекта «Java Project». Дайте проекту имя и нажмите «Finish». Теперь вы готовы начать разработку своего Java-приложения.

Подготовка к разработке Java-приложения для Windows

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

Шаг 1: Установка Java Development Kit (JDK)

1. Перейдите на официальный сайт Oracle: https://www.oracle.com/java/technologies/javase-jdk14-downloads.html
2. Скачайте JDK для Windows согласно вашей операционной системе (32-бит или 64-бит).
3. Запустите установщик JDK и следуйте инструкциям.
4. После установки JDK убедитесь, что переменная среды JAVA_HOME указывает на корректное местоположение JDK.

Шаг 2: Установка интегрированной среды разработки (IDE)

Для разработки Java-приложений удобно использовать специализированные интегрированные среды разработки (IDE). Одним из популярных вариантов является Eclipse IDE. Для установки Eclipse выполните следующие действия:

1. Перейдите на официальный сайт Eclipse: https://www.eclipse.org/downloads/
2. Скачайте версию Eclipse для Java разработчиков согласно вашей операционной системе.
3. Запустите установщик Eclipse и следуйте инструкциям.
4. После установки запустите Eclipse и выполните настройку рабочей среды по вашему усмотрению.

Шаг 3: Установка системы контроля версий (Git)

Для эффективной работы над проектом рекомендуется использовать систему контроля версий (VCS). Одной из популярных систем контроля версий является Git. Чтобы установить Git, выполните следующие действия:

1. Перейдите на официальный сайт Git: https://git-scm.com/downloads
2. Скачайте версию Git для Windows согласно вашей операционной системе (32-бит или 64-бит).
3. Запустите установщик Git и следуйте инструкциям.

Шаг 4: Подготовка среды разработки

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

Теперь вы готовы разрабатывать Java-приложения для Windows! Продолжайте учиться и экспериментировать, чтобы стать опытным Java-разработчиком.

Настройка окружения разработчика

Шаг 1: Установка JDK

Первым шагом в настройке окружения разработчика Java для Windows является установка Java Development Kit (JDK). JDK включает в себя все необходимые инструменты для разработки Java-приложений.

1. Скачайте установочный файл JDK с официального сайта Oracle.
2. Запустите установочный файл и следуйте инструкциям инсталлятора.
3. После установки JDK установите переменные среды JAVA_HOME и PATH:

Шаг 2: Установка IntelliJ IDEA

IntelliJ IDEA — одна из наиболее популярных интегрированных сред разработки для языка Java. Она облегчает процесс разработки Java-приложений с помощью мощных функций и инструментов.

1. Скачайте установочный файл IntelliJ IDEA с официального сайта JetBrains.
2. Запустите установочный файл и следуйте инструкциям инсталлятора.

Шаг 3: Настройка проекта в IntelliJ IDEA

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

1. Откройте IntelliJ IDEA и создайте новый проект.
2. Выберите тип проекта «Java» и укажите путь для сохранения проекта.
3. Укажите имя проекта и JDK, установленный на вашем компьютере.
4. Нажмите кнопку «Finish», чтобы создать проект.

Поздравляю! Вы успешно настроили окружение разработчика Java для Windows и готовы начать создание своего Java-приложения.

Загрузка и установка Java Development Kit (JDK)

Java Development Kit (JDK) — это набор инструментов, необходимых для разработки Java-приложений. В этом разделе мы рассмотрим, как загрузить и установить JDK на вашем компьютере под управлением операционной системы Windows.

1. Перейдите на официальный сайт Oracle (https://www.oracle.com/java/technologies/javase-jdk11-downloads.html), где вы сможете загрузить JDK.

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

3. Нажмите на ссылку загрузки для выбранной версии JDK.

4. После завершения загрузки запустите установщик JDK.

5. Следуйте инструкциям установщика для установки JDK. Вы можете выбрать путь установки и другие настройки в процессе установки.

6. После завершения установки проверьте, что JDK был успешно установлен. Для этого откройте командную строку (нажмите Win + R, введите «cmd» и нажмите Enter) и введите команду «java -version». Если все прошло успешно, вы должны увидеть информацию о версии установленной JDK.

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

Создание Java-проекта для Windows

Если вы хотите создать Java-приложение, которое будет работать под Windows, вам потребуется выполнить следующие шаги:

1. Убедитесь, что вы установили Java Development Kit (JDK) на своем компьютере. Вы можете загрузить JDK с официального веб-сайта Oracle.
2. Откройте среду разработки, такую как Eclipse или IntelliJ IDEA, или используйте любой текстовый редактор для написания кода Java.
3. Создайте новый проект Java в своей среде разработки. Введите имя проекта и выберите путь для сохранения проекта на вашем компьютере.
4. Создайте новый класс Java внутри проекта. Введите имя класса и выберите пакет, в котором он будет находиться.
5. Напишите код вашего Java-приложения внутри класса. Вы можете использовать различные библиотеки и фреймворки для разработки своего приложения.
6. Скомпилируйте ваш Java-код, чтобы получить байт-код. В среде разработки создайте новый сборщик (build configuration) и настройте его на компиляцию вашего кода.
7. Создайте исполняемый JAR-файл для вашего Java-приложения. Установите точку входа (main class) в вашем проекте и упакуйте все зависимости в JAR-файл.
8. Перейдите на вашем компьютере в командную строку и перейдите в папку, в которой находится ваш JAR-файл.
9. Запустите ваше Java-приложение, введя команду «java -jar YourJarFileName.jar» в командной строке.

Теперь ваше Java-приложение должно запуститься на компьютере под управлением Windows. Убедитесь, что у вас установлена соответствующая версия Java на вашем компьютере, чтобы исполнять вашу программу.

Создание нового проекта в среде разработки

Прежде чем начать разрабатывать Java-приложение для Windows, необходимо создать новый проект в среде разработки, такой как IntelliJ IDEA или Eclipse. В этом разделе мы рассмотрим шаги, необходимые для создания нового проекта.

1. Откройте среду разработки. Запустите IntelliJ IDEA или Eclipse на вашем компьютере.
2. Создайте новый проект. В меню выберите «Файл» -> «Создать новый проект».
3. Выберите тип проекта. В диалоговом окне выберите тип проекта, который соответствует вашим требованиям. Например, если вы хотите создать Java-приложение для Windows, выберите «Java» -> «Java Application» или «Java» -> «JavaFX Application».
4. Укажите настройки проекта. В следующем диалоговом окне введите название проекта и выберите путь для сохранения проекта. Вы также можете указать другие настройки, такие как JDK (Java Development Kit) и версию Java.
5. Создайте пакеты и классы. После создания проекта вы можете создать пакеты и классы, которые будут содержать ваш код Java. Вы можете создать новый пакет, щелкнув правой кнопкой мыши на папке проекта и выбрав «Создать пакет». Затем создайте новый класс, щелкнув правой кнопкой мыши на пакете и выбрав «Создать класс».

Поздравляю! Вы только что создали новый проект в среде разработки. Теперь вы готовы начать разрабатывать Java-приложение для Windows.

Настройка проекта для работы с Windows

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

Шаг 1: Установка JDK

1. Скачайте установщик JDK (Java Development Kit) с официального сайта Oracle.
2. Запустите установщик и следуйте инструкциям по установке JDK на вашу систему. Убедитесь, что вы выбрали соответствующую версию JDK для вашей операционной системы (32-бит или 64-бит).
3. После завершения установки, убедитесь, что переменная среды JAVA_HOME указывает на установленную директорию JDK.

Шаг 2: Настройка переменных среды

1. Откройте «Панель управления» и найдите раздел «Система».
2. Перейдите в «Дополнительные параметры системы».
3. В появившемся окне выберите вкладку «Переменные среды».
4. В разделе «Пользовательские переменные» нажмите кнопку «Создать».
5. Укажите имя переменной «JAVA_HOME» и значение, указывающее на директорию установленного JDK.
6. Добавьте путь к исполняемым файлам JDK (обычно в директории «bin») в переменную среды «Path», используя символ «;» для разделения путей.

Шаг 3: Установка среды разработки Java

• Скачайте и установите среду разработки Java, например, Eclipse, IntelliJ IDEA или NetBeans.
• Указывайте путь к установленному JDK при настройке среды разработки.

После выполнения этих шагов ваша система будет готова к разработке и запуску Java-приложений на Windows.

Вопрос-ответ

Какие инструменты нужно использовать для разработки Java-приложений под Windows?

Для разработки Java-приложений под Windows вам понадобятся следующие инструменты: JDK (Java Development Kit) для компиляции и запуска Java-кода, IDE (Integrated Development Environment) для разработки кода, например, Eclipse или IntelliJ IDEA. Также вам необходимо будет установить программу для управления версиями кода, например, Git.

С чего начать разработку Java-приложения для Windows?

Сначала убедитесь, что на вашем компьютере установлены необходимые инструменты: JDK, IDE и Git. Затем создайте новый проект в среде разработки и выберите тип проекта, который соответствует вашим потребностям — например, платформа JavaFX для создания графического приложения. Затем создайте основной класс приложения и начните писать код.

Как подключить библиотеки к Java-приложению для Windows?

Для подключения библиотек к Java-приложению вы можете воспользоваться системой сборки, такой как Apache Maven или Gradle. Вам нужно будет добавить зависимости в файл конфигурации проекта (например, pom.xml для Maven или build.gradle для Gradle) и запустить процесс сборки проекта. После этого библиотеки будут автоматически загружены и подключены к вашему приложению.

Как упаковать Java-приложение для Windows в исполняемый файл?

Для упаковки вашего Java-приложения в исполняемый файл для Windows вы можете воспользоваться утилитой Launch4j. Она позволяет создавать \».exe\» файлы из JAR файлов, что позволяет запускать приложение простым щелчком мыши. Прежде чем упаковать приложение, убедитесь, что ваш проект полностью собран и готов к распространению.

Последнее обновление: 22.11.2022

Итак, после установки JDK создадим первое приложение на языке Java. Что необходимо для создания программы на Java? Прежде всего нам надо написать код программы, и для этого нужен текстовый редактор.
Можно использовать любой текстовый редактор, например, Notepad++.

И чтобы превратить код программы в исполняемое приложение необходим компилятор. После установки JDK все файлы по умолчанию помещаются в каталог C:\Program Files\Java\jdk-[номер_версии] (при использовании ОС Windows).
В моем случае это каталог C:\Program Files\Java\jdk-19. Если мы откроем в нем подкаталог bin, то мы сможем увидеть в нем ряд утилит.
Нас прежде всего интересует утилита компилятора javac. Чтобы скомпилировать класс программы, нам надо передать ее код этому компилятору.

Также следует отметить другую утилиту из этой папки — java.exe, которая позволяет запускать скомпилированную программу.

Итак, создадим на жестком диске какой-нибудь каталог, в котором будут располагаться файлы с исходным кодом на языке Java. Допустим, это будет каталог
C:/Java. Затем создадим в этом каталоге текстовый файл, который переименуем в Program.java.
Откроем этот файл в любом текстовом редакторе и наберем в нем следующую программу:

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

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

При определении класса вначале идет модификатор доступа public, который указывает, что данный класс будет доступен
всем, то есть мы сможем его запустить из командной строки. Далее идет ключевое слово
class, а затем название класса. То есть класс называется Program. После названия в фигурных скобках расположено содержимое класса.

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

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

Далее в скобках у нас идут параметры метода — String args[] — это массив args, который хранит значения типа String, то
есть строки. В данном случае ни нам пока не нужны, но в реальной программе это те строковые параметры, которые передаются при запуске программы из
командной строки.

После списка параметров в фигурных скобках идет тело метода — это собственно те инструкции, которые и будет выполнять метод.
В данном случае фактически определени определена только одна инструкция — вывод на консоль некоторой строки. Для вывода на консоль используется встроенный метод
System.out.println(). В этот метод передается выводимая строка. Каждая инструкция завершается точкой с запятой.

Теперь скомпилируем написанную программу. Откроем командную строку (в Windows) или терминал в Linux/MacOS и введем там соответствующие команды. Первым делом перейдем в каталог, где лежит наш файл с программой с помощью команды:

В данном случае файл находится в каталоге C:\Java.

Затем cкомпилируем программу с помощью команды

C:\Java>"C:\Program Files\Java\jdk-19\bin\javac" Program.java

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

После этого программа компилируется в байт-код, и в каталоге C:\Java можно будет найти новый файл Program.class.
Это и будет файл с байт-кодом программы. Теперь нам надо его запустить с помощью утилиты java:

C:\Java>"C:\Program Files\Java\jdk-19\bin\java" Program

Здесь уже расширение у файла не надо использовать.

Для ОС Windows весь процесс будет выглядеть следующим образом:

Добавление java в переменную Path

Для компиляции приходится вводить полный путь к комилятору javac, что может быть сопряжено с ошибками при вводе, да и каждый раз вводить полный путь тоже неудобно.
Чтобы в дальнейшем облегчить работу, добавим путь к JDK в переменную PATH в переменных среды. Если мы работаем в Windows, то для добавления переменной среды
через поиск найдем найдем параметр Изменение системных переменных среды. Для этого введем в поле поиска «Изменение системных переменных среды»:

Выберем пункт Изменение системных переменных среды. И сначала нам откроется окно «Свойства системы», где нажмем на кнопку
Переменные среды:

Затем нам откроется окно, где мы можем увидеть все переменные среды.
(Также можно перейти через Параметры и пункт Система ->Дополнительные параметры системы ->Переменные среды)

Здесь нам нужно исправить системную переменную Path. Для этого выделим ее и нажмем на кнопку «Изменить»:

В эту переменную Path нам надо добавить путь к инструментам JDK. И тут есть два момента.
Во-первых, при установке jdk по умолчанию ряд утилит также устанавливаются в папку C:\Program Files\Common Files\Oracle\Java\javapath. В том числе это такие файлы как
java.exe и javac.exe. И путь к этой папке по умолчанию добавляется в перемнную Path. То есть мы можем использовать этот путь.

Второй момент — в последних сборках Windows компания Microsoft также устанавливает свои сборки JDK, точнее OpenJDK, которые также по умолчанию добавляются в переменную Path
и которые мы также можем использовать. Но у этих сборок есть большой минус — они применяют одну из прошлых версий JDK (обычно это LTS-сборки). Например, в моем случае это 11-я версия,
но текущая версия может отличаться (например, на написание данной статьи текущей являлась версия 19).

Чтобы использовать последнюю версию среди путей в переменной Path убедимся, что путь C:\Program Files\Common Files\Oracle\Java\javapath располагается выше
путей к сборкам JDK от Microsoft. Для перемещения определенного пути вверх среди переменных среды можно использовать кнопку «Вверх:

Также можно напрямую использовать путь к JDK.

Для создания новой переменной надо нажать на кнопку «Создать» и ввести в новое поле путь «C:\Program Files\Java\jdk-[номер_версии]\bin». Но опять же его следуется с помощью кнопки Вверх поместить
над путями к OpenJDK от Microsoft.

После установки переменной Path перейдем к командной строке/терминалу (в более старых версиях Windows может потребоваться перезауск командной строки) и для проверки версии введем команду

Консоль нам должна в ответ ввести номер только что установленной версии JDK (в моем случае 19-й версии):

java version "19.0.1" 2022-10-18
Java(TM) SE Runtime Environment (build 19.0.1+10-21)
Java HotSpot(TM) 64-Bit Server VM (build 19.0.1+10-21, mixed mode, sharing)

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

Как вы знаете, Java — один из самых популярных языков программирования в мире и его знание существенно увеличит вашу значимость как программиста. Итак, вы решили начать писать на этом языке. Вам понадобится поставить JDK для того, чтобы писать и запускать программы на Java. JDK — набор софта, разработанного Oracle, содержащий в себе компилятор (javac), среду выполнения (Java Runtime Environment), стандартную библиотеку языка, примеры и документацию. Прочитав эту статью, вы узнаете, как установить и настроить JDK на своей системе, что такое среда разработки и какие варианты IDE существуют для Java. Также вы напишете свою первую программу на Java.

Установка Java Development Kit

1. Перейдите на сайт Oracle и загрузите JDK для вашей платформы.
2. После загрузки извлеките полученный архив и запустите извлеченное приложение.
3. В процессе установке выберите вариант «Development Tool» и нажмите «Next».
4. Спустя некоторое время установка завершится.

Итак, вы установили Java Development Kit, но это еще не всё. Необходимо настроить его для вашей системы.

Настройка JDK на примере Windows

1. Перейдите в папку %ProgramFiles%\Java\%версия установленного вами jdk%\bin, нажмите на свойства любого файла в этой папке и скопируйте путь к нему.
2. Перейдите в свойства вашего компьютера, откройте вкладку «Дополнительно», нажмите «Переменные среды…». В открывшемся окне создайте новую переменную, назовите её Path, в её значение вставьте скопированный ранее путь.
3. Теперь самое важное. Откройте командную строку и наберите javac, чтобы убедиться, что JRE установлен и настроен. Если выдаётся список аргументов к команде javac, то поздравляю, вы успешно установили и настроили всё, что необходимо для использования Java!

После установки JDK и JRE не помешает установить на компьютер одну из IDE.

Установка IDE

Для начала разберёмся, что такое IDE.

IDE (Integrated Development Environment) – это комплекс программных средств, используемый программистами для разработки программного обеспечения. IDE позволяет с лёгкостью писать, запускать, отлаживать и тестировать код.

Для написания сложных программ целесообразно использовать IDE. Мы рассмотрим наиболее популярные.

Блокнот

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

NetBeans

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

• форматирование кода;
• установка сторонних библиотек;
• простой графический интерфейс;
• и многое, многое другое…

Eclipse

Eclipse, как и Netbeans — одна из наиболее популярных IDE. Она предоставляет впечатляющий интуитивно понятный интерфейс и производительную среду разработки, позволяющую комфортно разрабатывать приложения на Java. Скачать Eclipse можно бесплатно с официального сайта. Преимущества:

• возможность форматировать код так, как вам удобно;
• поддержка разбиения кода на модули;
• лёгкость использования одного и того же кода в разных проектах;
• перетаскивание (drag-and-drop);
• просмотр содержимого библиотек;
• удобный интерфейс.

IntelliJ IDEA

IntelliJ IDEA — известная IDE для Java, написанная, как ни странно, на Java. Укомплектована уникальными инструментами и позволяет без проблем ориентироваться в программе. Нахождение ошибок и отладка кода никогда не были такими легкими, как с IntelliJ IDEA.

JCreator

JCreator — продвинутая и самая быстрая IDE для Java, написанная на C++.

Пишем свою первую программу

Итак, вы установили и настроили JDK, JRE и IDE для Java. Каков следующий шаг? Конечно же, написать программу, чтобы окончательно убедиться, что всё работает и вы готовы к изучению языка. Вы познакомитесь с базовой структурой кода на Java и создадите свою первую программу! Стоит отметить, что перед изучением Java следует ознакомиться хотя бы с самыми простыми принципами объектно-ориентированного программирования.

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

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

Перед тем, как приступить к созданию программы, необходимо создать проект, а в нём и файл, в котором будет содержаться ваш код. Рассмотрим создание проекта на IDE Eclipse, но в остальных IDE процесс отличается не сильно. Cверху выберите «File», затем наведите курсор на «New», в открывшемся меню выберите «Java Project». В появившемся окне введите имя проекта и другие нужные вам настройки (если не уверены, что делать, то можно просто оставить все как есть) и нажмите «Next». Готово, вы создали проект! Осталось лишь создать в нём класс, в котором вы напишете свою первую программу. Щёлкните правой кнопкой мыши по вашему проекту (он должен появиться справа) и выберите «New» → «Class». Присвойте новому классу имя (в данном примере – это first) и нажмите «Finish».

Приступим к написанию вашей первой программы. По традиции — это программа, выводящая на экран «Hello, world!».

			public class first{
     public static void main(String args[])
     {
         System.out.println("Hello, world!");
     }
 }
		

Разберём по частям написанное нами:

• public – это модификатор доступа, определяющий, из какой части программы может использоваться наш класс. В вашем примере public — это весь код;
• class – ключевое слово, показывающее, что вы объявляете класс, а не что-либо иное;
• first – имя вашего класса. Круглые скобки определяют начало и конец кода класса;
• public static void main(String args[]) – объявление публичного статического метода (то есть который можно вызвать, не создавая объект класса). Метод в примере ничего не возвращает и принимает в качестве аргументов массив строк. Единственная команда в этом методе выводит в консоль сообщение «Hello, world!». Заметьте, вместо println можно написать print, разница лишь в том, что в случае с println дополнительно выведется символ переноса строки.

Хорошо, вы написали вашу первую программу. Теперь её надо запустить. Для этого просто нажмите белую стрелочку в зеленом кружке на верхней панели (при наведении курсора на неё должно высветиться «Run»). После нажатия внизу откроется консоль, в которой вы увидите сообщение “Hello, world”! Поздравляю, вы написали вашу первую программу на Java и готовы погрузиться в увлекательный мир этого языка!

Полезные ссылки для дальнейшего изучения

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

• документация Oracle по стандартной библиотеке языка;
• уроки по Java от Oracle;
• теория объектно-ориентированного программирования;
• хорошая книга-самоучитель;
• большое количество интересных и полезных статей про Java на русском языке.