TeachPro.ru с нами 25711 ученика, скачано 11702 курса, подключено 317 школ
text

Программирование на языке Java

Содержание

Введение

Среда программирования

Установка языка Java

Компиляция и выполнение простой программы

Текстовый редактор TextPad

Апплеты

Основные структуры языка

Простая программа на языке Java

Простая программа на языке Java. Комментарии

Типы данных. Переменные. Целые числа

16-ричные, 8-ричные и действительные числа

Символьный и булевый типы данных

Операторы. Арифметические действия

Битовые операции. Математические функции

Операторы. Преобразования типа

Строки. Создание, слияние, выделение подстроки, длина строки

Строки. Изменение, сравнение, работа с ними

Ввод данных с диалоговым окном и операции с ними

Форматирование данных для отображения на консольном окне

Основные структуры языка (продолжение)

Оператор if. Синтаксис

Оператор if. Составной оператор. Вложение операторов if

Операторы цикла do

Операторы цикла for

Оператор switch

Прерывание потока управления. Оператор break

Большие числа. Арифметические операции

Большие числа. Сравнение. Вычисление с большой точностью

Одномерные массивы. Создание. Инициализация. Число элементов

Одномерные массивы. Копирование. Сортировка

Многомерные массивы. Создание. Инициализация

Многомерные неровные массивы

Объекты и классы

Классы. Первое знакомство. Создание класса и объектов

Начальная инициализация. Конструктор класса

Методы класса

Создание нового класса

Наследование

Создание собственных классов. Конструкторы. Методы

Модифицирующие методы и методы доступа

Доступ к закрытым данным

Использование нескольких исходных файлов

Блок инициализации. Статический блок. Статические поля

Статические методы

Конструкторы. Перегрузка конструкторов

Конструкторы. Перегрузка методов

Пакеты

Автоматическое создание документации

Вставка дополнительных комментариев в документацию

Классы. Наследование

Создание подкласса. Вызов родителя

Замещение

Иерархия наследования. Абстрактные классы

Иерархия наследования. Абстрактные методы

Конкретная реализация абстрактных классов и методов

Метод equals

Метод equals. Сравнение подклассов

Метод equals. Выявление одинаковых объектов

Метод equals. Наследование

Метод toString

Списки массивов. Создание

Списки массивов. Изменение и добавление элементов

Списки массивов. Вставка и удаление элементов

Интерфейсы и внутренние классы

Интерфейсы. Требуемые методы

Интерфейсы. Применение

Создание интерфейса

Использование разных критериев в интерфейсе

Обратный вызов (callback). Вызов таймера

Обратный вызов. Выполнение действий с определенной периодичностью

Клонирование простых объектов

Клонирование объектов, содержащих ссылки на другие объекты

Внутренние классы. Создание

Внутренние классы. Пример реализации

Локальные и безымянные классы

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

Пример с использованием статических внутренних классов

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

Создание фреймов

Задание позиции и размеров фрейма

Задание заголовка, иконки и др. параметров фрейма

Отображение текста на панели. Создание фрейма

Размещение текста на фрейме

Отображение прямоугольников

Отображение эллипсов

Отображение многоугольников

Цвета. Задание цвета фона и фигур.

Задание оттенков цвета. Получение цвета случайным образом

Библиотека java 2D.Отображение прямоугольников

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

Библиотека java 2D. Отображение линий, секторов, кривых

Библиотека java 2D. Масштабирование, поворот и сдвиг

Форматирование текста

Шрифт, начертание и размер текста. Наклонный текст

Вывод текста в центр фрейма

Рамка вокруг текста

Работа с изображениями

Отображение рисунка на окне приложения

Повторяющиеся отображения рисунка

Вращение. Отслеживание процесса загрузки

Отсечение рисования. С помощью простой фигуры

Отсечение рисования. С помощью сложного контура

Режимы взаимодействия цвета фигуры и основы при отсечении

Заполнение фигуры изображением из файла. Копирование областей

Обработка событий

Обработка щелчка на кнопке. Внешний вид приложения

Обработка щелчка на кнопке. Обработчик события

Щелчок на нескольких кнопках. Создание обработчиков событий

Щелчок на нескольких кнопках. Создание одного обработчика для нескольких кнопок

Превращение компонентов в слушателей событий

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

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

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

Получение события, связанного с нажатием и отпусканием клавиши и щелчком

События связанные с клавиатурой для работы с фреймом. Ввод символа

События связанные с клавишами навигации

Событие "щелчок мыши" в приложении. Отрисовка эллипса при щелчке

Отрисовка цветного эллипса при щелчке

Использование в приложении события "двойной щелчок мыши"

Использование в приложении событий "движение мыши" и "перетаскивание"

Действия и интерфейс "Action". Использование интерфейса

Действия и интерфейс "Action". Нажатие на кнопку

Действия и интерфейс "Action". Горячие клавиши. Всплывающие подсказки

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

Реализация передачи нажатия на кнопку нескольким фреймам

Компоненты пользовательского интерфейса

Компоновка, поля и области

Введение в управление компоновкой. Поведение компонентов при изменении размеров фрейма

Расположение нескольких панелей на фрейме

Сеточная компоновка. Пример расположения кнопок калькулятора

Задание размера фрейма по размерам своих составляющих компонентов

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

Вычисления с кнопками калькулятора. Тестирование и модификация

Текстовое поле для ввода. Создание и инициализация

Текстовое поле для ввода. Обработчики событий

Поле для ввода пароля. Создание и инициализация

Поле для ввода пароля. Обработчики событий

Поля для ввода чисел

Поля для ввода чисел, денежных сумм и дат

Поля для ввода URL адресов. Поле для ввода с шаблоном

Текстовые области. Создание

Текстовые области. Вставка текста

Текстовые области. Режим переноса.

Текстовые области. Вставка текста (продолжение)

Текстовые области. Очистка

Текстовые области. Поиск. Замена

Элементы управления

Метки

Флажки. Создание

Флажки. Обработчик событий

Группы переключателей. Создание

Группы переключателей. Инициализация и обработчик событий

Рамки. Утопленные, приподнятые

Рамки. Изменение внешнего вида в процессе работы приложения

Рамки. Рамки с заголовком

Рамки. Рамки разного рода

Комбинированный список. Создание и инициализация

Комбинированный список. Обработчик событий

Ползунковые регуляторы. Создание

Ползунковые регуляторы. Обработчики событий

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

Компонент JSpinner. Изменение чисел и дат.

Компонент JSpinner. Отображение названий шрифтов.

Меню, панели инструментов, диалоговые окна

Меню. Создание пунктов

Меню. Разделители. Обработчики событий

Меню. Пиктограммы в пунктах меню. Переключатели

Меню. Переключатели. Блокирование и разблокирование пунктов меню

Меню. Группы переключателей

Меню. Назначенные и ускоряющие клавиши

Меню. Всплывающее меню

Панели инструментов. Размещение элементов на фрейме

Панели инструментов. Создание и размещение на фрейме

Панели инструментов. Размещение кнопок на них

Панели инструментов. Размещение переключателей на них

Подсказки

Диалоговые окна. Окно сообщения

Диалоговые окна. Окно подтверждения

Диалоговые окна. Окно выбора вариантов. Окно ввода

Создание диалоговых окон. Модальное окно. Задание размеров

Создание диалоговых окон. Модальное окно. Задание его элементов

Создание диалоговых окон. Немодальное окно

Выбор файлов и цветов. Компоновка

Выбор файлов. Вызов диалога

Получение результата диалога. Фильтрация файлов

Выбор цвета при помощи модального окна

Выбор цвета при помощи немодального окна

Отслеживание изменений в диалоговом окне

Блочная компоновка. Одна строчка компонентов

Несколько строчек компонентов с разным взаиморасположением

Компоновка сеточного мультимножества. Создание компонентов приложения

Определение взаиморасположения компонентов

Выравнивание и весовые поля

Аплеты

Создание простого апплета

Преобразование приложения в апплет

Архивы jar

Упаковка ресурсов в архивы jar

Всплывающие окна в апплетах. Создание кнопки

Всплывающие окна в апплетах. Обработчик событий

Передача параметров апплетам. Создание передаваемых параметров на html странице

Чтение параметров в апплете

Передача параметров апплетам. Построение гистограммы на их основе

Создание анимированных гистограмм на основе параметров из Web страниц

Создание цветных анимированных гистограмм на основе параметров из Web страниц. Создание нескольких вариантов страниц

Апплет с закладками. Создание

Апплет с закладками. Передача адресов для закладок в качестве параметров

Потоки и файлы

Хранение параметров настройки приложения. Класс Properties. Внешний вид приложения

Класс Properties. Создание

Класс Properties. Сохранение параметров при закрытии приложения

Класс Preferences. Инициализация

Класс Preferences. Сохранение параметров при закрытии приложения

Чтение и запись текстовых файлов. Создание потока записи

Чтение и запись текстовых файлов. Чтение ранее записанного текста

Чтение и запись текстовых файлов. Русский текст

Запись данных объектов в файлах с разделителями. Использование отдельного метода для записи одного объекта

Реализация метода для записи объекта

Чтение данных объектов из файлов с разделителями

Получение информации о полях объекта

Файлы с произвольным доступом. Запись. Позиционирование

Файлы с произвольным доступом. Запись полей

Файлы с произвольным доступом. Чтение

Сохранение объектов

Сохранение однородных объектов с помощью сериализации

Сохранение объектов переменного типа с помощью сериализации

Сохранение объектов с ссылками с помощью сериализации

Работа с файлами и каталогами.

Работа с файлами и каталогами. Создание внешнего вида приложения

Работа с файлами и каталогами. Получение списка каталогов

Работа с файлами и каталогами. Получение списка файлов

Исключительные ситуации и отладка

Перехват исключительных ситуаций. Создание исключительных ситуаций

Перехват исключительных ситуаций. Оператор try

Обзор разных исключительных ситуаций

Переполнение, ошибка ввода-вывода

Класс Robot. Имитация работы клавиатуры. Создание внешнего вида приложения

Класс Robot. Имитация работы клавиатуры. Ввод символов

Класс Robot. Имитация работы клавиатуры. Движение курсора

Класс Robot. Имитация работы мыши

Класс Robot. Сохранение части изображения экрана

Другие курсы

Самоучители по ПП фирмы Microsoft на русском языке

TeachPro Windows 2000 Professional

TeachPro Word 2000

TeachPro Excel 2000

TeachPro Access 2000

TeachPro PowerPoint 2000

TeachPro Outlook 2000

TeachPro FrontPage 2000

TeachPro Internet 2000

Самоучители по графическим пакетам

TeachPro Adobe PhotoShop6

TeachPro Adobe Premiere6

TeachPro Adobe Illustrator9

TeachPro Adobe PageMaker7

TeachPro 3D Studio MAX4

TeachPro CorelDRAW10

TeachPro Утилиты

TeachPro AutoCAD 2002

Уроки

ВведениеК оглавлению

Другое преимущество языка Java заключается в том, что он очень похож на синтаксис языка C++. И программисты, которые работают в основном на этом языке и привыкли к этому синтаксису, довольно легко переходят на язык Java и в нем довольно быстро адоптируются. Надо сказать, что язык Java, это полностью ориентированный язык, даже в большей степени, чем сам C++. Причем надо сказать, что разрабатывать программы, не содержащие ошибок, на языке Java гораздо легче, чем на языке C++, поскольку разработчики снабдили язык Java средствами, позволяющими исключить достаточно распространенные ошибки.

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

Рассмотрим основные характеристики языка Java. Первая из них, это то, что язык Java является достаточно простым языком. По существу синтаксис языка Java представляет собой очищенный вариант языка C++, в котором нет заголовочных файлов, арифметики указателей, самых указателей, структур, объединений и т.д. По сравнению с обычными, визуальными средами программирования, которые на данный момент используются достаточно широко, например, Visual Basic, язык Java может показаться сложным. И при работе на языке Java приходится гораздо больше программировать и писать коды. В отличие от визуальных средств программирования, которые позволяют почти автоматически создавать всю инфраструктуру приложения, весь его внешний вид. А на языке же Java необходимо программировать довольно много чего вручную.

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

Особенностью языка программирования Java к тому же является и то, что он, так же, как и подавляющее большинство современных языков программирования является объектно-ориентированным. И надо отметить, что объектно-ориентированные особенности языка Java и языка C, довольно похожи друг на друга. Надо отметить еще такую особенность языка Java, как-то, что он является распределенным языком. Т.е. он предоставляет мощные и удобные средства для работы в сетях, обладая большой библиотекой для передачи данных на основе таких протоколов, как, например, TCP IP, HTTP, FTP и т.д., которые широко используются в Интернете. И надо отметить, что на языке Java даже самые трудные задачи, например, такие как открытие и закрытие сетевых соединений, решаются очень легко. Механизм, состоящий из так называемых servlet, делает работу на сервере чрезвычайно эффективной, и это поддерживается многими популярными веб-сервирами.

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

Надо еще отметить такую особенность языка, как то, что он является достаточно безопасным при работе в сетях. Конечно, надо сказать, что абсолютно точно этого гарантировать нельзя, и в принципе в механизме безопасности языка Java были определенные проблемы. Но надо сказать, что группа разработчиков языка Java заявила о своей полной нетерпимости к любым ошибкам в системе защиты. И немедленно исправляет любые возникающие в этой сфере вопросы. И надо сказать, что, учитывая все это, с языком Java можно совершенно безопасно работать в сетях. Ну, например, в Интернете. Можно скачивать программы, написанные на Java, выполнять их на своем компьютере и при этом, никаких нежелательных последствий проявляться не будут. В отличие от такого альтернативного механизма, как технология ActiveX, которая для безопасности использует только цифровые подписи. Но, конечно же, этого совершенно недостаточно. Любой пользователь программного обеспечения Microsoft и этих элементов ActiveX, может подтвердить,

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

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

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

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

Рассмотрим такой аспект использования языка Java, как его работа в Интернете. Причем идея эта, достаточно простая. Это просто-напросто пользователи загружают байт кода языка Java, который получается в результате компиляции из Интернета, и выполняют их на своих машинах. И в результате получается, что на веб-странице появляется некая часть, которая отведена под изображение программы Java. Программы Java, которые работают под управлением веб-браузеров, называются аплетами (Applet). Например, в нашем случае, у нас загружена программа Internet Explorer, внутри которой находится аплет Java. Вот этот прямоугольник. Загрузка этого аплета напоминает просто-напросто внедрение изображения на веб-страницу. А текст и другие части этой веб-страницы просто-напросто обтекают этот аплет.

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

Установка языка JavaК оглавлению

Ну и наиболее полную и современную версию пакета Java, пакет Java2 Standard Edition можно загрузить с сайта компании Sun. Вот с этого - JAVA.SAN.com, на котором находится пакет Java2 Standard Edition, который предназначен для работы в операционных системах Solaris, Linux и, конечно же, Windows.

При этом можно увидеть, какие наиболее популярные версии этого языка Java загружают чаще всего пользователи. Как мы видим, на данный момент разработана Beta версия 1.4.2 и основная версия 1.4.1 языка Java.

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

А если же нам нужны другие языки, то, конечно же, нам понадобится следующая версия, вот эта, которая поддерживает также и другие языки, а не только английский. Если же нам нужна полная версия вместе с компилятором, примерами и т.д., то лучше загрузить вариант Java SDK. Но, конечно, при этом надо учесть, что различные версии этого пакета имеют так сказать различный вес, различный объем.

Минимальная версия, которая нужна для Windows, для поддержки работоспособности аплетов языка Java и программ, занимает около 8 МВ, а полная версия вот эта Java SDK вместе с примерами и вместе с компилятором, занимает около 37 МВ, что надо учесть при скачивании пакета из Интернета.

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

Если мы работаем в системе Windows 98, нам понадобится задавать путь к каталогу наших выполняемых файлов пакета Java, в список путей, по которому операционная система может найти эти файлы. Это нам придется сделать в файле Auto axis bat. Там нам понадобится добавить в путь Path, путь к этим программам. А также понадобится добавить путь к классам.

Ну, это мы сейчас рассматривать не будем, поскольку приблизительно аналогичное нам понадобится сделать в системе Windows XP, которая установлена на нашем компьютере. Правда, сделать это в системе XP, так же, как и в системе Windows 2000, надо немножко в другом месте, не в файле Auto axis bat, а в том месте, где находится описание нашей системы.

Для этого нам надо вызвать меню Start в нашем компьютере. Щелкнем на нем, далее подвести курсор к пункту My Computer, щелкнуть на правую кнопку мыши и выбрать его свойства - Properties. Щелкнем.

Появляются вот эти стандартные свойства нашей системы. А если же мы перейдем на вкладку Advanced (дополнительно), а дальше щелкнем на кнопке Environment Variable (переменные среды), то появляется вот это окно, в котором у нас и находятся все переменные и их значения. И нас интересуют две из них. Это Path, а также CLASSPATH, которые мы и должны изменить. Для того чтобы их изменить, надо щелкнуть на кнопке Edit.

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

В нашем случае это диск D и папка j2sdk с номером версии, и далее папка bin. Это именно та папка, в которую при инсталляции на наш компьютер и устанавливается инсталляционный пакет программы Java. А теперь щелкнем на кнопку ОК, и это изменение у нас зафиксировалось в соответствующей переменной.

Теперь же нам нужно задать еще и путь к нашим классам, для того чтобы правильно работал наш компилятор. Щелкнем теперь на кнопку Edit. Перейдем в конец нашей строки и далее добавим опять точку с запятой и просто-напросто точку, которая означает, что наш компилятор в случае компиляции нашей программы и ее выполнения, будет искать классы в текущей папке, что и означает введенная точка. Щелкнем теперь на кнопку ОК.

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

Компиляция и выполнение простой программыК оглавлению

Для этого подойдем к пункту меню Start на нашем компьютере, щелкнем на нем. Далее Мой компьютер. Далее выберем локальный диск D, поскольку именно на нем инсталлирован наш пакет. Щелкнем на нем дважды.

Вот появились папки и файлы, находящиеся на этом диске. И здесь мы можем видеть папку, в которую инсталлирован наш пакет Java. Щелкнем на нем дважды. И рассмотрим подробнее, какие здесь есть у нас папки. В папке bin у нас находятся все исполняемые файлы, компилятор, программы запуска и т.д.

В папке include находятся файлы с машинно-зависимыми кодами, в папке lib находятся, конечно же, библиотечные файлы. В папке jre находятся файлы среды выполнения программ на языке Java. А в сжатом файле src находятся исходные тексты всех открытых библиотек.

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

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

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

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

Для простых же программ, для которых в основном и предназначен язык Java, удобнее пользоваться в принципе нечто средним между работой в режиме командной строки и интегрированной средой разработки. А именно, каким-либо простым текстовым редактором, который интегрирован с пакета Java. Т.е. в принципе у нас есть один из нескольких возможных вариантов при работе с этой программой. А именно, воспользоваться какой-либо средой разработки. Например, мы можем воспользоваться таким широко распространенной средой Java, как Microsoft Visual Java++, которая дает нам возможность создавать большие пакеты на этом языке.

Мы можем воспользоваться пакетом, который предоставляет компания Borland Java Builder, с помощью которой опять-таки можно создавать достаточно большие пакеты. А можем воспользоваться и программой, которую поставляет сама компания Sun, а именно, Sun ONE Studio. Эту программу опять-таки можно скачать с сайта компании Sun.

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

Вот в принципе весь текст нашей программы, который состоит всего лишь из нескольких строчек. Сейчас останавливаться подробно на этом содержимом не будем, щелкнем на клавишу Esc и, для того чтобы попробовать ее выполнить, первое, что нам надо сделать, это ее скомпилировать. И для этого, в режиме командной строки нам надо набрать следующие строчки. Java, далее буква С, javac и затем имя нашей программы Hello.java.

Hello точка и java. Далее щелкнем на клавише Enter. Мы можем видеть, что, наряду с файлом Hello.java, в котором у нас находился текст нашей программы, появился новый файл Hello.class, который и является исполняемым модулем нашей программы, полученным после компиляции Hello.java.

Сейчас попробуем его запустить в режиме выполнения. Для этого нам нужно набрать java и далее имя нашей программы Hello. Причем, надо отметить, что нам надо набрать именно Hello. Регистр букв имеет существенное значение, он должен быть написан именно так, как мы его используем внутри нашей программы. И без расширения class. Только имя Hello, первая буква Н с большой буквы. Щелкнем на клавише Enter.

Ну, эта программа выполнилась, но пока ничего не видно, поскольку у нас панели навигации закрывают весь наш обзор. Для того чтобы посмотреть, что у нас получилось, щелкнем на клавишах Ctrl+F1. Этим мы скрываем левую панель и открываем вид на нашу командную строку, и то, что там выполняется. И можем видеть, что у нас выполнилась программа java Hello, в результате чего на нашем экране консоли появилась надпись Hello World, что и было целью нашей программы.

Но, в принципе это достаточно простая программа, которая, конечно же, больше ничего и не делает, т.е. только выводит на наш экран вот эту надпись Hello World. Т.е. вот таким путем, путем выполнения так сказать двух строчек. Первая, эта компиляция нашего текстового файла с программы, мы получаем исполняемый модуль, и его запуском, мы уже получаем выполнение и его результаты на нашем экране. И все это можно выполнять в режиме командной строки. Причем не только, конечно же, пользуясь такой оболочкой, как Norton или Far, но и просто, запуская программу с командной строки, прямо из оболочки Windows. Хотя, конечно же, это менее удобно.

Текстовый редактор TextPadК оглавлению

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

И одним из, именно таких текстовых редакторов, является текстовый редактор TextPad, который в принципе соответствует всем стандартам в системе Windows и работа в нем напоминает работу в обычном редакторе Notepad. Этот редактор можно найти на странице www.textpad.com, вот на этой странице, с таким адресом. И при этом, этот текстовый редактор относится к условно свободно распространенным программам.

Установка его достаточно проста. Требования достаточно неприхотливы. Она устанавливается практически на всех компьютерах при любой версии Windows, от Windows 95 до Windows ХР.

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

Вот появляется стандартное окно открытия файлов, в котором, как мы видим, в строке выбора типов файлов выбран тип Java. Хотя, если мы щелкнем на треугольнике, то можем видеть, что в этом же текстовом редакторе можно редактировать и файлы C++, html файлы, и т.д.

Но, сейчас нас интересуют файлы Java. Откроем сейчас директорию 1, в которой и находится наш пример Hello, выберем этот файл, и щелкнем на кнопке Open.

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

И первое, что нам надо сделать, это его скомпилировать. Для этого выберем пункт меню Tools и далее пункт Compile Java (скомпилировать Java программу). Щелкнем на этой команде.

Теперь можно видеть, что в левой части вот этого окна, у нас наряду с окном Hello.java, в котором мы и находимся, появилось еще одно окно Command Results. Если мы на него перейдем, то мы можем видеть, что наша программа была успешно скомпилирована.

Попробуем теперь ее запустить, выполнить ее. Для этого, опять развернем пункт меню Tools и на этот раз выберем пункт Run Java Application, т.е. выполнить программу Java. Щелкнем на этой команде.

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

Попробуем теперь выполнить и запустить другое, более сложное приложение. Для этого опять щелкнем на кнопке Открыть. Мы попадаем в ту же самую директорию, в которой мы были в прошлый раз. Перейдем на Мои документы затем в каталог ImageViewer, щелкнем на нем дважды, и выберем вот этот файл ImageViewer. Это простое приложение, которое позволяет просматривать разного рода графические файлы. Щелкнем на кнопке Open,

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

далее выберем команду Compile Java (скомпилировать), можем переключиться и проверить, что компиляция прошла успешно. А теперь попробуем ее выполнить. Для этого опять меню Tools и Run Java Application (запустить программу Java). Вот, можно видеть окно, которое появилось перед нами.

В принципе оно пока пустое, но у нас здесь есть пункт меню File. Если мы на нем щелкнем, то появляется возможность открывать новые файлы. Щелкнем на команде Open. Появляется вот такое окно, в котором мы можем видеть все файлы, находящиеся в нашей текущей папке, в папке ImageViewer.

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

Выберем, например, вот этот файл и щелкнем на кнопке Open. И вот это изображение загружается в окне нашего приложения.

А если мы еще раз развернем меню File и активизируем команду Open, выберем вот этот файл Tower, щелкнем на кнопке Open, то можно видеть другую картинку. Т.е. таким образом, в этом окне мы можем открывать картинки. Закроем это окно. Для этого в меню File выберем пункт Exit и нажмем на любую клавишу.

АпплетыК оглавлению

Рассмотрим ту самую молекулу, которую мы уже видели в наших предыдущих уроках. Для этого опять щелкнем на кнопке Открыть. Перейдем в Мои документы, далее вот эта папка MoleculeViewer. И, как мы видим, здесь у нас находится два файла, которые представляют Java программы. Это, XYZApp и Matrix3D.

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

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

Для этого подойдем к пункту меню Tools и здесь у нас есть опять-таки две возможности Run Java Application и Run Java Applet. Правда, если мы его запустим, как Run Java Application, то мы получим просто-напросто ошибку, поскольку это программой, как таковой, не является. Это аплет, который встраивается в html страницу, для показа в веб-браузере. Поэтому закроем это окно,

далее опять Tools и выберем команду Run Java Applet. Далее нас спрашивают, из какого html файла мы хотим посмотреть этот аплет. Здесь у нас есть три возможности. Это example1, example2 и example3, в каждой из которых используется этот аплет. Ну, возьмем example2, щелкнем на нем,

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

Сейчас у нас есть возможность двигать изображение. Оно трехмерное. Вот таким образом все это будет выглядеть. Закроем теперь это окно, щелкнем на этом крестике. Если же мы теперь развернем меню Tools

и вновь выберем команду Run Java Applet, опять появляется тот же самый пример, и на этот раз согласимся с показом example1. Щелкнем на кнопке Yes, и на этот раз мы можем видеть, что наш апплет выглядит несколько по-другому. Поскольку в примере example1 этот же апплет используется с несколько другими параметрами. В результате чего рисунок выглядит по-другому. Но опять-таки свойства у него те же самые. Мы можем его крутить таким образом. Закроем это окно. Щелкнем на крестике.

Попробуем теперь загрузить эту html страницу с примером example1 и посмотреть, как же все это выглядит там. Для этого, опять-таки щелкнем на кнопке Открыть. На этот раз тип файлов выберем не файлы Java, а html файлы. Редактор TextPad позволяет это сделать,

и откроем первый же пример example1. Щелкнем на кнопке Open и можем видеть текст нашего текстового редактора, со всеми его тегами и параметрами.

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

Попробуем теперь посмотреть, как же все это выглядит в виде html страницы. Для этого щелкнем на кнопке View in Web Browser. Вот запускается программа Internet Explorer, внутри которой мы можем видеть всякие надписи, MoleculeViewer, example, source и т.д. И среди них изображение нашей молекулы, нашего апплета. Вот этот квадрат и является апплетом, который представляет собой Java программу.

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

Конечно же, тот же самый html файл можно запустить не только из редактора TextPad, но и обычными стандартными средствами Windows. Для этого, например, подведем курсор к панели задач нашего компьютера, запустим Internet Explorer, далее пункт меню File, Open, Browse, далее перейдем в папку MoleculeViewer и откроем какой-либо из примеров. Ну, откроем первый example1. Щелкнем на нем дважды. Далее ОК.

И вот появляется то же самое окно, которое мы только что видели. С теми же самыми надписями и с тем же самым апплетом. В принципе этого и нужно было ожидать. Этот апплет выполняет все то же самое. Мы можем схватить его мышью и крутить нашу молекулу. Т.е. апплет, это абсолютно стандартная для веб-страниц часть, которая может на нем отображаться в виде встроенного окна и выполнять различного рода функции. В частности в нашем случае, это отображать вот такую трехмерную молекулу. Закроем теперь программу Internet Explorer, щелкнем на крестике, вернемся в наше стандартное окно редактирования.

Ну, надо, конечно же, сказать, что все то же самое, в том числе и просмотр апплетов, можно, конечно же, организовать и из командной строки. Вот мы активизировали стандартную командную строку и теперь выполним следующие действия. Во-первых, скроем левую панель, для того чтобы у нас здесь отображалось все то, что мы будем выполнять. Для этого щелкнем на клавишах Ctrl+F1,

и теперь напишем такие строчки. Во-первых, Javac, для того чтобы мы могли скомпилировать. Именно, Javac программа компиляции. Далее XYZApp.Java. Хотя, в принципе процесс компиляции можно и пропустить, поскольку все это здесь уже сделано. А соответствующий файл с расширением Class, уже можно видеть на экране. Перекомпилируем еще раз, щелкнем сейчас на клавише Enter.

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

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

Щелкнем на клавише Enter. Конечно же, еще раз надо напомнить, что большие и маленькие буквы надо набирать точно так же, как это набрано в соответствующем файле. Расширение Class или Java, здесь уже не нужно. Щелкнем на клавише Enter. Можно видеть, что в результате всего этого, мы все-таки допустили ошибку, поскольку нам нужно было запускать не файл XYZApp, а именно example.html, внутри которого находится наш апплет. Что нам в принципе и указали, при помощи вот этого текста нашей ошибки.

В случае необходимости мы можем просмотреть этот текст целиком, для этого надо нажать на клавиши Ctrl+F2, чтобы правая панель тоже исчезла. Вот теперь текст нашей ошибки отображается целиком. Опять нажмем на клавиши Ctrl+F2, чтобы появилась наша панель, и напишем команду appletviewer еще раз.

Теперь, например, укажем файл example1.html. Причем, надо сказать, что программа appletviewer устроена таким образом, что она реагирует только на апплеты, которые находятся на этом html файле, пропуская все остальные строчки изображения, картинки и т.д. Щелкнем сейчас на клавише Enter,

и мы можем увидеть наш апплет, запущенный при помощи командной строки. Но в принципе он выглядит, конечно же, точно также. Щелкнем на крестике. Закроем это окно. И закроем командную строку. Для этого щелкнем на клавише F10. Щелкнем на Yes. И мы вернулись в наше стандартное окно редактирования.

Надо отметить еще одно обстоятельство, а именно, как же наш текстовый редактор TextPad запускает Java программы на компиляцию и выполнение. Для этого мы можем зайти в пункт меню Configure, далее Preferences (опции)

и далее у нас здесь есть пункт Tools, в котором сконцентрированы все те три пункта, которые у нас появляются в пункте меню Tools. Первый из них, это Compile Java, который, как мы видим, состоит из команды javac.exe, той же самой стандартной команды, которую мы выполняли с командной строки. И дальше, в качестве параметра, ему передается имя нашего файла и текущая папка. А у пункта Run Java Application, программой является java.exe, а в качестве параметра, опять-таки имя и папка.

А у третьего пункта Run Java Applet, программой является appletviewer, та же самая программа, которую мы только что запускали. В качестве параметра, опять передаются имя и директория. Щелкнем теперь на кнопке Cancel. Здесь мы ничего менять не будет. Это мы просто-напросто открывали для ознакомления. И мы вновь вернулись в стандартное окно редактирования.

Простая программа на языке JavaК оглавлению

И первое, что теперь нам нужно делать, это написать первую строчку, в которой мы объявим наш класс. Поэтому напишем таким образом public, далее class, и далее имя, которое мы хотим придать нашему классу. Ну, пусть это будет, например, MyFirst.

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

Таких модификаторов доступа всего 3. Это слово public, которое мы только что использовали, также private и protected. Назначение каждого из них мы рассмотрим позже. Следующее слово, это слово class, которое напоминает о том, что все объекты в языке Java находятся внутри классов.

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

Следующим словом, после слова class, является слово MyFirst. Надо отметить, что слово public и слово class, являются так сказать уже внутренними словами Java, т.е. словами, которые входят в базовый словарь языка Java. А слово MyFirst, это уже слово, которое так сказать мы придумали, в качестве названия для слова class.

Вместо MyFirst, могло быть любое слово, которое мы можем себе представить, и которое состоит из букв и цифр. Например, вместо MyFirst, могло быть FirstSample или просто First или My и т.д.

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

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

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

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

и далее напишем такую строчку. Опять public, далее static, void, далее main, String, args, закроем скобки.

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

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

Следующее слово, это слово void, которое означает, что наш метод никакого значения не возвращает. Ну а если бы наш метод возвращал какое-либо значение при выполнении, например, целое, тогда бы мы написали здесь integer или какое-либо другое слово, которое соответствует типу возвращаемого значения. Ну, а слово void означает, что возвращаемого значения, как мы сказали, вообще нет.

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

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

После слова main у нас внутри круглых скобок написано String и args. Что это означает? Это означает те параметры, которые мы хотим передать методу main. Все эти параметры пишутся внутри круглых скобок и разделены между собой точкой с запятой. Ну, сейчас у нас точки с запятой нет, поскольку у нас всего один параметр.

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

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

А теперь же напишем следующую строчку, для написания которой опять чуть-чуть отступим от уровня вот этих фигурных скобок и напишем такую строчку System, далее точка, out, точка, println, откроем скобку

и внутри вот этой обычной скобки, напишем какой-либо текст, который мы хотим, чтобы наша программа выводила нам на окно. Например, введем следующий текст. It is my first program. Далее закроем кавычки, закроем скобку, точка с запятой.

Простая программа на языке Java. Комментарии К оглавлению

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

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

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

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

Вот появился этот текст, и отметим, что вместо метода println, мы могли использовать и метод print, без этих двух букв ln. Но, тогда в этой конкретной программе, ничего от этого не изменится. Но в принципе, разница только в том, что после вывода этой строки, перехода на следующую строку не будет. И следующий текст выведется непосредственно после вот этой строчки. Т.е., например, следующая буква следующего текста выведется после буквы m, сразу же за ней, а не со следующей строки.

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

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

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

Далее создадим новый каталог, который назовем каталогом java, перейдем в эту папку. И внутри нее создадим еще один каталог, который назовем my1. Т.е. это у нас просто будет первый пример. Щелкнем дважды.

И теперь уже, наконец, можем нажать кнопку Save, чтобы внутри вот этого каталога my1, появился файл MyFirst с расширением java. Вот мы уже сохранили эту программу, и, как мы видим, после того, как мы этому текстовому редактору дали понять, что это у нас файл Java, вот эта картинка с нашим текстом, приобрела несколько более живописный вид. Соответствующие фигурные скобки, ключевые слова и т.д. выделены соответствующим цветом. Конечно, в принципе при работе без этого тоже можно обойтись, но это дает дополнительные подсказки для визуализации нашего текста нашей программы.

Теперь же попробуем эту программу скомпилировать и выполнить. Для этого нам нужно зайти в пункт меню Tools, далее выбрать пункт Compile Java. Компиляция прошла успешно, что подтверждается появившейся надписью Tool completed successfully, операция завершена успешно. Перейдем обратно на наш файл Java и попробуем его выполнить.

Для этого опять меню Tools и на этот раз Run Java Application, запустить программу Java на выполнение. Ну, вот появился результат действия нашей программы с надписью It is my first program. Конечно, результат не особенно впечатляет, появилась всего одна строчка, это все, что нам удалось получить в результате действия нашего кода.

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

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

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

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

В языке Java есть несколько способов, ввода в текст нашей программы комментариев. Чаще всего для комментариев используются две косые черты и далее текст комментария. Например, введем после вот этой строчки, которая у нас выводит на окно, вот эту надпись, какой-либо комментарий. Для этого введем здесь две косые черты и далее введем сюда какой-либо текст. Например, напишем таким образом no comment. Точно также, комментарии можно написать не только, к этой строчке, но и к любой другой.

Например, вот к первой строчке. Введем две косые черты и далее my comment. Конечно же, комментарии можно писать не только после какого-либо оператора, но и можно сделать так, чтобы комментарий находились в самом начале нашей строчки.

Например, щелкнем на клавише Enter, освободим строчку, далее введем две косые черты, что означает начало комментария, и далее напишем comment for my text. Если же нам нужно ввести комментарии, которые будут состоять из нескольких строчек, конечно, можно начинать каждую из них с двух вот таких косых черточек,

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

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

далее Compile Java, компилировать. Компиляция прошла успешно. И далее попробуем ее выполнить. Для этого в меню Tools выберем пункт Run Java Application. Мы можем видеть, что результат абсолютно тот же самый. Надписи и It is my first program появились вот в этой первой строчке нашего окна. Закроем программу. Щелкнем на крестике и вернемся в наш обычный режим.

Типы данных. Переменные. Целые числаК оглавлению

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

Надо сосредоточить внимание на том, что после оператора int i, мы поставили точку с запятой, поскольку именной точка с запятой и является разделителем между операторами. Имя переменной может быть практически любое. Единственное ограничение, это то, что первая буква переменной обязательно должна быть именно буквой, а следующие знаки в нашей переменной могут быть буквами и цифрами.

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

Правда, есть ограничения. Символы плюс, минус, знак деления, пробел т.д., нельзя использовать в именах переменных. И еще надо отметить, что регистр клавиатуры имеет существенное значение. Т.е. вот эта переменная i, эта одна переменная. А если мы напишем I с большой буквы, это уж будет совершенно другая переменная.

Например, если мы напишем после этого определения еще int затем I большое, то мы определили две целочисленные переменные, i маленькая и I большая.

Правда, надо отметить одно обстоятельство, что в качестве имен переменной нельзя использовать зарезервированные слова языка Java. Например, вот такие, как public, Class, Static, void, String и т.д.

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

Т.е. у нас теперь определены в этой строчке две переменные. Переменная i целого типа, и переменная Int тоже целого типа. Надо еще отметить то, как мы написали эту строчку. Т.е. мы одним определили int, объявили две целочисленные переменные i и Int, написав между ними запятую. Т.е. таким образом, мы можем одним определением задавать несколько переменных.

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

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

А инициализацию переменной можно проводить и во время ее задания. Например, вот в этой строчке мы можем задавать, что переменной i сразу же задается, например, число 6. А переменной Int, мы с самого начала присваиваем значение 8.

Далее, через запятую зададим еще одну переменную. Например, i1, никакого значения присваивать тут не будем. А присвоим чуть позже, а вот после строчки i равно 5, напишем i1 равно, допустим, 4.

Язык Java является строго типизированным. Это значит, что тип каждой переменной обязательно должен быть объявлен. Мы не можем использовать какую-либо переменную, если она не определена, к какому типу она относится. Типов переменных в языке Java восемь.

Из них 4- это целых типа, 2 - это числа с плавающей точкой, еще один тип, это символьный тип char, используемый для представления символов в формате уникод. И последний, это булевский тип Boolean, применяется для логических величин, которые имеют два значения True или False.

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

Следующий тип, это тип short, который тоже является целочисленным типом. Единственное отличие, что для его хранения требуется всего 2 байтов и соответственно, диапазон его намного меньше от (-32) до +32 тысяч.

Зададим, например, в качестве применения этого типа, например, переменную t, которой присвоим значение 22 точка с запятой. Следующий тип, который у нас есть целочисленный, это тип long, который самый большой в представлении целых чисел и требует для себя 8 байт памяти.

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

И последний целочисленный тип, который можно использовать, это тип Байт. Пусть это будет у нас переменная b. Байт, как видно из самого своего названия, занимает в памяти один байт ровно. И его диапазон меняется от (-128) до 127.

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

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

16-ричные, 8-ричные и действительные числаК оглавлению

Для записи этих чисел в языке Java имеются специальные возможности. Например, присвоим переменной i1 вот в этом месте не число 4, а какое-либо число в 8-рычном представлении. Например, напишем вот таким образом, ноль 10. Это будет означать, что мы i1 присвоили не число 10, а на самом деле число 8, поскольку 10 в 8-рычном представлении, это есть 8. А признаком того, что это число является числом в 8-рычном представлении, является цифра 0, которая у нас стоит перед самим числом 10.

Правда, такая запись чисел, в принципе, достаточно сило противоречит нашим представлениям. Поэтому числа в 8-рычном представлении, в принципе используются достаточно редко. И надо сказать при этом, что вот, например, вот такая запись, 019, будет просто-напросто ошибкой и при компиляции, компьютер выдаст нам ошибку. Потому что цифра 0, которая стоит впереди, указывает калькулятору, что это 8-рычная, а цифра 9, которая здесь используется, явно выпадает из 8-рычного представления числа.

Поэтому, вот, например, 014, это правомерная запись, а 019, конечно же, уже нет. Для записи же числа в 16-рычном представлении, впереди надо приписывать суффикс 0Х. Например, переменной i присвоим какое-либо число в 16-рычном представлении. Для этого напишем таким образом: 0, затем Х и берем 6, далее пусть будет, например, 8 и, например, Б, поскольку для 16-рычного представления числа, кроме цифр от 0 до 9, используются еще буквы: А, В, С, D, E и F, как большие, так и маленькие.

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

Попробуем целые числа, которые мы только что задавали, вывести на окно нашей консоли. Для этого, опять-таки используем вот эту конструкцию System.out.println. Для этого проще всего ее скопировать, выделим. Правая кнопка мыши, Сору.

Вставим ее вот в этом место. Paste. Выровняем. И далее напишем таким образом. Сначала выделим вот это число i. Для этого напишем в кавычках вот это число, 0Х, далее 6а, 8б, точно так же, как и здесь было написано. Равняется. Закрыть кавычки. Плюс. И далее само число i. Закрыть скобку. Точка с запятой. Скопируем еще раз. На этот раз воспользуемся опять правой кнопкой мыши. Далее Paste, поскольку в буфере обмена у нас уже есть эта строчка.

Далее опять кавычки. На этот раз возьмем 014. Мы видим эту переменную i1, равняется, кавычки и напишем переменную i1. Закрыть скобку. Точка с запятой. Опять скопируем вывод, Paste, и выведем вот это большое число D. Для этого опять кавычки, напишем вот это число 3. Затем буква L.

Равняется. Закрыть кавычки. Далее плюс. И число D. Закрыть скобку, точка с запятой. Теперь же скомпилируем эту программу и посмотрим, что у нас получилось. Для этого Tools, далее Compile Java, скомпилировать.

Компиляция у нас прошла успешно. Переключимся на нашу программу и запустим ее на выполнение. Для этого Tools и Run Java Application. И вот результат выполнения нашей программы, мы можем видеть на нашем экране. Вот это 16-рычная переменная, 6а 8б, это на самом деле число 27275.

А 8-рычное число i с индексом, которое означает минус впереди и далее 14, это на самом деле число 12. А вот это большое число с тройкой впереди и с буквой L в конце, это вот такое число. Т.е. все те присваивания к целым числам, которые мы проводили, все они успешно были выполнены. Закроем это консольное окно и вернемся в наш обычный текстовый редактор.

Кроме целых чисел, где в языке Java существует возможность использования и чисел с плавающей точкой, чисел, имеющих дробную часть. Для представления такого типа чисел, в языке Java есть две возможности. Это float, она требует 4 байта для своего представления. Введем переменную такого типа, Пусть эта переменная будет у нас, например, f1.

И переменная типа double. Пусть это будет F2. Для переменной типа double в памяти требуется 8 байт. Это так называемое число с двойной точностью и в нем у нас есть 15 значимых десятичных цифр, в отличие от класса float, у которого приблизительно 6-7 значимых десятичных цифр.

Числа с плавающей запятой типа float и double можно записывать в различных представлениях. Например, переменной F1 присвоим какое-либо значение. Например, просто 14 целых и 3 десятых. Вот такая форма записи. Кроме этого, введем, например, переменную F3, которой присвоим значение 0,78. Как видим, число 0 впереди мы пропустили, это вполне допустимо.

Кроме таких прямых представлений чисел, можно числа представлять и в такой форме. Например, введем переменную F4, которой присвоим значение, например, 6,1е в 15 степени. Для разнообразия зададим теперь переменную типа double. Например, f2 присвоим значение 3141е в - 3 степени. Это приблизительно число пи, как можно заметить.

Зададим еще переменную F5, которой присвоим значение, например, 3е в 10 степени. Вот таким образом можно задавать числа с плавающей точкой. Числа, имеющие дробную часть. Числам, типа float, можно приписывать справа букву F, для явного задания его типа. А если буква F нет, тогда числа по умолчанию считаются типа double. Но им можно и явно приписывать букву D.

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

Попробуем теперь эти числа тоже вывести на наше окно приложения. Для этого опять скопируем вот эту строчку, в которой у нас происходит вывод, используем Paste и далее таким образом. Выведем f1. Далее в качестве разделителя используем 2 пробела, затем закрыть кавычки, выведем число f3. Затем в качестве разделителя опять 2 пробела.

Затем f4. Закрыть скобку, точка с запятой. Теперь выведем числа из второй строчки. Опять правая кнопка мыши и далее Paste. Выведем число f2, затем в кавычках два пробела и затем число f5. Закрыть скобку. Точка с запятой. Попробуем теперь все это скомпилировать и выполнить. Для этого опять пункт меню Tools, далее Compile Java.

В результате компиляции, мы получили три ошибки. Т.е. все три присваивания, и f1, и f3, и f4, там, где мы задавали тип переменной float, у нас оказались с ошибками. В чем тут дело? Дело в том, что, поскольку мы после чисел написали букву F, то, например, вот это число 14, 3 компьютер по умолчанию взял, как double с двойной точностью. И присваивание его числа к переменной, которая является числом с одинарной точностью, произошло соответственно с ошибкой.

То же самое, относительно переменных F3 и F4, во всех трех случаях. Что же нам теперь делать? Как выйти из этой ситуации. Для этого перейдем в наш текст и далее в конце каждого числа, припишем букву f, что будет означать, что мы так сказать, принудительно задаем его спецификацию, как число float, числу с одинарной точностью.

Теперь опять попробуем скомпилировать то же самое, Tools, далее Compile Java, на этот раз, как видно, все прошло вполне успешно. А теперь запустим. Run Java Application.

И можно увидеть, что в результате у нас получилось. Вот 14,3; 0,78, так же, как здесь есть. А вот число 6,1, которое у нас здесь было, задалось в несколько странной форме, 6,0 и далее 999 и 8. Ну, приблизительно, конечно, это 6,1. Это уже ошибка округления данного числа.

А число с двойной точностью, 3,141, которое получилось из вот этого числа 31,41е - 3, и вот это 3е10 у нас конвертировалось в 3,0 с "е" в 10 степени. Закроем теперь окно и вернемся в наше приложение, будем дальше писать нашу программу.

Символьный и булевый типы данныхК оглавлению

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

Он является двухбайтовым кодом, и в нем допускается 65536 символов. Этот формат намного богаче стандартного набора asi2, который представляет собой однобайтовый код, состоящий из 128 символов. Или его расширения, которое состоит из 256 символов, которое на самом деле является подмножеством уникода, и эти символы представляют собой просто-напросто первые 256 его символов.

Символьную переменную можно задавать не только в виде отдельной буквы, но и можно ее задавать просто числом. Хотя, конечно, оно числом не является. Тогда, просто-напросто берется соответствующая буква из набора уникода, которая соответствует этому порядковому номеру. Например, возьмем переменную с2 и присвоим ей значение 66.

Также возьмем переменную с3, которой сопоставим значение 66 в 16-рычном представлении. Для этого напишем, таким образом, 0Х и 66. Вот эти два, конечно же, должны быть две различные буквы с2 и с3. Кроме этого, то же самое можно задавать и таким образом, с4 переменная, равняется, далее кавычки, внутри которых напишем таким образом. Косая черта U, что означает управляющий символ, который показывает, что дальше будет идти 16-рынчная величина, состоящая из 4 цифр.

0066, закрываем кавычки. Так вот, с4 и с3, должна быть одна и та же буква. Попробуем теперь вывести все это на печать. Для этого Enter, далее правая кнопка мыши и Paste. Далее выведем все эти переменные на экран. Для этого напишем таким образом, с1+с2+с3+с4. Закрыть скобку, точка с запятой.

Если теперь мы попробуем скомпилировать и запустить эту программу, то получим следующее. Скомпилируем сначала. Щелкнем на пункте Compile Java. Компиляция прошла успешно. Теперь ее запустим. Run Java Application.

И если посмотреть теперь на консольное окно, то получим несколько неожиданный ответ. Там, где у нас должны были получиться 4 буквы, мы получили 341. В чем дело? Дело в том, что, так как мы написали вывод на печать, с1+с2+с3+с4, он просто-напросто сложил вот эти 4 значения, просто, как целые числа. Но и в результате получили некое целое число 341. Закроем это консольное окно.

Попробуем сделать по-другому. Для того, чтобы компьютер понял, что мы хотим вывести именно в виде буквы с1+с2+с3+с4, введем вначале просто-напросто вывод пустого знака. Далее плюс. Теперь попробуем опять скомпилировать. Compile Java.

Все прошло достаточно успешно, и теперь запустим наше приложение. Ran Java Application. И вот в результате как раз мы и получили 4 буквы. J, B, F и F. Как видим, последние две буквы совпадают. Вот эти два представления в виде 66 и в 16-рычном виде. И в таком виде они выдают нам одну и ту же букву F. Закроем это окно, и мы опять вернулись в наш обычный текстовый редактор.

Кроме префикса, косая черта U, которая означает символ в формате уникода, есть еще несколько управляющих символов. Это такие, как возврат на одну позицию, которая выдается, как косая черта и маленькая буква "b". Вот таким образом. Можно задавать символ табуляции. Это будет косая черта и буква "t", символ, при помощи которой можно перейти на следующую строку, это косая черта и буква "n".

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

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

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

И далее, в конце, еще знак возврата на одну позицию назад. Это у нас будет косая черта и b. Далее плюс и введем еще одну какую-нибудь букву. Пускай выведем букву o. Закрыть кавычки. Мы здесь забыли ввести управляющий символ, косая черта.

Попробуем теперь это скомпилировать и посмотрим, что у нас получилось. Tools, далее Compile Java, скомпилируем. Все прошло успешно. Теперь запустим наше приложение Run Java application. И вот можно посмотреть, что у нас получилось. В начале мы ввели знак кавычек. Вот при помощи этого символа. Затем у нас косая черта из переменной с1.

Затем буква Б, это у нас переменная с2 дальше у нас перевод строки. Вот этот управляющий символ косая черта и n, в результате чего мы перешли на новую строчку. Затем у нас С3 и С4, как мы помним, они оба должны были вводить букву F. Одна буква F есть, а второй буквы F нет, поскольку вместо нее у нас произошел возврат на одну позицию назад и затем мы на эту букву F сверху, так сказать написали цифру 0. В результате одна буква F у нас затерлась. Т.е. все получили все так, как мы и задавали. Закроем теперь это окно приложения.

Рассмотрим последний тип переменной, это переменная типа Boolean. Пусть эта переменная у нас будет переменная ВВ и она может принимать два значения, True или False.

Пусть ВВ принимает значение True, а зададим другую переменную, В1, которой присвоим значение False. Точка с запятой. Надо отметить, что в отличие от языка C, тип переменной Boolean, никакого отношения к целым числам не имеет.

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

Теперь попробуем скомпилировать. Compile Java. Компиляция прошла успешно, и теперь запустим нашу программу. Вот, что получилось в результате всего этого. Вот компьютер нам в последней строчке вывел эти значения, True и False.

Закроем окно нашего приложения и выйдем в наш обычный режим. В языке Java, кроме переменных, можно использовать и контакты, для обозначения которых используется ключевое слово final. Например, вот эти две переменные В и В1 представим в виде констант. Для этого впереди, перед словом Boolean напишем слово Final.

Что будет означать, что эти два идентификатора В и В1 являются константами, т.е. присвоить им значения можно только один раз. Если же нам нужно употреблять константу, которой будут доступны нескольким методам внутри одного класса, тогда они называются константами класса и тогда перед словом Final нужно написать еще слово Static. И тогда константы такого класса будут задаваться вне метода mine. И в этом случае ее можно будет использовать в других методах того же класса.

Например, зададим его вот в этом месте. Щелкнем здесь на Enter и далее напишем, таким образом, public, далее static, final, поскольку это константа и далее переменную, какого типа мы хотим задавать. Например, пусть эта будет double. Число с плавающей точкой двойной точностью

Возьмем эту переменную, как пи и введем для него численное значение. Например, такое, 3,14. Это, конечно, не точно, но все-таки это в каком-то приближении число пи.

Операторы. Арифметические действияК оглавлению

Откроем новую папку, которую назовем My2. Щелкнем на ней дважды, чтобы туда зайти и выберем имя нашего файла. Как мы помним, оно должно быть точно такое же, как и название нашего класса, причем с учетом регистра. Т.е. первая буква М, в нашем случае должна быть большая. Наберем My2 и щелкнем на кнопку Сохранить. Тип файла Java у нас есть, поэтому все остальное у нас остальное нормально.

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

Например, создадим переменную a класса integer, присвоим ей значение, например, 1+3, далее возьмем опять целое число, пусть это будет b, которому присвоим значение a умножить на 3, точка с запятой. Далее возьмем целое число c, которому мы присвоим значение b деленное на 5, например. Точка с запятой.

Затем возьмем целое число d, которому присвоим значение b-a. Ну и тут же на этой же строчке возьмем еще одну переменную c, которой присвоим значение минус d.

Теперь же попробуем все эти числа вывести на наше консольное окно. Для этого воспользуемся вот этим оператором println. Выделим его. Далее правая кнопка мыши, Сору. И сюда вставим. Правая кнопка, Paste.

Теперь напишем таким образом, кавычки, это у нас сначала будет переменная А, далее плюс и выведем ее значение a. Закроем скобку. Точка с запятой. Правая кнопка. Paste. Выведем на этот раз переменную В. Далее то же самое с переменной c.

И затем то же самое с переменной d. И последняя переменная, это переменная e. Тут мы допустили ошибку, у нас c повторяется два раза. Конечно же, следующую переменную нужно было обозначить, следующей буквой e. Вставим сюда и выведем на экран значение переменной e. Закрыть скобку. Точка с запятой.

Введем еще одну переменную. Пусть эта будет f, которой присвоим значение, например, b и остаток по модулю, т.е. вот этот значок проценты и далее 5. Остаток по модулю при делении на 5. Выведем значение этой переменной на экран. Правая кнопка мыши, Paste, далее f, равняется и его значение.

Теперь же скомпилируем эту программу. Для этого, как всегда нам нужен Tools. Далее Compile Java. Компиляция прошла успешно, и поэтому теперь мы можем его запустить на выполнение. Для этого Tools и Run Java Application. Вот мы видим результат выполнения нашей программы. Первой строчкой является та строка, которая у нас была здесь: 'it is program My2'. А далее у нас идут значения наших переменных. Переменная a равна 4, что в принципе и понятно, b - это у нас будет 4 умноженное на 3, будет 12, а c у нас будет 2,

поскольку получается, как деление b на 5, но поскольку целиком 12 на 5 не делится, то это у нас целочисленное деление. Далее у нас значение d, которое равняется b-a, 12- 4=8, все правильно и затем переменной e мы присвоим значение d с обратным знаком. Получается (-8). И последнее значение f, это целочисленное деление числа b, которое равно 12, на 5, что остается в остатке число 2. Закроем это окно, щелкнем на этом крестике.

Наряду с обычными арифметическими операциями, широко используется и арифметические операции сокращенного вида, которая позволяет выполнять дополнительные операции. Например, вместо операции a, равняется a+4, вот вместо этой операции можно написать операцию при помощи вот этого оператора плюс равно. Т.е. вместо него, можно написать такое выражение, что несколько сокращает внешний вид этой строчки. a+ =4. Что по результату абсолютно одно и тоже.

Такие сокращения операторы обычно получаются приписыванием пред символом равно, соответствующих арифметических символов - плюс, минус, умножения и т.д. Выполним еще несколько операций. Увеличим, b, например, в 3 раза. Для этого пишем b, далее знак умножения равно и 3. переменную c тоже увеличим. Плюс - равно. Увеличим на значение a+b. И далее напишем значение c, как остаток по модулю от деления, например, на 5.

Теперь же выведем все эти значения a, b и c на экран. Для этого нам вполне нужно скопировать вот эти 4 строчки. Выделим. Далее правая кнопка мыши и Сору. Вставим сюда. Правая кнопка и Paste. Теперь, единственное нам, осталось выполнить еще одну операцию с переменной d, с ней мы ничего не делали. Поэтому, например, для d применим вот этот последний неиспользуемый нами оператор: минус равно, т.е. увеличим значение d на какое-либо выражение. Например, уменьшим на 3 единицы.

В принципе мы можем выровнять все эти строчки, чтобы все они были одинаковыми. И после этого, попробуем скомпилировать эту программу. Для этого, пункт меню Tools, далее Compile Java, все прошло успешно. Переключимся на Java и запустим теперь наше приложение Run Java Application.

Вот мы можем видеть результат выполнения нашей программы. Число "a" у нас увеличилось на 4. Если оно раньше было 4, еще 4. то получилось значение 8. "b", же у нас увеличилось в 3 раза. Вместо 12 стало 36. "c", после выполнения вот этих двух операции, увеличение на a+b и далее целочисленное деление на 5, стало единицей, как остаток от деления на 5, а "d" мы уменьшили на 3 и вместо 8 стало 5. Т.е. все операции опять у нас прошли нормально.

Закроем теперь это приложение. Щелкнем на этом крестике и вернемся в наш обычный текстовый редактор. Программисты, которые часто сталкиваются с разного рода программами, конечно же, знают, что одним из самых распространенных действий над числовыми переменными, являются увеличение и уменьшение их значения на единицу. И для этих действий, так же, как и в языке Сi и C++, в языке Java есть специальные операторы.

Например, если мы напишем, таким образом, a++, то после выполнения этой операции, значение a увеличится на единицу. А если напишем b--, то b уменьшится на единицу.

Эти операторы ++ и --- можно использовать не только отдельно, для увеличения и уменьшения на единицу, но и внутри выражения. Например, таким образом. Создадим переменную типа integer k1, пусть его значение будет 5. Запятая. Создадим еще переменную k2, которой присвоим тоже значение 5 и далее напишем такие выражения: int s1, которое будет равняться 2 умноженное на ++ k1.

Теперь напишем, практически, такое же выражение: int s2, равняется 2 умножить, но напишем теперь не ++ k1, а k2 и затем ++, т.е. переставим плюс и переменную местами.

Посмотрим теперь, что у нас получилось. Для этого выведем это значение на экран, скопируем вот эту строчку. Правая кнопка мыши, Сору. Далее вставим сюда. Правая кнопка мыши, Paste. Выведем значение k1. Для этого напишем, таким образом, в кавычках k1 равняется, затем само значение k1. Теперь выведем значение s1. Равняется. s1, закрыть скобку, точка с запятой.

Теперь опять вставим этот текст. Paste. Кавычки. На этот раз нам нужно значение k2. Равняется. Кавычки. Само k2. Теперь выведем s2. Кавычки и плюс s2. Теперь попробуем скомпилировать эту программу и выполнить ее. Для этого Tools, Compile Java. Все прошло успешно, и теперь запустим саму программу: Run Java Application.

И вот можно видеть, что у нас получилось: k1 и k2 у нас стало по 6 их значение. Мы присвоили им 5 и далее при выполнении вот этих выражений, каждая из них увеличилась на единицу, в связи с тем, что около них не написали ++. А вот значение s1 и s2 у нас разное. s1 - 12, а s2 - 10. Дело в том, что если ++ у нас написан спереди, то сначала происходит увеличение k1 на единицу и затем вот это полученное выражение 6, уже используется для дальнейших вычислений. В результате чего и получается 6х2=12.

А при вычислении s2, тут дело происходит немножко по-другому. Для вычисления вот этого выражения s2, берется старое значение k2, 5 и 2 раза 5 получается 10, и лишь после этого k2 увеличивается на единицу. Закроем теперь это окно. Щелкнем на вот этом крестике.

Битовые операции. Математические функцииК оглавлению

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

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

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

В нижней таблице приведены действия этих операторов, если у нас есть один бит, А и В, и их значения, вот такие, как внутри таблицы, то в случае действий операторов or, and, xor и not A принимают вот такие значения, как видно из таблицы.

В языке Java, наряду с обычными операторами, которые работают с целыми числами, действительными и т.д., есть и операторы, которые работают с булевыми выражениями и булевыми переменными. Это такие операторы, как and, or, xor и т.д. Вот этот оператор, оператор "и ", следующий оператор, оператор "или".

Далее оператор xor, исключающий "или", и следующие два оператора, это операторы or и and с быстрыми вычислениями. Т.е. при этих двух операторах, выражение до конца не вычисляются, если ее значение получается уже при выполнении первого из операндов.

Следующей, это оператор отрицания not, но далее три оператора, которые повторяют, оператор "и", "или" и исключающий "или", но вместе с присваиванием. А также есть оператор проверки на равенство, равны ли два выражения друг другу, и оператор проверки, если два выражения не равны друг другу.

А также есть оператор, который заменяет оператор if-then-else. Ниже, в этой таблице приведены результаты работы операторов or, and, xor, и not A, "и" , "или", и, исключающий "или", при различном значений первого и второго операндов А и В, для булевых выражений.

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

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

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

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

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

Например, чтобы извлечь квадратный корень, для этого у нас есть специальная функция sqrt. Зададим переменную с двойной точностью, double. Пусть эта переменная x, которая будет равна 2.

И затем зададим еще одну переменную с двойной точностью. Пусть это у нас будет y, которая будет равняться корень из x. Для этого напишем таким образом: math, тот класс, в котором у нас сосредоточены все математические функции и далее sqrt. И далее в скобках x.

Вот теперь у нас к y будет присвоено значение корня из x, т.е. корня из 2. Выведем это число на экран. Для этого скопируем эту строчку. Выделим. Правая кнопка мыши. Сору. Встанем сюда. Правая кнопка мыши и Paste.

И теперь напишем таким образом. Переменная y равняется, и само значение y. Закрыть скобку, точка с запятой.

Теперь скомпилируем и выполним эту программу, для этого Tools, далее Compile Java, теперь опять Tools и Run Java application, вот можем видеть, чему равняется корень из 2, 1,4 и т.д. Все цифры по порядку. Закроем это окно.

Кроме корня квадратного, в классе math, еще много всяких математических функции. Это такая функция, как pow, которая реализует возведение числа в степень, в корень мы уже видели. Далее синус, косинус, тангенс, котангенс, это все обычные тригономические функции.

Далее экспонент и логарифм, и две математические константы, это Pi и e. Например, попробуем возвести какое-нибудь число, например, Pi в какую-либо степень при помощи возведения pow.

Для этого воспользуемся следующим способом. Напишем, таким образом, Double число с двойной точностью, пусть это будет у нас xx, равняется, и далее напишем, таким образом, math, точка, pow.

Далее возведем число Pi, math Pi, ну, например, в степень "е", math "е". Закрыть скобку. Точка с запятой. Теперь попробуем это все вывести на окно. Для этого правая кнопка мыши и Paste.

Теперь напишем, что это у нас переменная x. И выведем ее значение. Закрыть скобку, точка с запятой. Если же мы сейчас скомпилируем эту программу, и запустим, Tools, Run Java application, то мы можем удовлетворить наше любопытство и узнать, чему равняется число "пи" в степени "е".

Это 22 целых и т.д. Закроем теперь это окно и вернемся в наш обычный текстовый редактор.

Операторы. Преобразования типаК оглавлению

Это преобразование из байта в short, из short в integer, и из integer в long, а также из char в integer, происходит без всяких потерь, так же, как преобразование из числового типа float в double, а также из integer в double.

А вот преобразование из long в double, из integer в float, а также из long в float, может происходить с потерей точности. Например, создадим целочисленную переменную типа int n1, которое у нас будет равняться 123456789.

При преобразовании его к типу float, пусть это будет f1, равняется n1, как раз и будет происходить потеря точности. Посмотрим, как это происходит. Для этого скопируем вот этот вывод на консоль. Правая кнопка мыши, Сору, далее вставим сюда, правая кнопка мыши, Paste.

Выведем n1 и f1 на печать. Для этого напишем, таким образом, n1 равняется, n1. И далее выведем f1. Закрыть скобку. Точка с запятой.

Попробуем это скомпилировать. Для этого Tools, далее Compile Java, далее Tools и Run Java application. И можно видеть результат, который мы получили: n1, это точное значение, как мы задавали 123456789.

А f1 у нас даже, если учесть, что у нас 10 в восьмой степени, тем не менее, как мы видим, 567, а затем, вместо 89 у нас 92, произошла некоторая потеря точности. Закроем теперь это консольное приложение.

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

И происходит это по следующему законам. Если, хотя бы один из них, или тип double двойной точностью, то второй тоже преобразовывается к такому же типу. Если же этого нет, и один из операторов имеет тип float, действительный, тогда второй же преобразовывается к этому же типу. Если же оба числа целые, и один из оперантов имеет тип long, тогда второй тоже преобразовывается к типу длинного целого, к типу long.

Ну и, в сущности, если оба операнда не являются не действительными, и не длинными целыми, тогда оба операнда преобразуются к типу integer (int). Очень часто, при написании программ, нам требует и обратная операция. Т.е. преобразование, например, от действительного числа к целому.

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

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

Далее в скобках мы должны указать непосредственно, какой тип преобразования нам нужен. Нам нужен тип Int. Преобразование к типу Int, целому и далее саму переменную. Это переменная f1.

Выведем теперь это число тоже. Для этого воспользуемся опять буфером обмена. Щелкнем на правую кнопку мыши, Paste и далее напишем, таким образом, n2, равняется, и само значение n2. Закрыть скобку. Точка с запятой.

Скомпилируем: Tools, далее Compile Java и теперь выполним: Tools и Run Java application. Вот можно увидеть, что у нас при этом получилось. Значение n2, это 1234567, а далее у нас уже 2 цифры отличные. Вместо 89 - 92, что в принципе соответствует вот этому действительному числу f1. Закроем это окно.

Напишем еще один пример такого рода. Например, возьмем действительное число типа double. Пусть это будет, например, z1, которое будет равняться 2 целое 7 десятых, точка с запятой.

Далее возьмем преобразование типа к типу integer. Пусть это будет i1, которое будет равняться преобразованию типа integer и далее эта наша переменная z1. Точка с запятой.

И в этом случае у нас к переменной i и i1, у нас будет присвоено значение 2, которое получается из 2,7 отбрасыванием дробной части. Ну, конечно же, нас больше бы устроило преобразование типа, при котором мы округляем число z1 до ближайшего целого.

Это можно сделать немножко по-другому. Для этого введем еще одну целую переменную. Пусть это будет ii2, равняется. Далее преобразование к типу целого int, и далее воспользуемся функцией math.

Далее Round, округление, которое как раз и даст нам округление z1 до ближайшего целого. Вот в этом случае мы уже получим число 3.

Проверим это, выведем все это на окно консоли. Для этого щелкнем на правую кнопку мыши и Paste. Далее ii2 равняется, +ii.2, далее ++ и внутри в кавычках напишем ii1.

Кавычки и значение ii1.Закрыть скобку. Точка с запятой. После ii1 лучше еще написать знак равенства и далее скомпилируем эту программу. Tools, Compile java, далее Tools, Run Java Application, запуск программы.

И можно увидеть, что как мы и ожидали у ii2 значение 3, которое получится округлением из 102, 7, а у переменной ii1 получило значение 2, которое получается отбрасыванием дробной части. Закроем консольное окно и вернемся в наше обычное окно редактирования.

Строки. Создание, слияние, выделение подстроки, длина строкиК оглавлению

Для работы со строками стандартная библиотека языка Java содержит специальный встроенный класс String. Причем надо заметить, что любая строка, которую мы заключим в кавычки, сразу же представляет собой отдельный экземпляр класса String. В языке Java, встроенного типа для строк, такого, как, например, целого числа integer, для действительного real и т.д., нет. Т.е. все, что касается строк, нужно представлять себе в виде экземпляра какого-то класса.

Создадим несколько переменных типа String. Для этого щелкнем здесь на кнопку Enter и напишем таким образом. String, создадим экземпляр этого класса. Пусть, например, это будет s1, знак равенства, и сразу присвоим ему какое-либо значение. Для этого, так же, как и при создании любого другого класса, напишем new String.

В скобках укажем кавычки, внутри котрых напишем то, что мы хотим ему присвоить. Например, числа от 1 до 5. Закроем кавычки, скобку и точка с запятой. В принципе путь, который мы выбрали для создания новой строки s1, вполне допустим, но на самом деле, в языке Java встроена поддержка более простой возможности. Для этого мы можем взять тип String, далее возьмем переменную s2. И после знака равенства, мы можем написать прямо то, что мы хотим ему присвоить внутри кавычек. Например, буквы abcd. Закроем кавычки, точка с запятой.

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

String, переменная s3, которая будет равняться объединению строки s1 и s2. Это будет s4. Для этого напишем s1+s2, достаточно простой синтаксис этой операции. Надо отметить, что к строке можно прибавлять не только строку объединения двух строчек, но и можно прибавлять, например, переменные других типов, например, целого типа. И в этом случае, компьютер его преобразует к его символьному представлению. К примеру, возьмем целое число i1.

Введем знак равенства. Присвоим ему какое-либо значение. Например, 5, точка с запятой. И теперь возьмем класс String, s5, знак равенства. И пусть он является объединением строки s2, прибавить i1,

точка с запятой. То же самое можно сделать и, используя вместо переменной, просто обыкновенные числа. Напишем таким образом. String, s6, знак равенства. Далее опять s2, плюс 5. Вот эти два выражения на самом деле абсолютно идентичны. И в том и в другом случае, мы получим одно и то же. Теперь к 5 добавим еще какое-либо число. Например, 2, точка с запятой. Правда, к выражению такого типа надо быть осторожным. Потому что, если мы ниже напишем такую строку, как String s7, знак равенства, s2, прибавить, в скобках 5+2, то результат выполнения вот этого выражения будет уже совсем другим. Будет не точка s2, т.е. abcd, 5, 2, а строчка abcd, и 7, как результат суммы 5+2. Посмотрим, как все это будет выглядеть. Для этого распечатаем значение этих переменных, которые у нас есть. Для этого воспользуемся функцией println и скопируем ее в буфер обмена. Сору, далее правая кнопка мыши, Paste.

Выведем сначала s4, закроем скобку, точка с запятой. Правая кнопка мыши, Paste. Далее s5, закроем скобку, точка с запятой. Правая кнопка мыши Paste, s6. И выведем последнее значение s7. Закроем скобку, точка с запятой. Теперь попробуем все это скомпилировать. Для этого Tools, Compile Java, далее Run Java Application, запустим на выполнение. И вот можно видеть, что у нас получилось. S4 у нас равняется s1+s2, т.е. 12345, а затем abcd, что и выведено в этой строчке. Причем можно видеть, что между цифрами и буквами abcd, нет никакого пробела, они идут подряд. Затем, у нас есть сумма s2 и числа 5, что будет обозначать abcd и далее 5. В следующей строке к 5 еще добавлено 2, что отражается на нашем экране, а затем, в последней строке, сначала выполняется операция 5+2, получается 7, и далее выводится все это на экран.

Закроем теперь консольное окно и вернемся в режим редактирования. Из любой строки можно выделить и подстроку. Для этого, в классе String существует специальный метод substring. Посмотрим, как это делается. Для этого возьмем String, переменную s8, которая будет равняться следующей строчке. Кавычки и далее напишем My First String. Закроем кавычки, запятая. И далее возьмем переменную s9, которая будет равняться какой-либо части из строки s8. Для этого возьмем таким образом.

S8, далее точка и метод substring. В скобках возьмем числа 3 и 7, закроем скобку, точка с запятой. Что означают числа 3 и 7? Тройка означает номер позиции в строке s8, начиная с которой мы и хотим взять букву из этой строки. Причем, надо сказать, что нумерация начинается с 0, т.е. буква М это нулевой символ, Y- первый, пробел будет второй, а буква F будет третим символом. Число 7 означает номер символа, до которого мы и хотим взять символы из этой строки.

Если попробовать вывести это все на консоль, для этого опять правая кнопка мыши, Paste, далее выведем сначала s8, чтобы у нас было с чем сравнивать, а затем опять правая кнопка мыши, Paste и выведем на экран s9. Закроем скобку, точка с запятой.

Теперь попробуем все это выполнить. Для этого Tools, Compile Java, далее Run Java Application, и можно видеть результат выполнение этой программы. Сначала мы выводим My first string на экран, а затем символы с 3 по 7. Т.е. получается f, i, r, и s. Как мы и сказали, буква f у нас стоит на третьей позиции, а буква t, в слове first, стоит на 7 позиции. Поэтому, копируются и используются все буквы до буквы t, до 7 позиции.

И получается то, что мы видим на экране. Закроем это окно. Отметим теперь, что для определения длины строки в языке Java существует специальный метод length, длина. Попробуем определить длину строки. Для этого возьмем переменную типа integer. Пусть длина строки будет n, знак равенства, определим длину строки s8, строки My first string. Напишем s8, точка, ее метод length, затем скобки, точка с запятой. Вот теперь, в переменной n мы поместили длину строки. Для того чтобы выделить отдельный символ, в языке Java существует тоже специальный метод charAt. Если мы возьмем таким образом, char, далее last,

последний символ, знак равенства. Выделим последний символ в этой строке s8. Для этого s8, точка, charAt. В скобках укажем номер позиции этого символа. Поскольку мы хотим последний, для этого мы можем воспользоваться вот этой функцией length, показать номер n. Напишем n, поскольку, как мы помним, нумерация в строке у нас начинается с 0, поэтому последним символом будет ни n, а n-1. Закроем скобку, точка с запятой.

Попробуем все это вывести на экран. Для этого, опять воспользуемся правой кнопкой мыши, далее Paste. Выведем таким образом, length, длина, знак равенства, плюс. Напишем значение n, плюс и далее выведем последнюю букву lastchar, знак равенства, закроем кавычки, плюс и вот этот символ last. Закроем скобки, точка с запятой. Посмотрим, что у нас получилось. Для этого скомпилируем. Tools, Compile Java. Далее Run Java Application. Теперь надо запустить программу.

И, как можно увидеть, мы получили то, что ожидали. Длина нашей строки My first string равна 15 буквам, включая пробелы и последний знак, буква g, что в принципе так и есть. Закроем окно и вернемся обратно в наш текстовый редактор.

Строки. Изменение, сравнение, работа с нимиК оглавлению

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

Попробуем в строчке My first string заменить маленькую букву s, на S большую. Для этого можно написать таким образом, напишем переменную s8, далее знак равенства, опять s8 и ее подстроку substring,

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

и опять s8 с подстрокой substring, начиная от следующей 10-й позиции и уже до конца, до n. N, как мы помним, равняется длине этой строки. Вот это место, где мы определили n, как длину строки s8. Точка с запятой. Теперь попробуем все это вывести на наш экран. Для этого опять правая кнопка мыши, Paste, как мы помним, метод println у нас находится в памяти все время, и далее выведем s8 на экран. Закроем скобку, точка с запятой. А теперь скомпилируем, Tools и Compile Java, далее Tools, Run Java Application, как мы видим, мы получили My first String уже с большой буквой S, String,

т.е. в языке Java мы поменяли одну букву в строковой переменной. Закроем это окно. Для того чтобы проверить, совпадают ли две строки, можно использовать метод equals. Можно написать таким образом. Как мы помним, строка s1 равняется 1, 2, 3, 4, 5, поэтому выведем на наше консольное окно уравнение, в котором указано, равняется ли оно какой-либо строке. Для этого, правая кнопка мыши, Paste.

Вот теперь мы получили println, и далее напишем таким образом. S1, точка. Далее метод equals, скобка. И строка для сравнения. Напишем ту же самую строчку 1, 2, 3, 4, 5. Закроем кавычки, скобки, и точка с запятой. Теперь опять правая кнопка мыши, Paste. И на этот раз напишем несколько по-другому. Сравним s1 equals с какой-либо другой строкой. Например, A, B, C, D. Закроем кавычки, скобки. Точка с запятой.

А теперь, посмотрим, что у нас получилось. Для этого Tools, Compile Java, далее Tools, Run Java Application, и как мы видим, выполнение первого из этих операторов, вызывает результат True, поскольку s1 у нас как раз и равняется 1, 2, 3, 4, 5. А выполнение следующей за ним строки вызывает ответ False. Поскольку s1 не равняется A, B, C, D.

Закроем теперь наше консольное окно и отметим, что-то же самое можно написать несколько по-другому. Щелкнем на правую кнопку мыши, Paste, мы получили println. Затем в кавычках напишем опять какую-либо строку. Например, ту же самую 1, 2, 3, 4, 5, кавычки, точка. Используем эту строку как раз в качестве переменной строкового класса. Далее equals,

откроем скобки, и опять 1, 2, 3, 4, 5, закроем кавычки, скобки, точка с запятой. Т.е. вот в этой строчке 1, 2, 3, 4, 5 мы сравниваем опять-таки с 1, 2, 3, 4, 5. Результат, конечно же, должен получаться такой. Просто в этой строке строку мы использовали в качестве переменной, в качестве экземпляра класса String.

Теперь же отметим еще одно обстоятельство, использование вот такого значка двойного равенства для сравнения двух строчек, на самом деле не правомочно. Поскольку, написать такое можно, это не воспримется в качестве синтаксической ошибки, но результат может быть совершенно непредсказуемым. Потому что при сравнении, компьютер сравнивает на самом деле не две строки, а две ссылки. Приведем пример такого порядка. Как мы помним, результат сравнения s1 и 1, 2, 3, 4, 5 у нас был True, поскольку s1 равняется этой строке. Напишем это немножко другим образом. Для этого правая кнопка мыши, Paste, s1 и на этот раз воспользуемся знаком сравнения равенства. И далее в кавычках 1, 2, 3, 4, 5.

Закроем скобку, точка с запятой. Так вот, результат выполнения вот этого оператора, будет False, поскольку s1 и как раз равен этой строке, но на самом деле, как ссылка, это два совершенно различных участка памяти. Посмотрим, так ли это. Для этого Tools, Compile Java. Теперь Tools, Run Java Application, и как мы видим, результат выполнения нашего последнего оператора будет False.

S1 и 1, 2, 3, 4, 5, это совершенно различные вещи, хотя, как строчки они одинаковые. Но и предыдущий оператор выдал нам результат True. Результат сравнения 1, 2, 3, 4, 5 самим с собой, как с оператором, выдал нам результат True. Закроем данное окно. Из всего этого можно сделать следующий вывод, пользоваться этим оператором для сравнения двух строчек совершенно нежелательно. Поскольку мы можем получить совершенно непредсказуемый результат. Если это один и тот же ресурс, мы будем получать равенство, а если - разные, то будем получать значение False. Хотя, как строчки, это может быть абсолютно одинаковые выражения. Рассмотрим теперь основные методы, которые есть у класса String в языке Java.

Они выведены вот в эту сводную таблицу, которую мы можем видеть на экране. Первый из них это метод charAt, с которым мы уже сталкивались и который возвращает символ, расположенный в указанной позиции, в позиции индекс. Следующий метод, метод compareTo, позволяет сравнивать две строки и возвращает отрицательное значение, если строка предшествует строке other в лексикографическом порядке, и положительное значение, если эта строка other предшествует ей. А также выдает значение 0, если две строки совпадают.

Этот метод очень полезен, если мы хотим расположить строчки в алфавитном порядке. Следующий метод, метод endsWith, позволяет определить оканчивается ли данная строка под строкой suffix. Если это верно, то возвращается значение True, а в противном случае, значение False. А метод equals, с которым мы уже знакомы, сравнивает две строки. Если они равны друг другу, то выдается значение True, а если они не равны, не совпадают, то выдается ответ False. Следующий метод, метод equalsIgnoreCase сравнивает две строки без учета регистра, без учета больших и маленьких букв.

Если они с этими условиями не учета регистра равны, то тогда выдается True, а в противном случае - False. Метод index, так же, как и метод индекс Of, помогает найти подстроку str в исходной строке. И возвращает начало первой подстроки, совпадающей с этой строкой, начиная с позиции 0 в первом случае, или, начиная с позиции fromIndex во втором случае.

Следующие два метода очень похожи на то, что мы только что обсуждали, они возвращают начало последней подстроки, равной этой строке str. Начиная с позиции 0 или с позиции fromIndex во втором варианте. Метод length возвращает длину нашей строки. А метод replace возвращает в новую строку, которая получается заменой всех символом oldChar на символы newChar.

Метод startWidth позволяет определить, начинается ли наша строка подстрокой prefix. Если это верно, возвращается True, в противном случае, возвращается в False. Следующие два метода, которые называются одинаково, это методы substring. У них различное количество передаваемых параметров. Возвращают в новую строку, которая состоит из всех символов, начиная с beginIndex, и заканчивая концом строки в первом случае, или же заканчивая позицией endIndex, не включая при этом именно эту позицию во втором случае.

Следующие два метода toLowercase и toUpperCase, превращают нашу строку в новую строку, преобразовывая при этом прописные буквы в строчные в первом варианте. И наоборот, все строчные буквы в прописные во втором варианте. Последний, выписанный здесь метод trim, который возвращает новую строку, из которой исключены все предшествующие и последующие пробелы.

Ввод данных с диалоговым окном и операции с нимиК оглавлению

Начнем работу с простейшего шаблона приложения, в котором создается консольное окно, и выводится вот такая строчка It is program My4. Сохраним его. Для этого щелкнем на кнопку Save, создадим для него новую папку с названием My4.

И зададим имя для нашего файла. Как мы помним, он должен в точности повторять название нашего класса, включая, маленькие и большие буквы. Поэтому назовем так, My4. Щелкнем на кнопку сохранения. И после этого мы вернулись на наш текстовый редактор. Попробуем теперь сделать так, чтобы мы могли ввести в некое диалоговое окно какие-либо данные. Для этого мы можем воспользоваться следующим методом JOptionPane. Затем точка и вызовим его метод showInputDialog.

Далее скобка. Теперь нам нужно написать ту строчку, которая будет выводится на это диалоговое окно. Введем самый стандартный вопрос What is your name,

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

Вот мы ввели тот оператор, при помощи которого можно вызвать диалоговое окно. Ну, если мы в таком виде запустим наше приложение на компиляцию выполнения, то произойдет ошибка. Дело в том, что для того чтобы мы могли использовать вот этот оператор, нам нужно использовать дополнительный пакет javax.swing. Для того чтобы мы могли это сделать, нам нужно в самом начале нашего приложения, написать следующую строчку. Освободим строку и далее напишем ключевое слово import. И далее пакет javax.swing.

Именно в этом пакете и определен класс JOptionPane, у которого мы и хотим позаимствовать метод вызова диалогового окна. Теперь в конце нашей программы, напишем еще строчку System. Exit, и в скобках зададим код выхода нашей программы. Зададим 0, поскольку у нас теоретически все должно закончится нормально.

Теперь же попробуем скомпилировать. Для этого щелкнем на пункте меню Tools, далее Compile Java, теперь Tools, Run Java Application, и можно видеть, что у нас получилось. Наряду с этим консольным окном, которое у нас все время появлялось, появилось окошко диалогового типа, которое в принципе независимо от консольного окна. Его можно передвигать в разные стороны, а также можно, конечно же, ввести какой-либо текст.

Например, вписать имя John и ОК. И, как мы видим, наша программа после этого прекратила свою работу. Правда, на консольное окно больше ничего выведено не было. Закроем теперь наше приложение и попробуем вывести на окно результат ввода. Для этого нам достаточно использовать вот этот метод println, а также задать какую-либо переменную, внутрь которой поместим данные из нашего диалогового окна. Зададим теперь какую-либо переменную строкового типа. Для этого наберем String. Пусть эта переменная у нас будет name, поскольку мы вводим имя. Далее знак равенства и после этого вот этот оператор showInputDialog.

Щелкнем на кнопку Delete, чтобы объединить вот эти две строки. Вот теперь после выполнения нашего диалогового окна поместим в переменную name наш введенный текст. Теперь же попробуем его вывести на консольное окно. Для этого воспользуемся оператором println. Выделим вот этот текст. Правая кнопка мыши, Сору. Теперь встанем сюда, правая кнопка, Paste. И теперь выведем name. Напишем таким образом. Hello.

Далее +name. Закроем скобку, точка с запятой. Теперь попробуем опять скомпилировать. Для этого Tools, Compile Java, Tools, Run Java Application. Вот опять появилось консольное окно вместе с диалоговым. Напишем наше имя John, и ОК. Как мы видим, появилась надпись и на нашем консольном окне.

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

Вместо name, пусть это будет i1. Изменим текст. Напишем Number one.

Опять скопируем эту строку. Щелкнем правой кнопкой мыши, Сору. Далее вставим сюда. Правая кнопка, Paste. Пусть это будет теперь два и Number two.

Теперь надо преобразовать строковую переменную i1, i2 в их числовые представления. Поэтому напишем таким образом int i1 знак равенства, воспользуемся специальным оператором, который предназначен для этого и который называется Integer.parseInt. Далее точка. И его метод parseInt,

который и производит такое преобразование. Далее наша строковая переменная i1, закроем скобку, точка с запятой. Теперь скопируем эту строчку еще раз. Правая кнопка мыши, Сору. Встанем сюда. Правая кнопка, Paste.

Переделаем единицы на двойки. Далее попробуем все это вывести на наше консольное окно. Для этого опять воспользуемся методом println. Выделим. Правая кнопка, Сору. Встанем сюда. Правая кнопка, Paste.

Теперь напишем то, что мы хотели вычислить. Для этого напишем таким образом. Сначала выведем первое число i1, затем знак умножения. Второе число i2, знак равенства и их произведение. ni1 умножить на ni2, закроем скобку, точка с запятой. Попробуем теперь скомпилировать наше приложение и посмотреть, что у нас получилось. Для этого развернем меню Tools, далее Compile Java.

Опять Tools и Run Java Application. Вот появилось наше консольное окно вместе с окном диалога. Введем какое-либо имя. Пусть будет то же самое, ОК. После того, как здесь написалось приветствие, появилось опять диалоговое окно, которое у нас спрашивает первое число. Возьмем любые числа и OK.

Появилось опять диалоговое окно. Теперь нам нужно ввести второе число, ОК. И можно видеть результат выполнения этого произведения.

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

Форматирование данных для отображения на консольном окнеК оглавлению

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

и попробуем скомпилировать. Развернем меню Tools, Compile Java. Опять Tools и Run Java Application. От нас требуют опять ввести какое-либо имя. Пусть, например, будет имя Билл, ОК.

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

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

и попробуем реализовать форматированный вывод. Для того чтобы управлять форматом вывода данных, в языке Java есть три специальных метода, которые предоставляют стандартные средства форматирования. Для чисел, это первый метод getNumberInstance, который находится в классе NumberFormat. Следующий метод, метод getCurrencyInstance, позволяющий форматировать денежные суммы. И последний метод getPercentInstance, который служит для форматирования процентов.

Попробуем применить это на практике. Для этого напишем следующую строку. Первое, что нам нужно сделать, это получить объект типа NumberFormat. Поэтому напишем таким образом, NumberFormat.

Пусть этот объект называется myformat, знак равенства. А теперь применим первый из этих методов getNumberInstance, поскольку мы хотим форматировать числа. NumberFormat, точка. Теперь getNumberInstance.

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

И теперь переделаем эти выводы. Напишем таким образом. Myformat, точка. И воспользуемся его методом format. Далее скобки. В конце нам нужно добавить еще одну скобку. Вот теперь форматированный вывод первой из этих чисел, нами обеспечен. Теперь то же самое сделаем во втором случае, при выводе делении одного числа на другое. Для этого выделим вот этот кусок текста. Чтобы не писать еще раз, скопируем, правая кнопка, Сору, и вставим, правая кнопка и Paste.

Нам, конечно же, нужно ввести еще одну закрывающуюся скобку. А теперь попробуем скомпилировать и запустить нашу программу. Но, прежде чем мы запустим нашу программу на компиляцию, нам нужно написать еще одну строчку импорта. Для того чтобы воспользоваться классом NumberFormat и его методами, нам нужно импортировать пакет java.text. Поэтому щелкнем здесь на Enter и напишем слово import. Далее java, точка, text, и точка с запятой. Вот теперь попробуем скомпилировать нашу программу. Для этого щелкнем на кнопку Tools. Далее Compile Java.

Опять Tools и запустим нашу программу Run Java Application. Введем опять какое-либо имя. Например, пусть будет Роберт, ОК.

Введем первое число. Пусть это будет 1, 2, 3, 4, 5, 6, ОК. Теперь второе число. Например, возьмем 7, ОК. И теперь можно видеть, что у нас получилось. В результате форматированного вывода, как мы видим, большое число было разделено по три цифры, и в качестве разделителя взята запятая. А в качестве разделителя между дробной и основной частью, взята точка. Само число тоже разбито по три цифры. Кроме этого, для вывода действительных чисел, взяты три цифры после запятой. Закроем теперь наше приложение. Щелкнем на вот этом крестике,

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

Воспользуемся этим методом для нашего формата. Теперь setMaximumFractionDigits. Далее скобка,

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

А также мы можем указать общее количество цифр для отображения перед десятичной точкой в форматируемом объекте. Для этого надо воспользоваться методом setMaximumIntegerDigits. Но с таким методом нужно пользоваться с осторожностью, поскольку, если число превысит это значение, и значащих цифр намного больше, то оно усечется и мы получим совершенно неправильный ответ. Попробуем сейчас запустить наше приложение, и посмотреть, что у нас получилось. Для этого Tools, далее Compile Java. Теперь Tools и Run Java Application.

Введем какое-либо имя. Например, пусть будет Stiv, ОК. Введем какое-либо число, ОК. Введем второе число, ОК.

И можно видеть, что на этот раз у нас после запятой только одна цифра для вывода действительного числа, как мы и задумали. Все остальное осталось точно таким же. Единственное, надо сказать что, как мы видим, последняя цифра, которая после точки, цифра 8, получается округлением нашего числа. Поскольку на самом деле у нас одна часть начинается с 7, затем 9, и т.д. И округляя, получим цифру 8. Закроем теперь наше приложение. Щелкнем на вот этом крестике и вернемся в наш обычный текстовый редактор.

Оператор if. СинтаксисК оглавлению

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

Создадим новую папку my5. Щелкнем на кнопке Открыть. И зададим имя для нашего приложения. Как мы помним, это имя должно в точности повторять имя нашего класса My5. Щелкнем на кнопке Сохранить.

И теперь рассмотрим вопросы видимости переменных внутри блоков. Для того чтобы разобраться в этом вопросе, определим какую-либо переменную. Пусть это будет переменная целого типа integer, i равняется, допустим, 5. Точка с запятой.

Теперь откроем какой-либо новый блок при помощи фигурных скобок и внутри него определим другую целую переменную int, например, k. Далее определим еще одну переменную s, которая будет равняться i+k.

А за пределами этого блока, определим опять-таки целую переменную, которая будет называться, например, g и будет равняться i+2. Но, конечно же, предварительно, нам нужно было бы определить какое-либо значение k. Пусть оно равняется 4. И в таком виде наша программа синтаксически правильно записана.

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

И в этой строчке мы написали, что s будет равняться сумме i+k. k определен внутри этого блока, а i вне этого блока, раньше. А вот в этой строчке, мы определили новую переменную g, которая определилась на основе переменной i, которая определена ранее в том же блоке и затем число 2. Переменную k здесь мы использовать не могли. Это было бы ошибкой.

Если мы здесь напишем вот таким образом, i+2+, например, k, то компилятор нам в этом случае выдаст ошибку. Если мы развернем меню Tools и выберем команду Compile Java, то, как мы видим, компилятор это не принял. На символе k он показал ошибку, что в принципе и ожидалось. Но вторая ошибка является на самом деле отголоском первой. Просто-напросто переменная k у нас не определена.

Перейдем опять на нашу программу. Сотрем здесь переменную k, которую мы использовали неправомочно и покажем еще одну ошибку, которую можно допустить. Ну, если мы определим наряду с переменной k внутри этого блока опять переменную i. Напишем int I, равняется, например, 7.

Вот такая запись тоже является ошибкой. Т.е. переопределять переменную внутри блока, если она уже определена ранее, нельзя, в отличие от других языков программирования. Например, в C это возможно. И при выполнении такой последовательности действий в языке C, у нас переменной s присвоилось бы значение 4+7, а не 4+5. А в языке Java, это просто-напросто ошибка. Если мы развернем меню Tools и выберем команду Compile Java,

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

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

и далее попробуем ввести некую информационную строку с диалогового окна. Для этого, как мы помним, надо воспользоваться методом showInputDialog из класса JOptionPane.

Теперь откроем скобку и теперь надо указать тот текст, который будет появляться в этом диалоговом окне. Откроем кавычки и далее напишем, например, ваша зарплата, Your salary? Закроем кавычки, закроем скобку. Точка с запятой.

Теперь же переведем эту строковую переменную в число. Для этого воспользуемся переменной типа int, которая пусть называется ii. Теперь нам надо преобразовать переменную ss к типу int, к типу ii. И для этого воспользуемся следующей функцией integer, точка и далее класс parseInt. Это стандартная функция преобразования от строки к числу,

и далее укажем переменную ss. Закроем скобку. Точка с запятой. Теперь же рассчитаем, какой нужно заплатить налог с этой суммы. Предположим, что условия у нас на налоги такое, что если наша зарплата меньше 1000 рублей, то она налогами вообще не облагается, а если больше 1000, то с каждого рубля, который больше этой 1000, надо заплатить 14%.

В этом случае, как раз нам и понадобиться использовать условный оператор if. Но сначала определим какую-либо переменную, в которой будем сохранять сумму налога. Пусть она будет у нас типа double, действительное число, поскольку нам понадобиться оперировать с дробными частями. Пусть эта переменная называется xx и равна, для начала, 0.

И теперь напишем оператор if. Далее в скобках нам нужно написать условие. Условие у нас будет такое. Если ii больше, чем 1000, тогда нам надо высчитывать налог. И в этом случае xx будет равняться ii-1000 умножить на коэффициент 0,14. 14 процентов, это как раз и есть 0,14.

Дальше попробуем все это вывести на консольное окно. Для этого скопируем вот этот оператор println, щелкнем правой кнопкой мыши, Сору. Далее вставим сюда. Щелкнем правой кнопкой мыши и Paste.

И выведем переменную xx. Напишем таким образом "You will pay" и далее xx. Точка с запятой.

А теперь нам еще нужно, для того чтобы мы могли использовать вот это диалоговое окно ввода, произвести импорт соответствующего пакета, который напишем в начале нашей программы. Напишем Import, далее javax, поскольку именно в этом пакете и находится возможность диалогового окна, далее точка, swing, и точка с запятой.

Теперь попробуем выполнить наше приложение. Для этого развернем меню Tools и выберем команду Compile Java (компилировать программу). Вновь развернем меню Tools и выберем команду Run Java Application. Появилось вот это диалоговое окно, в которое введем, например, сумму 3000. Щелкнем на кнопке ОК.

И как мы видим, с суммы 3000 надо заплатить 280 рублей. Теперь закроем это консольное окно. В принципе надо учесть, что мы забыли написать System.exit в нашей программе, что необходимо при использовании диалогового окна. И в результате при выходе из диалогового режима, на конец программы сразу же не попали. Сейчас закроем консольное окно.

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

Оператор if. Составной оператор. Вложение операторов ifК оглавлению

Напишем теперь таким образом. Откроем фигурные скобки. И теперь скопируем оператор println. Щелкнем правой кнопкой мыши, Сору. Вставим сюда. Вновь щелкнем правой кнопкой мыши, Paste.

И теперь напишем таким образом You mast pay. Далее кавычки, и сумма xx. Закрыть скобку. Точка с запятой.

Теперь же, если у нас сумма меньше 1000, тогда напишем оператор else, и далее следующую строку, вот в этом случае, который, конечно же, будет с несколько другим текстом. Текст будет такой You mast pay nothing! Ну и, конечно же, xx нам уже писать не нужно. Добавим слово not.

Запустим наше приложение и посмотрим, что у нас получилось. Развернем меню Tools, далее Compile Java, далее в меню Tools выберем команду Run Java Application. Введем опять какое-либо число. Например, 4000, ОК. И как мы видим, в этом случае нам нужно заплатить 420 рублей. Правда, здесь есть еще довольно большой остаток, который определяется ошибками округления.

Сейчас закроем наше приложение. Попробуем его запустить и ввести на этот раз число, которое будет меньше 1000. Для этого развернем меню Tools, компилировать нам уже не обязательно и поэтому прямо выберем команду Run Java Application.

Введем число, например, 500, ОК. И как мы видим, нам ничего платить не надо. Закроем приложение.

Чуть-чуть еще более усложним нашу задачу, и пускай с суммы, которая больше, например, 5000 рублей нам нужно платить по другой ставке налога. Например, 30% от всех денег, которые больше этих 5000.

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

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

Теперь напишем формулу вычисления вот в этом случае. Она у нас будет выглядеть следующим образом. xx = сумма ii-5000, из которой надо заплатить 30%, 0,30. Плюс еще та сумма, которая платится с денег, которые меньше 5000. Она будет высчитываться по следующей формуле. 5000-1000, т.е. это минимальная сумма, которая освобождается от налога, умножить на предыдущую вставку 0,14, Точка с запятой.

Теперь нам эту сумму надо вывести на консольное окно. Для этого просто-напросто скопируем вот эту строчку. Выделим ее. Щелкнем правой кнопкой мыши, Сору. Далее встанем сюда. Правая кнопка мыши и Paste.

Скомпилируем нашу программу, используя команду Compile Java. Теперь же запустим эту программу, используя соответствующую команду. Вот опять появилось это вопросительное окно, в которое введем числа, маленькие мы уже вводили, и теперь введем большое число. Например, 7000, которое явно больше 5000. Щелкнем на кнопке ОК и посмотрим, сколько нам надо заплатить. Оказывается, от 7000, нам надо платить 1160 рублей. Закроем наше консольное окно

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

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

Здесь напишем таким образом. while, скобки и условия. Далее напишем ii больше 0, закроем скобку. Точка с запятой. А теперь, если мы в таком виде запустим нашу программу, при компиляции, компилятор выдаст нам ошибку. Дело в том, что у нас переменная ii является локальной, внутри вот этого блока do и соответственно вне этого блока мы ее использовать не можем.

Поэтому нам просто-напросто надо вынести определение переменной ii за вот эти скобки. Поэтому определение integer здесь удалим. И снаружи нашего цикла проведем ее инициализацию, int ii, точка с запятой.

Теперь еще в начале наших вычислений, сразу после диалогового запроса, распечатаем саму нашу зарплату. Поэтому скопируем оператор println, Сору.

Вставим сюда, Paste. Затем напишем "Your salary", плюс и переменная ss. Закроем скобку. Точка с запятой.

Теперь скомпилируем наше приложение. Для этого развернем меню Tools, Compile Java. Запустим программу, активизировав команду Run Java Application и, как мы видим, возник тот же стандартный вопрос, который мы уже ни раз видели.

Введем какую-либо зарплату. Например, 444. Щелкнем на кнопке ОК. Как мы видим, в этом случае мы платить ничего не должны. А если наша зарплата составляет 4444, тогда нам надо платить 482 рубля с копейками.

В случае же, если зарплата еще больше 44444, тогда надо заплатить более 12000. А если же мы сейчас введем 0, щелкнем на кнопке ОК, то, как мы видим, при зарплате 0, платить ничего не надо и мы вышли из нашей программы. Закроем теперь наше консольное приложение. И мы вернулись в наш текстовый редактор.

Операторы цикла doК оглавлению

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

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

Попробуем, например, выполнить какое-либо простейшее действие. Например, сложить первую последовательность натуральных чисел, до тех пор, пока эта сумма не превысить число 100. Для этого введем несколько переменных целого типа (integer) i1, эта переменная, в которой мы будем держать последовательность натуральных чисел.

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

А число max пусть равняется, например 100, точка с запятой. Теперь оператор File, который является оператором цикла. Условием у нас будет, чтобы следующая сумма, а именно sum+i1 должна быть меньше числа mаx.

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

Воспользуемся такой записью оператора. И теперь выведем на печать наш полученный результат. Для этого воспользуемся оператором Println, скопируем его из вот этого места, правая кнопка мыши. Сору. Вставим сюда. Правая кнопка мыши и Paste.

Теперь кавычки, sum. Далее напишем, что мы проводим сумму от 0 до какого-то числа. В нашем случае, следующим числом, которое мы складываем, это будет i1. И эта сумма должна равняться знак равенства в кавычках и далее плюс теперь результат суммы. Закрыть скобку. Точка с запятой.

И теперь скомпилируем нашу программу и выполним для этого Tools. Далее Compile Java. Теперь Tools, Run Java Application.

Можно увидеть результат выполнения нашей программы. Мы, оказывается, сложили числа от 0 до 13, и в результате получили сумму 91. Если же прибавить следующее число, оно будет 14, то, конечно же, вы уже получите число больше 100. Закроем теперь это окно и вернемся в наш редактор.

Ту же самую операцию можно проделать и с помощью другого варианта оператора цикла. Напишем, например, таким образом. Заново определим i1 и sum, i1 равно 0, далее sum равно 0, и дальше напишем опять оператор цикла. Но на этот раз его напишем при помощи операторов do и while.

Далее выпишем, что мы хотим сделать. Сделать мы хотим то же самое, i1 увеличим на единицу. Далее сумму увеличим на величину i1. Точка с запятой. Теперь надо закрыть фигурные скобки. И теперь надо написать: while.

И внутри скобок условие, в течение которого и будет выполняться наш оператор цикла. Ну, опять напишем условие то же самое: sum + i1 будет меньше max. Закрыть скобки. Точка с запятой.

И далее выведем на печать то же самое выражение. Для этого скопируем эту строчку. Выделим. Правая кнопка мыши. Сору. Теперь встанем сюда. Правая кнопка мыши. Paste. И попробуем скомпилировать и запустить наше приложение. Для этого пункт меню Tools. Далее Compile Java.

Далее Tools, Run Java Application, и, как и нужно было ожидать, в случае первого цикла и в случае второго цикла, мы получили абсолютно идентичный результат. Закроем консольное окно.

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

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

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

Т.е. различие между двумя операторами цикла проявляется в том случае, если у нас с самого начала условие неверно. Продемонстрируем это. Скопируем все эти строчки. Выделим. Правая кнопка мыши. Сору.

Теперь Enter. Вставим. Правая кнопка мыши. Paste. И единственное, что сделаем, изменим, назначение переменной max со 100 на (-100) и посмотрим, что в этом случае произойдет. Конечно же, в этом случае, условие неверно с самого начала. Посмотрим, что тогда мы получим.

Для этого Tools. Далее Compile Java. Теперь запустим наше приложение, Tools, Run Java Application. И вот можно видеть, что, если в первом случае, когда мы складывали все суммы до 100, у нас результат получился абсолютно идентичный, и в первом и во втором случае. То, во втором случае, когда мы в качестве максимального числа взяли (-100) сразу же неверное условие, результат у нас получился при выполнении цикла так сказать первого вида и второго, два различных результата.

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

Операторы цикла forК оглавлению

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

Переменная max, пусть опять равна 100, и далее напишем оператор цикла for. Теперь скобка, внутри которой нам нужно написать условие нашего оператора for, который содержит в себе несколько действий. Первое среди них задает инициализацию, потом идет само условие цикла, и дальше условие обновление счетчика.

После первого выражения напишем переменную i1, которой присвоим значение 0. Затем второе выражение, в качестве которого опять-таки вот это 100+i1 меньше max. И затем третье выражение, в качестве которого возьмем приращение счетчика i1 на единицу. Закроем скобку.

Далее выполним некий оператор, в качестве которого возьмем просто-напросто приращение sum на i1. Поэтому напишем sum += i1. Конечно, если бы у нас была необходимость использование нескольких операторов, тогда надо было бы воспользоваться составным оператором. Т.е. поместить все эти операторы внутри фигурных скобок. Ну, поскольку сейчас здесь оператор всего лишь один, то фигурные скобки нам не нужны.

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

Теперь запустим наше приложение и посмотрим, что у нас получилось. Выберем пункт Tools. Далее Compile Java. Теперь опять Tools, Run Java Application. Как мы видим, наряду с теми 4 строчками, которые вычисляли эти суммы и которые мы уже видели, появилась еще одна дополнительная строка. Она вычисляет такую же сумму и получается тот же самый результат 91. Правда, счетчик у нас остановился не на 13, а на 14.

Это уже связано с конкретной реализацией цикла for. Просто-напросто превращение i1 у нас произошло, а вот это превращение при переменной i1 равной 14, еще не прибавилось. И именно на этом моменте и прекратилось выполнение оператора for Закроем эту консоль.

Теперь выполним этот цикл немножко по-другому. А именно, более стандартным образом: for, далее определим переменную. Переменную счетчик цикла можно определить прямо внутри цикла for. Для этого напишем int. Ну, пусть переменная у нас будет i2. Она пусть равняется от 0 и до тех пор, пока эта переменная i2 меньше, например, 10. Точка с запятой.

И к i2 применим приращение на единицу. Закрыть скобку. Теперь посчитаем сумму: sum +=, и i2. Точка с запятой. Конечно же, предварительно нам нужно было бы задать в этой сумме значение 0, точка с запятой. И вы выведем теперь это значение sum на печать. Из-за этого опять воспользуемся вот этой строкой, которая у нас уже находится в буфере обмена. Для этого правая кнопка мыши и Paste.

Теперь ее немножко переделаем, i1 у нас вообще нет в цикле. Не используется. А вот переменную i2, здесь мы использовать, как раз не имеем право, поскольку она определена внутри этого цикла. Ее можно использовать только внутри вот этого блока for. Но мы знаем в принципе, что она меняется от 0 до 10, поэтому напишем вот так: 0 и 10.

Все это можно убрать. Но, конечно, если у нас сумма от 0 до 10, тогда в этом случае тут лучше взять не знак меньше, а знак меньше или равно, чтобы число 10 тоже вошло у нас в эту же сумму. Теперь возьмем Tools. Далее Compile Java.

Опять Tools, Run Java Application и, как можно видеть, сумма чисел от 0 до 10, является числом 55. Что при желании можно проверить хотя бы вручную. Но это так. Закроем теперь это окно.

В цикле for можно организовать не только вот такой возрастающий цикл, но и убывающий, при котором, например, вот эта переменная i2 будет убывать. Например, сложим все числа в убывающем порядке от 20 до 10. Для этого сначала опять проинициализируем переменную sum. Присвоим ей значение 0. Далее оператор for. Скобка. Определим опять переменную внутри цикла int и далее i2.

Начальное значение пусть будет 20, точка с запятой. А далее условие цикла, i2. Должно быть больше или равно 10. Точка с запятой. И далее переменную i2 уменьшим на единицу. Напишем два знака минус. Закрыть скобки. А теперь к сумме надо прибавить вот эту переменную i2. Напишем это таким образом. Плюс равно и далее i2. Точка с запятой.

Теперь все это выведем на печать. Для этого правая кнопка мыши. Далее Paste. Теперь опять переделаем вот эту строчку вывода. Как мы помним, мы складываем от 20 до 10. И попробуем выполнить это приложение. Для этого сначала Tools, Compile Java. Далее опять Tools, Run Java Application.

Как мы видим, сумма чисел от 20 до 10 равняется 165. Закроем это окно.

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

Например, если мы выполним цикл с действительными числами, предварительно определим значение sum равным 0, далее оператор for, теперь определим переменную действительного типа double. Пусть это будет d1. Начальное значение пусть у нее будет равно 0. Точка с запятой.

Затем условие. Пусть условие будет d1 меньше 10. Запятая. И далее приращение к d за один цикл пусть будет равно 0,1. Закрыть скобку. И просто-напросто подсчитаем количество итераций.

Для этого напишем таким образом: sum+ равно 1. Конечно же, на предыдущей строке нам не хватает точки с запятой. Теперь скопируем вот этот println. Для этого выделим его. Правая кнопка мыши. Сору.

Enter. Теперь правая кнопка мыши. Paste. И выведем вот этот результат выполнения нашего цикла. В принципе, если посмотреть на сам цикл, то можно увидеть, что он должен выполняться примерно 100 раз от значения d1 равно 0, до значения d1 равно 9,9. Что, как раз составит ровно 100 циклов.

Посмотрим, так ли это. Выведем просто sum. Закрыть скобку. Точка с запятой. Далее скомпилируем Tools, Compile Java. Далее Tools, Run Java Application. И, как мы видим, наш компьютер выполнил этот цикл не 100 раз, а 101.

Вот этот один цикл прибавился за счет ошибки округления. Дело в том, что 0,1 в реальном так сказать исчислении у компьютера на самом деле не 0,1, а немного меньше, 0,099 и т.д. И в результате, выполняя все эти итерации на последнем шаге, компьютер имеет возможность еще одно прибавить вот это 0,1 и все равно переменная sum будет меньше 10. Чуть-чуть, но будет меньше. В результате прибавляется один лишний цикл.

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

Оператор switchК оглавлению

Сохраним ее на жестком диске. Для этого щелкнем на кнопку сохранения. Создадим новую папку для нее отдельную. И введем имя для файла нашей программы. Как мы помним, он должен совпадать с названием нашего класса, My7. Щелкнем на кнопку Сохранить.

И теперь попробуем использовать оператор switch. Для этого выведем сначала на наш экран диалоговое окно. Это можно сделать при помощи оператора showInputDialog. Для этого возьмем сначала переменную типа String. Пусть эта переменная будет input.

Равняется. Далее JOptionPane Точка. Теперь showInputDialog. Скобка.

И теперь внутри этой скобки в кавычках, напишем тот текст, который должен появиться в этом диалоговом окне. Просто напишем вариант 1,2,3,4. Закрыть скобку. Теперь пусть будет кавычки. Закрыть скобку. Точка с запятой.

Конечно же, чтобы использовать этот оператор, нам нужно импортировать соответствующий пакет. Для этого в первой строчке нашей программы напишем import, далее пакет, javax, внутри которого и находится средство поддержки диалогового окна. Далее swing. Звездочка. Точка с запятой.

И теперь, преобразуем эту переменную строковую типа в целое число. Для этого определим новую переменную типа integer. Пусть эта переменная будет i1, равняется. Далее функция преобразования - integer. Точка. parseInt.

Скобка и переменная input, внутри которой и должно находиться число, которое определит наши дальнейшие действия. Теперь напишем switch. Далее нам нужно указать в скобках ту переменную, на основе которой и будем производить переключение. Эта переменная у нас i1.

Далее фигурные скобки, внутри которых нам нужно написать все содержание нашего переключателя. Щелкнем теперь на клавише Enter и далее введем оператор case. И далее 1. Это будет означать, что после этого двоеточия будут выполняться операторы, в случае, если у нас i1 будет равен ровно 1. Т.е. мы выбрали первый вариант.

И теперь нам нужно написать те операторы, которые должны выполняться в этом случае. Для этого, просто-напросто скопируем эту строчку, выделим. Правая кнопка мыши. Сору. Вставим сюда. Правая кнопка. Paste. И пусть на консольное окно выводится вариант 1.

Variant one. Далее кавычки. Закрыть скобку. Точка с запятой. И далее нам нужно выполнить и написать оператор break, для того чтобы после выполнения вот этого оператора, который предназначен для варианта 1, переключатель прекратил свою работу и не выполнял остальные варианты. Теперь выполним вариант 2. Для этого проще всего скопировать вот эту строку. Выделим. Правая кнопка мыши. Сору.

Далее встанем сюда. Правая кнопка мыши и Paste. Только вместо Variant one, будит Variant two. Теперь опять Enter. Опять правая кнопка мыши и Paste. На этот раз вместо варианта Variant two будет Variant three, три. Но, соответственно, конечно же, нужно изменить здесь числа. Будет 2 и дальше 3. Теперь напишем, что должно происходить в варианте 4.

Вставим. Paste. Это у нас будет вариант 4, поэтому здесь напишем four. Теперь скопируем еще раз. Правая кнопка мыши и Paste, case 5 и вариант будет five.

Теперь же нам нужно написать операторы, которые будут выполняться в том случае, если у нас i1 не равен ни 1, ни2, ни 3, ни 4, ни 5. Поэтому напишем здесь default, что должно происходить по умолчанию, если i1 у нас не будет равен ни одному из существующих вариантов.

Опять напишем println. Скопируем. Сору. Вставим сюда. Правая кнопка и Paste. И в кавычках напишем No Variants, нет вариантов. Кавычки. Закрыть скобку. Точка с запятой.

И опять break. Запустим теперь наше приложение. Сначала его скомпилируем. Для этого Tools. Далее Compile Java. После этого опять Tools, Run Java Application.

Вот, появилось диалоговое окно с приглашением выбрать один из 5 вариантов. Но, выберем, например, вариант 4. ОК. И, как мы видим, появилась соответствующая надпись - Variant four. Как мы видим, мы забыли написать system exit. В связи с этим, нормального выхода не получилось.

Закроем наше консольное приложение и в конце напишем system exit. Но и, конечно же, с кодом 0, что символизирует нормальное окончание процесса. Запустим опять наше приложение. Tools. Сначала скомпилируем. Compile Java.

Опять Tools, Run Java Application. И на этот раз введем какое-либо совсем другое число, например, 88, которое у нас не присутствует в этом переборе возможных значении. ОК. И как мы видим, в этом случае появилась надпись No Variants, вариантов нет. Нормальное окончание процесса.

Закроем. Вернемся в обычный текстовый редактор. Попробуем теперь проэкспериментировать, и убрать один из операторов break. Например, вот этот. После выполнения 4-ого варианта. Теперь опять скомпилируем. Для этого Tools. Далее Compile Java. После этого опять Tools, Run Java Application. И теперь, если мы введем вариант 4, и щелкнем на кнопку ОК,

то мы можем видеть, что у нас получилось. А именно, выполним все операторы, которые предназначались и для варианта 4 и для варианта 5. Написалось и four и five. Если же мы запустим это приложение еще раз и напишем 5, то, как мы видим, в этом случае выполняется оператор, который написан у нас для варианта 5 и только.

Т.е. в случае выбора 1,2,3 или 5, выполняется только 1 из соответствующих вариантов, а в случае выбора варианта 4, у нас выполняется и операторы 4 варианта и операторы 5. Это произошло, потому что мы ключевое слово break, после оператора 4 варианта не написали.

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

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

Прерывание потока управления. Оператор breakК оглавлению

Именно поэтому разработчики языка Java, Хотя и сохранили само зарезервированное слово go to, но в сам язык его не включили. Правда, вместо оператора go to, существует специальный оператор для обеспечения преждевременного выхода из цикла. Это оператор break, такой же, как мы применяли в случае переключателя.

Например, напишем какой-либо цикл, при помощи которого выполним вот этот кусочек программы несколько раз. Для этого здесь щелкнем на клавише Enter, далее напишем, оператор for, и теперь внутри скобок создадим новую переменную целого типа. Пусть это переменная будет i2.

Она меняется от 1 до, например, i2 меньше 10. На каждом цикле пусть будет приращение на единицу. Закрыть скобки. Далее все остальные операторы поместим в фигурные скобки.

А также, на каждом цикле на наше консольное окно выведем номер итерации i2. Для этого скопируем вот этот println, выделим его. Правая кнопка мыши. Сору.

Вставим сюда. Правая кнопка и Paste. Далее кавычки. Напишем цикл. Закрыть кавычки и номер i2. Закрыть скобку. Точка с запятой.

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

Например, напишем таким образом. Оператор IF, далее проверим i1. Если i1 равняется, например, величине 55, тогда напишем оператор break. Точка с запятой. Исправим теперь вот в операторе if знак равенства. Конечно же, здесь должен быть знак сравнения, а также вместо переменной i, здесь должна быть переменная i2, в этом операторе for.

Теперь скомпилируем эту программу. Для этого щелкнем на пункте Tools. Далее Compile Java. Теперь опять Tools, Run Java Application. Как мы видим, программа запустилась. Появилось вот это диалоговое окно. Введем здесь какое-либо число. Например, 2. ОК. Вот, как мы видим, это у нас вариант 2 отметился. И цикл номер 1. Теперь введем какое-либо другое число. Например, 4.

ОК. Как мы помним, в случае варианта 4, выполняется и оператор варианта 4 и варианта 5, поэтому напились две строки. Variant Four и Variant Five. Теперь же, если мы введем какое-либо число, которое не входит в эти варианты, например, 33. ОК. Появилась надпись No variants, а если же мы введем число 55, которое у нас являлось так сказать ключевым, для выхода из цикла, и щелкнем на кнопку ОК,

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

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

Но, например, напишем здесь же, там где у нас был оператор break, еще одну проверку if, if i1 равняется, например, 66, тогда выполним оператор continue. Точка с запятой.

Теперь запустим эту программу. Для этого щелкнем на пункте Tools. Далее Compile Java. Теперь опять Tools, Run Java Application. Введем какое-либо число. Например, 3. Как видим, сейчас выполнился цикл номер 1. Если зададим число 5, выполнился цикл номер 2.

А если же введем число 66, то, как мы видим, операторы следующего цикла не выполнились. Правда, выход из всего цикла не произошло. Опять появилось диалоговое окно. Если, сейчас опять введем какой-либо номер, например, номер 2, щелкнем на ОК, то, как мы видим, после цикла 2 мы перешли к циклу 4, цикл 3 у нас просто-напросто пропустился. Пропустился, благодаря оператору continue.

Если же мы сейчас введем число 55 и щелкнем на ОК, то мы совсем выйдем из нашего цикла и соответственно из нашей программы, благодаря оператору break. Закроем. Надо отметить, что при помощи оператора break мы можем прекратить выполнение только текущего цикла, самого вложенного. Что же делать, если мы хотим выйти из нескольких циклов сразу? Для этого существует в языке Java специальная разновидность оператора break, break с меткой. Например, наряду с вот этим циклом for напишем еще один цикл. Опять напишем for, int. Пусть это будет на этот раз переменная i3.

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

И далее, при распечатке выведем не только i2, но и i1. Поэтому напишем, таким образом, i1, далее Плюс, кавычки, пара пробелов и плюс. Вот попробуем выполнить все это таким образом.

Теперь же попробуем использовать оператор break с меткой. Для этого введем метку вот этому внешнему циклу. Например, пусть это будет следующая аббревиатура. Просто-напросто возьмем abcd. В принципе это может быть любое имя, как мы составляем имя переменной, только дальше это должно быть двоеточие. И теперь вот в этом месте, где мы выполняли все проверки, выполним еще одну проверку if.

И если переменная i1 у нас будет равняться, возьмем 77, в этом случае выполняется оператор break с меткой abcd. Т.е. происходит выход всех циклов до метки abcd.

Попробуем теперь выполнить эту программу. Для этого Tools, Compile Java. Сначала скомпилируем. Теперь Tools, Run Java Application. Запуск программы. Появляется вот это стандартное диалоговое окно. Наберем здесь единицу. ОК. Вот, как видно, у нас цикл 1,1. Возьмем теперь, например, 2. Выполняется цикл 1,2.

Если же мы возьмем число 66, ОК. Как мы видим, мы пропустили один цикл. Если возьмем, например, число 4, видно, что мы после второго цикла перешли сразу на 4. Возьмем теперь число 55. ОК. Мы опять пропустили цикл, но на этот раз, если опять введем какое-либо число. Например, 2 и щелкнем на ОК, то можно видеть, что мы перешли к следующему циклу во внешнем цикле. Вот здесь, после единицы, появилась 2. А во внутреннем цикле у нас счет пошел сначала, с единицы.

Если мы теперь опять введем какое-либо число. Например, 5, то мы переходим к следующему по порядку циклу. А если же мы введем число 77. ОК. То на этот раз мы вышли из первого и из второго цикла. Мы перешли по метке, выполненной оператором break с меткой. Закроем теперь наше приложение и отметим, что в принципе такой оператор break с меткой и вот эту метку можно приписывать не только оператору цикла, но и любому составному оператору. Например, оператору if, просто-напросто в круглых скобках, внутри которого находится некий составной оператор и т.д.

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

Большие числа. Арифметические операцииК оглавлению

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

Пусть будет My8. Далее ведем имя для нашего приложения. Как мы помним, оно должно совпадать с названием класса. Поэтому возьмем опять My8. Причем первая буква М большая, так же как и в названии класса. И щелкнем на кнопку сохранения. И теперь мы можем непосредственно начать работу по созданию нашего приложения.

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

Теперь решим задачу, связанную с большими числами. Попробуем подсчитать точное количество зерен, которое должен был выдать король древнему шахматисту за его изобретение шахмат. При этом, как мы помним, на первую клетку нужно положить 1 зерно, далее 2, 4, 8 и т.д. до последней 64 клетки. Для того чтобы это подсчитать, введем две переменные больших чисел целого типа. Этот тип у нас будет BigInteger.

Пусть одна переменная будет sum, в неq будем хранить сумму всех зерен на всех досках. Проинициализируем его сначала. Начальное значение пусть будет 0. Для этого мы не можем написать прямо равенство sum и 0, это будет ошибкой. Эта операция не применима к большим числам. При использовании больших чисел, надо использовать специальные операторы и для сложения, и для вычитания, и даже для присваивания. Поэтому нам просто обычное число 0 надо превратить в большое число. Поэтому напишем таким образом, BigInteger,

точка и valueOf. Укажем в скобках число 0, которое нам нужно. Т.е. вот этим оператором BigInteger valueOf конвертировали обычное число 0 в число типа BigInteger. Теперь введем еще одну переменную sumi,

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

И на этот раз проинициализируем его числом 1. Поскольку, как раз с одного зерна все и начиналось. На первой клетке должно быть одно зерно. Далее напишем оператор цикла for. Введем обычную переменную целого типа i1, которая у нас будет меняться от 1 до 64. С приращением единицы. Поэтому напишем i++.

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

Такая запись выражения недоступна для операций с большими числами, поэтому надо воспользоваться другой записью, которая тут существует. Sum, точка и далее надо воспользоваться специальным оператором Add, добавить, cкобка. И вот теперь мы можем написать sumi, текущее значение зерен.

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

Поэтому напишем несколько в другом виде. А именно, sumi точка и специальный оператор multiply, который позволяет умножать на 2, не только на 2, а на любое другое число. И здесь мы тоже не можем написать внутри скобок просто 2, поскольку число 2 не является большим числом. Его надо конвертировать в большое число, для чего мы опять воспользуемся вот этой операцией BigInteger valueOf.

Для этого проще скопировать вот этот кусочек текста. Правая кнопка мыши, Сору. Далее вставим сюда. Правая кнопка, Paste. Единственное отличие, вместо 1 здесь нам нужно написать 2. Далее закроем скобку, точка с запятой. Теперь попробуем вывести результат на печать. Для этого воспользуемся println. Выделим вот этот кусок текста. Далее правая кнопка мыши, Сору.

Вставим сюда. Правая кнопка, Paste, в скобках напишем sum, знак равенства, плюс и само значение переменной. Закроем скобку, точка с запятой. Скомпилируем теперь эту программу и запустим. Для этого Tools, Compile Java. Далее Tools и Run Java Application. Как видим, при компиляции нам компьютер выдал ошибку. Но в принципе достаточно понятно, что здесь произошло. При написании цикла for, мы около i не написали 1, поскольку идентификатор у нас i1. Поэтому переключимся на наш текст и припишем здесь недостающую здесь единицу. Теперь скомпилируем опять. Для этого Tools, Compile Java, Tolls и Run Java Application. На этот раз компиляция прошла успешно, поэтому запустим приложение на выполнение.

Можно видеть, сколько зерен на самом деле нужно было выдать. Вот это большое число, которое, конечно же, простым Integer или LongInteger записать невозможно. Можно подсчитать, что здесь используется 20 цифр для записи этого выражения. Закроем теперь наше консольное окно.

Большие числа. Сравнение. Вычисление с большой точностьюК оглавлению

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

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

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

А число факториал, это произведение от 1 до n, всех натуральных чисел. Воспользуемся этой формулой. Поскольку возрастание n, это число очень быстро убывает, то эта формула достаточно быстро сходится. Для контроля выведем сначала число e, которое есть в этом пакете Math, на принтер. И, чтобы не писать, выделим эту часть текста. Правая кнопка мыши, Сору. Затем вставим сюда. Правая кнопка мыши, Paste.

И теперь напишем таким образом. Число E, знак равенства, кавычки, плюс и теперь его представление из пакета Math. Поэтому напишем Math, точка и далее большую букву Е. Закроем скобку, точка с запятой. Теперь попробуем это все подсчитать. Для этого введем переменную типа BigDecimal, которая и является действительным числом с большой точностью. Назначим число e и введем для него начальное значение.

Как мы помним, прямо присвоить какое-либо значение тут мы не можем. И, так же как и в случае с натуральными числами, нам нужно воспользоваться специальным оператором valueOf. Но, на этот раз возьмем не BigInteger, а BigDecimal, точка. Теперь valueOf.

И в скобках присвоим ему значение 0, запятая. Теперь в отличие от целого числа, здесь мы можем указать вместе с его значением и точность количества цифр, с которой мы хотим это число иметь. Возьмем, например, число 35. Мы хотим узнать точность числа е 35 знаков. Далее закроем скобку, запятая.

И возьмем еще одно число. Обозначим его e1, в котором будем хранить число единица деленное на n факториал. Проинициализируем это число. Для этого скопируем вот этот кусок текста. Правая кнопка мыши, Сору. Далее вставим сюда. Правая кнопка, Paste. Точка с запятой. Вот теперь у нас две переменные, типа BigDecimal уже есть. Единственное, во втором из этих чисел запишем теперь единицу для начала.

Поэтому напишем таким образом, e1, знак равенства, далее e1, точка add (добавить), и добавим единицу. Но нам нужно воспользоваться вот этим оператором BigDecimal valueOf. Поэтому скопируем, выделим. Правая кнопка мыши, Сору. Вставим сюда. Правая кнопка, Paste. И добавим здесь, конечно же, единицу. Теперь нам точность не нужна, в e1 у нас точность уже зафиксирована, поэтому закроем все скобки и поставим точку с запятой.

Введем еще одну переменную, просто integer. Пусть это будет i1, которая нам понадобится для организации цикла. Для начала ее проинициализируем нулем, и далее напишем оператор цикла while. Условием у нас пусть будет точность, и для этого напишем такое выражение. Е1, прекращать мы будет вычисление, когда вот это число e1, у нас будет меньше, чем 10 минус в 35 степени, поскольку мы как раз и хотим взять 35 знаков.

Поэтому напишем таким образом, e1, далее оператор сравнения, compareTo. Как мы помним, простые операторы больше - меньше мы здесь использовать не можем, поэтому напишем compareTo, и скобки, внутри которых нам опять надо воспользоваться вот этой конструкцией BigDecimal valueOf.

Поэтому выделим. Правая кнопка мыши, Сору. Вставим сюда. Правая кнопка мыши, Paste. Точка с запятой нам не нужна, и вместо нуля напишем единицу. И тогда, вот это число, будет числом 1 умноженное на 10 в минус 35 степени. Закроем теперь еще одну скобку

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

Увеличим значение i1 на единицу, i1++. Точка с запятой. Далее, к значению e надо добавить значение e1. Для этого опять воспользуемся оператором e, точка add, добавить.

Далее скобки и значение, которое у нас есть в переменной e1. Закроем скобку, точка с запятой. Теперь нужно e1 разделить на n, для того чтобы там все время сохранялось число 1 деленное на n факториал.

Поэтому напишем e1, знак равенства e1, точка и далее divide (делить), скобка. Теперь нам понадобится опять вот эта функция, преобразование обычных чисел в большое число. Выделим. Правая кнопка мыши, Сору. Вставим сюда. Правая кнопка мыши, Paste. Делить нам, конечно же, нужно на вот это число e1, на переменную нашего цикла i1.

Закроем скобку, запятая. И теперь нам нужно указать, как будет происходить округление при нашей операции деления. Напишем таким образом, BigDecimal, точка. И далее режим округления Round Half Up,

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

Следующим оператором выведем все это на печать. Для этого воспользуемся операцией println. Скопируем. Правая кнопка мыши, Сору. Вставим сюда. Правая кнопка, Paste. Далее выведем на печать оба числа, и единицу делить на n факториал, т.е. число e1 и само число e, подсчитанное нами.

Для этого напишем e1, плюс. Введем еще пару пробелом между этими двумя числами, чтобы они отделялись друг от друга и далее само число e, которое напишем таким образом, e, закроем скобку, точка с запятой. В принципе, мы можем ввести и такой символ e со знаком равенства, чтобы это все у нас было видно более четко, что у нас тут происходит. Теперь скомпилируем эту программу и запустим ее на выполнение. Для этого Tools, Compile Java.

Далее Tolls, Run Java Application. И вот можно видеть, что у нас получилось. Немножко растянем это окно, для того чтобы у нас все наши вычисления поместились и можем видеть, как у нас изменялось число e при вычислениях. И как у нас изменялся обратный факториал.

Как мы видим, он у нас все время мешался, пока не дошел до 0. А число e у нас получилось вот такое. Как мы видим, оно в принципе достаточно точно совпадает с числом e, которое у нас находилось в пакете Math. Первое, соответствующее количество цифр у нас совпадает, а далее после этого, мы дополнительно подсчитали еще достаточно много количества цифр.

Надо сказать, что, скорее всего, последняя цифры 1 или 2, тут вряд ли будет правильными из ошибок округления, но где-то 34, 33 цифры здесь будут абсолютно верными. Вот таким образом мы подсчитали число e. Конечно же, такие вычисления при помощи обычных операций сложения, вычитания и т.д. с обычными целыми действительными числами, даже с двойной точностью недоступны. Закроем теперь это окно. И вернемся в наш обычный редактор.

Одномерные массивы. Создание. Инициализация. Число элементовК оглавлению

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

Для этого щелкнем на кнопке сохранения. Создадим для него отдельную папку. Щелкнем на кнопке Открыть и далее введем имя для нашего файла. Ну, пусть будет вот такое. Как мы помним, это имя должно совпадать с именем класса.

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

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

Однако надо отметить, что этот оператор, который мы только что написали, лишь объявляет переменную, но не инициализирует ее настоящим массивом. А для того чтобы именно инициализировать массив, нам здесь еще нужно написать дополнительно его начальную инициализацию, которую напишем таким образом, знак равнения, затем new int, поскольку у нас массив целых числе и, далее в квадратных скобках укажем размер нашего массива.

Пусть, например, это будет массив, состоящий из 10 чисел. И массив, состоящий из 10 чисел, нумеруется числами от 0 до 9, т.е. от 0 до вот этого числа (-1). Поэтому, если мы захотим вот этот массив a1 заполнить какими-либо данными, то для этого нам нужно будет написать следующие коды.

Например, напишем, оператор цикла for, далее создадим переменную, допустим, i1, которая у нас будет меняться от 0 до i1 меньше 10, точка с запятой, и i1++ прибавление на единицу.

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

Как видите, еще одно обстоятельство при работе с массивами, если у нас программа достаточно большая, мы можем не помнить в середине или в конце нашей программы, сколько же элементов у нас было в массиве a1. Для того чтобы это узнать, оказывается, есть специальная функция u1, которая называется length. Поэтому, вот здесь, когда мы инициализировали наш массив, вместо 10 мы можем написать такую конструкцию, a1 точка length, длина массива a1. И теперь мы здесь к числу 10 привязаны уже не будем. Размер массива достаточно указать один раз при его инициализации, а дальше пользоваться вот этой величиной length.

Надо помнить, что в языке Java, изменять размер массива невозможно. Размер массива создается только один раз при его инициализации. А теперь же попробуем распечатать наш массив и вынести его на наш экран. Для этого опять воспользуемся вот этим оператором цикла, который проще всего скопировать, выделим его, щелкнем правой кнопкой мыши, Сору.

Затем встанем вот в это место. Вновь щелкнем правой кнопкой мыши и Paste. Enter. И теперь скопируем оператор println. Выделим его, вызовем контекстное меню, Сору. Встанем сюда. Правая кнопка мыши и Paste. И теперь напишем здесь, что мы хотим распечатать. Ну, распечатаем сначала номер элемента массива i1. Плюс, затем несколько пробелов, затем плюс, дальше элемент массива a1 с номером i1. Закроем скобку, точка с запятой.

Запустим теперь наше приложение. Для этого сначала скомпилируем его. Развернем меню Tools. Далее Compile Java. Компиляция прошла успешно. Теперь в меню Tools выберем команду Run Java Application. Запустим наше приложение и можно видеть, что у нас получилось. Мы выписали целые числа и рядом их квадраты.

Закроем наше приложение. Конечно, в принципе то же самое можно было сделать гораздо проще, не прибегая к массивам. Просто написать i1 и рядом его квадрат, но понятие массива, конечно же, используется не только для таких простых случаев. Определить массив можно и по-другому, сразу заполняя его значениями.

Для этого напишем таким образом. Напишем int, поскольку мы опять хотим создать массив из целых чисел, затем квадратные скобки, для того чтобы указать, что это у нас будет массив. Далее название этого массива. Пусть это будет массив a2, знак равнения и далее в его фигурных скобках уже укажем сразу же элементы этого массива. Пусть это будет, например, 1,2,3,4, далее введем обратный отчет 4,3,2 и 1. Далее закроем фигурную скобку. Точка с запятой.

Т.е. мы сразу же определили массив, сразу же определяется его размерность, как число элементов в этом массиве, и его отдельные элементы. Теперь, например, этот массив можно распечатать. Для этого скопируем вот эти две строчки, чтобы не писать их заново. Выделим их. Щелкнем правой кнопкой мыши. Далее Сору. Теперь встанем вот сюда. Правая кнопка мыши, Paste и теперь все, что нам нужно сделать, это изменить a1 на a2. У нас уже массив a2. Точно, то же самое при распечатке. Распечатать мы хотим массив a2.

Теперь запустим наше приложение. Развернем меню Tools и для начала выберем команду Compile Java. Далее воспользуемся командой Run Java Application. И вот, можно видеть, что второй массив у нас состоит из 8 элементов с индексами от 0 до 7, и он распечатался у нас вот в этом месте. Идут цифры 1,2,3,4, а затем в обратном порядке.

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

То же самое можно сделать и при определении первого массива. Вот эти две скобки, можно было перенести после названия массива a1. Давайте скомпилируем сейчас нашу программу, выберем команду Compile Java, затем Run Java Application, то можно заметить, что у нас ничего не изменилось. На экране мы получили абсолютно один и тот же результат, одно и тоже окно. Как мы видим, от перестановки наших фигурных скобок, ничего не изменилось. Закроем наше приложение и вернемся в наш текстовый редактор.

При применении массивов, правомочно использовать оператор присваивания, оператор равенства. Например, если мы напишем следующую строчку, определим еще один массив, назовем его, например, a3, и этому массиву присвоим значение a2. Точка с запятой.

Но при этом надо помнить, что массив a3 и a2, это на самом деле один и тот же массив, который ссылается на один и тот же набор данных. И поэтому, если мы здесь изменим какой-либо элемент какого-либо из этих массивов, например, a2 от 2, например, второй элемент с индексом 2. Присвоим ему, например, значение 100. Точка с запятой.

А элементу массива a3 с номером, например, 5 присвоим значение 50, на самом деле, в случае первого и второго присвоения изменяется значение обоих массивов, поскольку это опять-таки один и тот же массив.

Попробуем это проверить. Для этого распечатаем оба массива. Скопируем эти две строчки. Щелкнем правой кнопкой мыши, Сору. Далее встанем сюда. Правая кнопка и Paste. Теперь изменим распечатку println. Сделаем ее немного другой. После a2 распечатаем еще значение массива a3. Для этого сначала введем пару пробелов. Затем +, далее a3, тоже от i1. Скомпилируем. Воспользуемся командой Compile Java,

далее Run Java Application. И можно видеть, что и массив a2 и массив a3, у нас абсолютно одинаковые. Этот элемент с индексом 2 у нас в обоих элементах стал 100, и элемент с индексом 5, тоже в обоих индексах стал 50. Хотя мы изменяли сначала элемент a2, а затем элемент a3. Но изменились оба массива, поскольку это один и тот же набор данных. Закроем окно программы и вернемся в обычный режим редактора.

Одномерные массивы. Копирование. СортировкаК оглавлению

Например, создадим еще один массив. Опять целого типа. Пусть он называется а4. Возьмем его размер, например, чуть больше. Определим его опять в явном виде. Напишем таким образом. Пусть это будет 11,12,13,14 и т.д. Ну вот, пожалуй, элементов здесь хватит. Явно видно, что массив а4 больше, чем массив а2, и аналогично а3.

И далее скопируем элементы из массива а2 в массив а4. Теперь напишем таким образом System, далее точка. Теперь оператор array.copy. Откроем скобку. Теперь нужно указать из какого массива мы хотим копировать. Например, мы копируем из массива а2, запятая. Теперь надо указать с какого индекса мы хотим копировать элементы. Например, начнем копировать из элемента с индексом 2.

Далее надо указать, так сказать, массив приемник. Это у нас а4, запятая. Теперь надо указать индекс, начиная с которого в массиве а4 будут располагаться эти элементы, но пускай это будет у нас число 3, запятая. И далее надо указать количество копируемых элементов. Например, скопируем 3 элемента. Закроем скобку, точка с запятой.

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

А теперь же, после копирования, попробуем распечатать массив а2 и а4. Для этого опять воспользуемся вот этими двумя строчками. Выделим их. Щелкнем правой кнопкой мыши и Сору. Далее вставим сюда. Правая кнопка и Paste.

И вместо а3 тут напишем а4, поскольку нас теперь интересует именно этот массив. Правда, надо отметить, что при распечатке вот таким образом, у нас из 4 распечатываются не все элементы, а только такое же количество элементов, как и в массиве а2, поскольку мы здесь задали распечатать количество элементов, равное а2 length. Т.е. то, которое есть в массиве а2.

Запустим теперь наше приложение. Для этого развернем меню Tools. Сначала скомпилируем ее. Далее запустим, используя команду Run Java Application. И вот можно увидеть, что у нас получилось. А именно, скопировалось у нас три элемента. Причем копирование у нас произошло со сдвигом. Т.е. вот это число 100, которое было на втором месте в первом массиве, перешло на третье место в массиве а4, вот в этом. То же самое произошло со следующим элементом. Вот эта 4 тоже перешла сюда, но со сдвигом. И следующая 4 тоже.

А все остальные элементы массива а4 остались такими же, как и были. Вот в начале 11,12,13 и в конце 17,18. Эти элемента массива не изменились. Изменились только вот эти три, которые стали равны соответствующим трем элементам из массива источника. Закроем теперь наше консольное окно и опять вернемся в наш обычный текстовый редактор.

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

Для этого создадим массив целого типа int. Далее введем квадратные скобки. Определим новый массив. Пусть это будет массив а5. Знак равнения. И далее напишем таким образом, new int и далее укажем размер нашего массива. Размер укажем, как длину массива а2. a2 точка далее length. Закроем скобку, точка с запятой.

Теперь у нас а5 и а2, оба массива одинаковой длины. Теперь скопируем все элементы а2 в а5. Для этого вновь воспользуемся оператором System.arraycopy. Так и напишем. Далее откроем скобку. Массив источник у нас будет а2. Запятая. Копировать мы будем из элемента с индексом 0. Запятая. Далее у нас массив приемник будет а5. Запятая. Опять мы копируем, начиная с индекса 0.

И далее количество копируемых элементов. Мы возьмем все элементы, поэтому напишем а2 length. Закроем скобку. Точка с запятой. Теперь же, после того, как мы все элементы скопировали, попробуем элементы массива а5 отсортировать. Для этого надо написать таким образом Arrays, точка sort. И внутри скобок название массива а5. Закроем скобку. Точка с запятой.

Теперь попробуем массивы а2 и а5 распечатать. Для этого воспользуемся опять вот этой частью println, вместе с соответствующим циклом. Выделим эти строки. Щелкнем правой кнопкой мыши, Сору. Далее встанем сюда. Правая кнопка и Paste. И теперь единственное, здесь нам надо изменить, вместо а4 написать распечатку массива а5

и кроме того, чтобы отделить эту задачу от всех предыдущих, введем какую-либо строчку. Для этого скопируем вот этот оператор. Щелкнем правой кнопкой мыши, Сору. Встанем сюда. Правая кнопка мыши и Paste. И внутри кавычек напишем просто-напросто вот такую разделительную линию. Далее закроем кавычки. Закроем скобку. Точка с запятой.

Теперь, для того чтобы эта программа корректно работала, нам нужно так сказать узаконить использование вот этой функции Arrays.sort из класса Arrays. Для этого в нашей программе мы должны импортировать соответствующий пакет util. Поэтому напишем таким образом, import, далее java, точка, util, точка, звездочка, точка с запятой.

Теперь мы можем скомпилировать программу. Для этого развернем меню Tools, Compile Java. Компиляция прошла успешно. Теперь Tools и Run Java Application. И можно видеть результат выполнения нашей программы. Как мы видим, у нас и массив а2 и массив а5 состоят из одних и тех же наборов чисел, но массив а5 у нас в отличие от массива а2, расположен по своему возрастанию. Т.е. отсортирован. Начинается вот с единицы и кончается именно на том, значении которое равно 100. В отличие от массива а2, где все эти элементы расположены так сказать в рабочем беспорядке.

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

Затем вставим их сюда, Paste. Следующая наша задача будет опять отделена вот таким прочерком. И далее напишем таким образом. На этот раз i1 возьмем от 1 до 10. И будем искать вот эти числа от 1 до 10, т.е. i1, присутствуют ли они в массиве а2.

Для этого вот это все уберем, и напишем так. Arrays, поскольку этот метод сортировки есть именно в этом классе, точка. Далее binarySearch. Далее откроем скобку. Теперь нам нужно указать массив, в котором мы будем искать. Пусть это будет массив а2, запятая и далее, что мы будем искать. Искать мы будем элемент с значением i1. Закроем скобку.

А теперь скомпилируем программу. Развернем меню Tools, Compile Java. Компиляция прошла успешно. Теперь вновь меню Tools, Run Java Application и можно увидеть, что у нас получилось. Как мы видим, выводится номер элемента, значение которого равно вот этим числам. А если такого элемента нет, тогда отображается отрицательное число. Вот, как мы видим, в массиве а2, вот это у нас массив а2 был распечатан в предыдущем примере. Элемента со значением 0, нет. А элемент с значением 1, есть. И у этого элемента, со значением 1, индекс 0. Что мы тут и получили.

А элемент, значение которого равно 2, его номер у нас единица, что у нас и отображается. Элемента в массиве а2, который равнялся бы 3, нет, а элемент, который равнялся бы 4, у нас есть, у него индекс 3. Вот тройку мы здесь и получаем. И далее, элементы со значением 5, 6, 7, 8 и 9 отсутствуют. Тут таких элементов нет. И в результате здесь все отрицательные числа. Закроем теперь окно нашей программы.

Многомерные массивы. Создание. ИнициализацияК оглавлению

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

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

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

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

Ну, например, таким образом, 11,12,13,14 - это у нас первый ряд этого массива, затем следующий, пусть это будет 21,22,23,24 и т.д.

31,32,33 и 34. И закроем фигурную скобку. Точка с запятой. Вот, таким образом мы проинициализировали многомерный массив, размером 3х4. Это у нас, двумерный массив. Попробуем его теперь распечатать на нашем консольном окне.

Для этого нам, конечно же, потребуется оператор цикла. Напишем таким образом, for, int i1, который меняется от 0, далее точка с запятой, и от 0 до i1 меньше, чем длина нашего массива, так сказать, по вертикали, т.е. вот это наружное. Потом напишем а1, точка length. Точка с запятой.

И далее i1++, чтобы на каждом шагу было приращение на единицу. Далее нужно закрыть скобку. А теперь фигурные скобки, внутри которых напишем еще один цикл for,

на этот раз возьмем опять переменную тип int, целую. И пусть это будет i2, которая меняется от 0 до i2 меньшем, чем, на этот раз, возьмем длину нашего массива, так сказать, в другом направлении. Поэтому возьмем а1, возьмем его элемент под номером i1 и на этот раз используем именно его длину. length, точка с запятой, i2++ опять, приращение на единицу. Закроем скобку.

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

Поскольку кроме печати нам ничего не нужно, фигурные скобки вставлять не обязательно. Теперь же напечатаем то, что мы хотим распечатать. Именно вот эти числа из массива а1. а1, i1 первый индекс и i2 второй индекс. Далее плюс. И введем несколько пробелов, для того чтобы эти числа у нас не прилипли друг к другу. Закроем скобку. Точка с запятой.

Кроме этого, воспользуемся лучше не оператором println, а просто print, для того чтобы элементы внутреннего массива, у нас отображались на одной строке. А между циклами наружного индекса, индекса i1 сделаем перевод строки. Поэтому щелкнем здесь правой кнопкой мыши, Paste. Вставим этот оператор и закроем скобки. Здесь нам нужен только перевод строки.

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

Теперь скомпилируем нашу программу. Для этого развернем меню Tools, Compile Java. Далее Run Java Application. И можно видеть результат выполнения нашей программы. Мы вот эту нашу матрицу, наш двумерный массив распечатали на консольном окне. Закроем его. Вернемся в наш текстовый редактор.

Создадим теперь еще один массив. Для этого, пусть это будет опять массив целых чисел int. Опять будет двумерный, поэтому вот эту пару квадратных скобок напишем два раза. Пусть эта переменная будет a2, которую определим при помощи оператора new. new, далее int и определим размерность этого массива. Ну, пусть это будет на этот раз просто 5х5. Точка с запятой.

Теперь заполним, какими-либо значениями вот этот массив. Для этого опять воспользуемся вот этим двойным циклом. Скопируем вот эти две строчки. Выделим их. Правая кнопка мыши. Сору. Теперь вставим сюда. Правая кнопка мыши и Paste. Теперь нам немножко это все надо переделать. Вместо a1 написать a2. И в первом цикле и во втором.

Теперь напишем определение самой переменной. Вот эта фигурная скобка нам не нужна. Далее Enter. И далее напишем таким образом. a2 от i1, это первый индекс. И внутри квадратных скобок i2, это второй индекс, пусть равняется случайному числу, которое будет лежать в пределах от 0 до 100.

Для этого нам нужно написать следующую строку. int, это число нам нужно перевести к типу integer. Далее Math, точка, random. Далее скобки и умножить на 100, поскольку число мы хотим взять от 0 до 100. Дело в том, что вот этот оператор Math.random выдает нам случайные действительные числа от 0 до 1. А при умножении на 100, мы получаем соответственно от 0 до 100. А приведение к целому типу выдает целое число соответствующего диапазона от 0 до 100.

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

И теперь попробуем многомерный массив a2 вывести на печать. Для этого опять воспользуемся вот этой готовой заготовкой. Выделим вот эти несколько строчек.

Далее правая кнопка мыши и Сору. И вставим в это место. Вставим сюда. Правая кнопка и Paste. И теперь везде a1 поменяем на a2. В этом месте, в этом и соответственно вот в этом месте.

Единственное, чтобы вот эти первая и вторая маленькие подзадачи у нас не путались между собой вставим между ними еще один оператор println. Выделим вот этот фрагмент текста. Щелкнем правой кнопкой мыши, Сору. Далее вставим сюда. Правая кнопка и Paste. И введем опять разделительную линию. Внутри кавычек напишем несколько минусов. Вот таким образом. Теперь развернем меню Tools.

Compile Java - скомпилируем. Компиляция прошла успешно, и поэтому запустим наше приложение. Run Java Application. И вот можно видеть результат выполнения нашей программы. Мы получили матрицу 5х5, состоящую из случайных чисел. Закроем это консольное окно. Щелкнем на вот этом крестике. И выйдем в наш обычный текстовый редактор.

Многомерные неровные массивыК оглавлению

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

Например, возьмем вот этот массив 5х5, который мы только что разбирали и превратим его в неровный массив. Для этого скопируем вот эти строчки. Выделим их. Щелкнем правой кнопкой мыши, Сору. Теперь вставим сюда.

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

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

А внутри этих фигурных скобок, до следующего цикла for зададим и длину этого массива по другому направлению.

Теперь определим размерность массива a3 по другому направлению. Поэтому напишем таким образом. a3 от i1 равняется new int и затем размер массива, который нам нужно написать внутри квадратных скобок. Размер массива опять возьмем случайным образом, вот этим оператором Math и random.

Поэтому скопируем вот этот фрагмент текста, выделим его, щелкнем правой кнопкой мыши, Сору. Далее вставим сюда. Правая кнопка и Paste. Единственное, возьмем размерность этих случайных чисел не 100, а меньше. Например, возьмем до 8, чтобы у нас все это поместилось в одну строчку. Далее закроем квадратную скобку. Точка с запятой.

Теперь нам нужно переделывать каждый раз a2 на a3 во всех дальнейших строчках. Вот это у нас была инициализация вот этого массива. А в следующих строчках у нас происходила его распечатка. Поэтому здесь тоже напишем a3. Вот таким образом у нас уже исправлены все строчки кода.

В конце каждой строки выведем также размерность. Вот эту величину. Скопируем ее. Правая кнопка, Сору. Вставим сюда. Правая кнопка и Paste. Единственное, перед этой информацией, поместим еще в кавычках следующий текст. Напишем просто, n и знак равнения.

И попробуем выполнить и скомпилировать эту программу. Для этого развернем меню Tools. Далее Compile Java. Теперь, после того, как компиляция прошла успешно, вновь развернем меню Tools и Run Java Application.

И вот можно видеть, что у нас получилось. У нас получился вот такой абсолютно неравномерный массив. Первая строчка у нас состоит из 4 элементов. Вторая строчка из 7. Третья тоже из 7. И последние две строчки - по одному элементу.

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

Напишем char, далее две пары квадратных скобок, поскольку опять возьмем многомерный массив и определим имя этого массива. Ну, пусть будет a4, и далее напишем таким образом. Знак равнения. И теперь внутри фигурных скобок нам нужно написать элементы этого массива.

Пусть это будет таким образом. Возьмем буквы, которые расположены у нас на первой строчке нашей клавиатуры. Это будет буква q, затем буква w, и далее по порядку. Возьмем первые несколько букв. Вот первую строчку из этих букв мы уже ввели. Теперь запятая,

введем следующую строчку. Опять фигурные скобки и продолжим тем же способом. Закроем фигурную скобку. Опять запятая и следующая последняя, третья строчка, которая будет состоять из таких букв. Эта буква z, далее x, c и т.д. Закроем фигурную скобку, закроем также вторую фигурную скобку. Точка с запятой.

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

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

Единственное, опять-таки, чтобы отделить одну задачу от другой, вставим между ними вот эту строчку. Выделим ее. Правая кнопка мыши и Сору. Вставим сюда. Правая кнопка мыши и Paste. Теперь скомпилируем эту программу. Для этого развернем меню Tools. Далее Compile Java.

Далее опять меню Tools и Run Java Application. И вот можно увидеть, что у нас получилось. У нас получился вот такой неравномерный массив, в первой строчке которого у нас 10 элементов, начиная с буквы q и кончая буквой p, во второй строке у нас 9 элементов от a до l,

и в третьей 7 элементов от z до m, так как это все у нас расположено на контактной клавиатуре. Закроем это приложение. Щелкнем на вот этом крестике и выйдем в наш обычный текстовый редактор.

Классы. Первое знакомство. Создание класса и объектовК оглавлению

И далее пара фигурных скобок. Одна открывающая, и следом закрывающая. Между ними надо написать саму сущность этого класса, что он будет делать. Но в принципе можно пока оставить вот так. Это уже полностью рабочий класс Point, который правда пока абсолютно ничего не делает.

Введем теперь в наш класс Point две переменные, в которых будем хранить информацию о двух координатах, которые определяют положение точки на плоскости. Переменные пусть, конечно же, будут типа integer, и назовем их x и y. Но и в конце, конечно же, точка с запятой. Вот теперь у нас уже есть абсолютно готовый класс, в котором существуют две переменные x и y.

Этот класс мы уже можем вполне использовать. Для этого создадим новый класс. Напишем ключевое слово class и далее имя этого нового класса. Пусть это будет My11. Далее фигурные скобки, внутри которых напишем его метод, метод main, с которого, как обычно у нас начинается выполнение всех консольных программ. Поэтому напишем, таким образом, public, далее static, с этой строчкой мы уже не раз сталкивались.

Далее метод main, который обязательно должен присутствовать во всех консольных программах. И его параметр String, далее arcs, закрыть скобку. И далее две фигурные скобки.

Теперь сохраним нашу вот эту программу в файл. Для этого щелкнем на значке File, хранение файла. Создадим новую папку. Назовем ее My11. Щелкнем на кнопку Открыть. Вот мы попали внутрь этой папки и выберем имя для нашего файла, который, конечно же, должно совпадать с названием класса, в котором у нас и находится метод main, 11, далее щелкнем на кнопку Сохранить.

Как мы видим, как только мы сохранили наш файл, у нас все ключевые слова и скобки выделились особым образом. И теперь попробуем скомпилировать эту программу и ее выполнить. Уберем сначала лишнюю квадратную скобку, которая у нас случайно появилась на экране. Далее скомпилируем, Tools, Compile Java. Далее Tools, Ran Java Application.

Как мы видим, наша программа успешно скомпилировалась и запустилась на выполнение. Правда, пока она абсолютно ничего не делает и ничего не выдает на экран. Это в принципе поправимо. Закроем наше консольное окно. Теперь сделаем так, чтобы эта программа что-то делала. Мы видим, пока в работе нашей программы никак не проявляется то, что мы у нас создали новый класс Point.

А теперь мы можем на основе этого класса Point создать два объекта, два экземпляра этого класса. Введем здесь Enter и далее таким образом. Создадим новый Point. Напишем Point. далее имя этого объекта. Назовем, например, Р1. Точка с запятой.

И после этого у нас уже есть один объект класса Point. Но сам по себе он еще не инициализирован. Для этого нам нужно воспользоваться специальным оператором new. И поэтому, вместо точки с запятой, напишем так. Равняется, затем new, и далее Point. И открывающая и закрывающая скобки. Точка с запятой.

Вот теперь у нас уже есть полноценный экземпляр класса Point. Создадим еще один экземпляр. Еще один объект такого же класса. Опять напишем Point. На этот раз возьмем другое имя, Р2. Опять new, Point. И скобки. Внутри скобок мы ничего не пишем, поскольку у класса Point никаких передаваемых параметров нет.

Теперь же мы с объектами Р1 и Р2 можем проводить некие действия. Но, в принципе, посмотрев на класс Point, мы можем понять, что мы можем сделать. В классе Point пока существует возможный единственный вариант работы, это использовать вот эти поля x и y. Поэтому напишем таким образом. Р1 точка Х, т.е. Х-тая координата объекта Р1, объекта типа Point, типа точки. Равняется.

Ну и присвоим какое-либо число. Например, 11. Точка с запятой. То же самое можно сделать с его y координатой. Р1 точка y равняется, пусть будет, например, 22. А теперь определим точку Р2. Р2 точка, его x координата пусть будет 33. А у точки Р2 y координата пусть будет равняться, например, 44.

Вот теперь можно увидеть различия между объектом и классом. Т.е. класс, это некие правила поведения, которые мы создаем внутри нашей программы. Это еще не объект. Не реальная вещь, с которой можно что-то делать. А вот объект Р1 и Р2, это уже реальная так сказать сущность, внутри которой мы можем сохранять какие-то числа, какие-то проводить с ним действия и т.д.

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

Напишем, например, таким образом. System Точка. Далее oyt. Точка. Println. Далее скобка. И внутри скобок напишем таким образом. Кавычки и далее Р1.x равняется, Р1.x.

Затем выведем Р1.y. Р1.y равняется. И плюс Р1 точка y. Само значение. Закрыть скобку. Точка с запятой. Скопируем теперь эту строчку. Правая кнопка мыши, Сору.

Далее Enter. Вставим. Правая кнопка мыши. Paste. И вместо Р1, напишем Р2 во всех соответствующих местах.

Скомпилируем теперь эту программу и попробуем ее выполнить. Для этого щелкнем на пункте Tools. Далее Compile Java. Компиляция прошла успешно. Теперь Tools, Run Java Application. И как можно видеть, как мы и ожидали, мы получили ответ на нашем экране. А именно, координаты x и y в точке Р1 и x и y в точке Р2. И можно видеть, что это различные координаты, несмотря на то, что класс один и тот же. Но объекты разные. Экземпляры этого класса разные. Наверху Р1, а внизу Р2. Закроем консольное окно.

И вернемся в наш обычный текстовый редактор. Попробуем теперь все то же самое сделать несколько иначе. А именно, попробуем в наш класс Point внести некий метод. Т.е. напишем некую подпрограмму, которая будет выполняться внутри этого класса Point. Для этого щелкнем здесь на Enter и далее напишем, таким образом: void.

Далее init. Пусть этот метод называется инициализация. Здесь может быть любое имя. Далее скобка, внутри которой мы можем написать те параметры, которые хотим передавать этому методу. Ну пусть у нас два параметра будут, оба целого типа: integer, и их значение будет Х0 и далее опять целое int и Y 0. Закрыть скобку.

А теперь фигурные скобки, внутри которых и попробуем провести инициализацию внутри этого метода. Ну, конечно же, просто-напросто Х присвоим значение Х0. Точка с запятой. А "Y" присвоим значение Y0. Вот теперь мы можем воспользоваться вот этим методом init в нашей основной программе, в методе main, класса My 11. Который как раз и выполняется при запуске нашей программы.

Теперь же попробуем переделать вот эти две строчки, в которых мы определяли поля X и Y объекта Р2. Для этого уберем эти две строчки и напишем таким образом. Имя этого объекта Р2, точка. И далее метод init, который теперь появился у этого класса Point: point. Скобка и далее нам нужно определить те передаваемые параметры, которые мы написали в этом классе Point.

Как мы видим, здесь два параметра Х0 и Y0. Присвоим им какие-то значения. Например, 55 запятая 66. Закрыть скобку. Точка с запятой. Попробуем теперь скомпилировать эту нашу программу и выполнить. Правда, перед этим исправим одну ошибку. А именно, впишем здесь недостающую точку с запятой, которую мы забыли поставить после оператора присваивания. Скомпилируем теперь эту программу и попробуем ее выполнить. Для этого щелкнем на пункте Tools. Далее Compile Java. Компиляция прошла успешно. Теперь Tools, Run Java Application.

Как мы видим, и на этот раз у нас все прошло достаточно гладко. Мы проинициализировали вот этот объект Р2, который является экземпляром класса Point класса точки с числами 55 и 66 соответственно. Закроем теперь это консольное окно и вернемся в наш обычный текстовый редактор.

Начальная инициализация. Конструктор классаК оглавлению

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

Вот таким образом переделанный метод init делает то же самое, что он делал ранее. Попробуем это проверить. Для этого щелкнем на пункте Tools, Compile Java. Теперь опять Tools, Run Java Application. И как мы видим, результат выполнения программы абсолютно идентичен тому, что мы видели ранее: p2, Х и Y опять равны 55 и 66, так как мы и задавали в программе.

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

Очень часто при работе с класса, при создании нового экземпляра этого класса соответствующего объекта, мы сталкиваемся с тем, что объект и его поля определяются прямо при его создании, во время выполнения операции new. Конечно же, хотелось бы, чтобы при вот этом же определении внутри Point, внутри вот этих скобок, мы могли бы задать какие-то числа, которые и были бы полями Х и Y для этого класса Point. И не пользоваться для этих целей отдельным методом init.

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

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

И то же самое можем сделать с вот этими двумя определениями X и Y. Но их пока сохраним. Просто-напросто поставим галочки, закомментировав эти две строки. А в определении Р1 и Р2 объектов, вместе с Point со скобками без параметров, теперь нам нужно здесь написать параметры. Потому что, если мы, таким образом, запустим наше приложение, то компьютер нам выдаст ошибку.

Дело в том, что мы уже по умолчанию задали конструктор Point с параметрами, с двумя целыми числами. Поэтому напишем здесь, таким образом, 11 запятая 22, а в точке 2, напишем, например, таким образом, 77 и 88. Если сейчас запустим нашу программу, сначала скомпилируем, Compile Java.

Далее Tools, Run Java Application. Потом можно увидеть, как мы и ожидали, мы получили те значения, которые мы задавали при определении этих двух точек Р1 и Р2, 11 и 22, и 77 и 88. Закроем.

Попробуем убрать комментарии с вот этих двух строчек, написав здесь какие-либо другие числа. Например, поставим посередине 3. Пусть будет 131 и 232. Сейчас, если мы скомпилируем, Tools, Compile Java, далее Tools, Run Java Application, то можно увидеть, что несмотря на то, что при инициализации точки Р1, ей было присвоено значение 11 и 22, после этого, мы явным образом присвоили Х и Y, полям этой точки Р1 значение 131 и 232, которые и появились при распечатке на нашем консольном окне. Закроем это консольное окно.

Попробуем переделать наш класс таким образом, чтобы мы могли задавать не только точку Points с параметрами, но и точку Point без параметров, поскольку, например, задание значений 11 и 22 для нашей точки Р1, сейчас абсолютно излишне, учитывая, что в следующих строчках переопределяем эти значения. И явным образом присваиваем Х и Y новые значения.

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

Далее фигурные, открывающие и закрывающие скобки. Теперь скомпилируем. Tools, Compile Java. Далее Tools, Run Java Application. Теперь, как мы видим, у нас все прошло гладко. Результат получился точно также. Закроем.

Здесь мы видим, что при определении нового объекта класса Point, мы можем воспользоваться двумя, совершенно разными подходами. Т.е. мы можем определить внутри него прямо его поля, вот при помощи двух параметров, или же оставить, так сказать, это дело открытым. Просто-напросто указав класс Point со скобками, без параметров. И определив его поля Р1 Х и Р1 Y позже.

Внутри конструктора без параметров Point, мы можем задать не только вот такие пустые фигурные скобки, но можем определить какие-то параметры, которые мы хотим задать по умолчанию. Например, вот эти значения X и Y по умолчанию мы хотим задать каким-либо образом. Для этого напишем таким образом. Ключевое слово this теперь нам уже не нужно, поскольку формальных параметров Х и Y при определении конструктора Point в этом случае у нас нет. Поэтому можем прямо написать: Х, равняет.

И, например, определить таким образом. Х равняется 99, а Y пусть равняется по умолчанию -99. Точка с запятой.

Теперь же, правда, если мы выполним эту программу еще раз вот таким образом, пока ничего не изменится, поскольку и в первом случае определение Р1 мы явно задавали его значения. И в случае Р2, но если мы определим еще одну точку Point Р3, для этого скопируем вот эту строчку. Выделим ее. Правая кнопка мыши. Сору. Далее Enter. Вставим сюда. Правая кнопка мыши и Paste.

Назовем эту точку Р3. Параметры пусть будут вот такими. Т.е. без параметров. И выведем ее тоже на печать. Для этого, конечно же, скопируем вот эту строчку. Выделим. Правая кнопка мыши. Сору.

Далее сюда встанем. Правая кнопка мыши и Paste. Напишем везде Р3. Как мы видим, у нас внутри вот этой программы main ни в одном месте к Р3 не присваиваются никакие значения для его полей. И попробуем сейчас скомпилировать. Запустить и посмотреть, что у нас получилось.

Теперь скомпилируем. Tools, Compile Java. Далее Tools, Run Java Application. И как мы видим, к Р3Х и Р3Y присвоили соответствующие значения по умолчанию, 99 и -99, так как мы и задавали при определении конструктора Point без параметров. Закроем теперь это консольное окно и мы вернулись в наш обычный текстовый редактор.

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

И внутри скобок, те значения, которые мы хотим присвоить Х и Y. Возьмем опять то же самое. 99 запятая и возьмем, например, 77. Закрыть скобку. Теперь вот этим оператором this мы опять вызываем внутри нашего конструктора Point, его предыдущую версию, в которой у нас и определены Х и Y. Точка с запятой.

Теперь же попробуем посмотреть, как все это работает. Для этого Tools, Compile Java. Далее Tools, Run Java Application. Запустим наше приложение и, как мы видим, у нас опять все получилось так, как мы и задумали. В третьем случае, в случае точки Р3, в котором мы просто-напросто вызвали конструктор Point без параметров, мы получили по умолчанию значения 99 и 77, так как мы и записали. Закроем теперь это консольное окно. Нажмем на вот этот крестик и вернулись в наш обычный текстовый редактор.

Методы классаК оглавлению

Наберем это имя. Далее внутри скобок, укажем его параметры. Ну, поскольку это будет другая точка, у нее параметры тоже будут Х и Y. Они должны быть опять-таки, конечно же, целыми числами: int Х запятая, int Y. Закрыть скобку.

И теперь внутри фигурных скобок мы должны написать, что бы должен делать оператор distance. Сначала, посчитаем разность координат по оси Х и по оси между этими двумя точками. Точка Х, которая задается в формальных параметрах и координатами Х и Y, которые у нас есть в нашей точке. Назовем этот параметр DX и DY.

Зададим их внутри нашего метода distance. Они тоже, конечно же, будут целыми. Поэтому напишем, таким образом, int DX, равняется. Для того чтобы нам обратиться к координате нашей точки Point, используем опять ключевое слово this. Точка Х и вычесть Х. Вот второе Х, это у нас вот этот формальный параметр. Точка с запятой.

Теперь абсолютно то же самое для координаты Y: int DY. Разность координат по оси Y: равняется this точка Y. Вычесть Y. Точка с запятой. Вот теперь у нас уже есть DX и DY, теперь же, чтобы посчитать расстояние, нам нужно извлечь корень из суммы квадратов DX и DY.

Для этого нам потребуется оператор из пакета math, который называется sqrt. И к тому же зададим нашему методу distance. возвращаемое значение, которое, конечно же, целым уже никак не может быть. Оно будет у нас действительным числом. Поэтому зададим double, и теперь напишем таким образом: return, для того чтобы указать, что это у нас возвращаемое значение.

Далее Math. Точка sqrt, и внутри скобок нам нужно DX и DY в квадрате, просто напишем, DX умножить на DX, прибавить DY, умножить на DY. Закрыть скобку. Точка с запятой.

А теперь для полной корректности нашей программы, мы, конечно же, должны импортировать пакет Math. Для этого в самом начале нашего приложения зададим это включение. Напишем Импорт. Далее Java Math. Точка Math. Точка звездочка. Точка с запятой.

Также подсчитаем расстояние от какой-либо точки до другой. Например, можем подсчитать расстояние от центра координат 00 до, например, точки Р2. Для этого опять скопируем этот println. Выделим. Далее правая кнопка мыши. Сору.

Вставим сюда. Правая кнопка мыши и Paste. И теперь напишем таким образом. Кавычки. Далее distance. И напишем таким образом, расстояние от точки с координатами 00, и точки, возьмем, например, Р2.

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

И внутри скобок нам нужно указать координаты той точки, относительно которой мы и хотим подсчитать расстояние. Мы хотели взять 0 запятая 0. Закрыть скобку. Далее скобка. Точка с запятой. Теперь же, как раз подсчитаем расстояние между этими точками. Запустим наше приложение. Для этого сначала его скомпилируем, Tools. Далее Compile Java.

После того, как компиляция прошла успешно, мы можем запустить наше приложение. Для этого Tools, Run Java Application. Запустим. И вот, как мы видим, расстояние от точки с координатами 00 от начала координат до точки Р2, будет вот такая величина 116, 9.

В принципе можно проверить на калькуляторе и подсчитать. Но сейчас это делать не будем. Закроем наше консольное окно и вернемся в наш текстовый редактор.

Попробуем теперь подсчитать расстояние не от точки 0 до точки Р2, а между двумя точками. Например, между точкой Р2 и точкой Р1. Для этого скопируем вот эту строчку распечатки, выделим ее. Далее правая кнопка мыши. Сору. Далее вставим сюда. Правая кнопка мыши и Paste.

И немножко его переделаем. Вместо 0 напишем здесь Р1, и расстояние между Р1 и Р2 у нас будет выражаться таким образом. Р2 distance, это все оставляем, а далее напишем Р1 точка Х, его Х координата. И в качестве координаты Y будет у нас Р1 точка Y.

Запустим приложение. Для этого Tools, Compile Java. Далее Tools, Run Java Application. И можно видеть расстояние от точки Р1 до точки Р2. Она выражается вот таким числом. Закроем.

Попробуем сейчас то же самое расстояние между точками Р1 и Р2 выразить несколько по-другому, поскольку, конечно же, вот такая запись, когда мы Р1 разбивали на Р1Х, Р1Y, в принципе явно лишняя. Поскольку расстояние от точки Р2 до точки Р1, конечно, характеризуется просто заданием точки Р2 и точки Р1.

Как же это сделать? Для этого нам нужно написать метод distance, еще раз немножко по-другому. Конечно же, этот метод distance, который у нас уже есть и который опирается на задание двух параметров Х и Y, мы переделывать не будет, а напишем его второй вариант. Для этого напишем опять Double. Далее distance. То же самое имя. Теперь в качестве параметров мы должны сделать точку типа Point, поэтому напишем Point. Далее пусть это будет точка Р. Закрыть скобку.

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

Поэтому напишем, таким образом, return, поскольку это возвращаемый параметр. А далее возвращение к методу distance. Опять напишем distance. поэтому. И внутри скобок, теперь уже нам нужно задать Х и Y две координате точки. А поскольку у нас точка Р, поэтому Х и Y будет Р точка Х запятая и далее Р точка Y.

Закрыть скобку. Точка с запятой. Ну и теперь воспользуемся вот этой второй записью distance, и напишем то же самое расстояние от точки Р1 до точки Р2. Поэтому выделим вот эту строчку. Правая кнопка мыши. Сору.

Далее встанем сюда. Правая кнопка мыши и Paste. И расстояние от точки Р1 и Р2 посчитаем, не вписывая его в качестве вот этих передаваемых параметров, его координаты Х и Y, а просто-напросто, задавая точку Р1. Поэтому вот этот выделенный текст явно лишний. Мы его целиком стираем. И вот в таком укороченном виде попробуем запустить наше приложение.

Для этого Tools, Compile Java. Далее Tools, Ran Java Application. Ну и, конечно же, у нас результат абсолютно одинаковый. Вот эти две последние строчки, они идентичны. Хотя вычисляются и записываются несколько по-другому. Так сказать от перестановки мест слагаемых сумма меняться не должна. Закроем теперь наше консольное окно и вернемся в наш текстовый редактор.

Создание нового классаК оглавлению

Далее Point. Далее 3D, далее Enter и теперь определим те переменные, которые у нас должны быть вот в этом классе Point 3D. Конечно же, у нас должно быть целых три параметра, X, Y и Z. Поэтому зададим: X, Запятая Y, запятая Z. Точка с запятой.

Теперь же определим его конструктор. Определим самый простой. Поэтому напишем Point. 3D. Далее внутри скобок должны быть его формальные параметры, которые пусть будут int Х, int Y и еще одна целая int Z.

Закрыть скобку и теперь внутри фигурных скобок, определим создание этой трехмерной точки. Для этого нам нужно написать: this Х равен Х. Только, единственное, добавится еще третья размерность Z.

Поэтому напишем, таким образом, this, точка Х равняется Х. Далее точка с запятой, this. Точка Y равняется Y. И теперь, в отличие от предыдущего случая, у нас добавляется еще одна размерность Z, this Z равняется Z.

Точка с запятой. Закрыть фигурные скобки. И закроем еще одну фигурную скобку, чтобы закрыть весь наш класс. А теперь исправим ошибку. Мы неявно предположили, что мы хотим создать Point 3D, это у нас класс. Ну, конечно же, об этом нигде не указали, не написали. Поэтому напишем здесь слово class перед заданием Point 3D, и теперь у нас уже задается класс Point 3D совершенно полномочно.

Теперь же зададим, что у нас должно создаваться, если мы указываем метод Point 3D без параметров. Поэтому напишем, таким образом, Point 3D. Далее открывающаяся и закрывающая скобки, что будет означать, что у нас указывается без параметров.

Далее используем так же, как и в случае первой точки, ключевое слово this, ссылаясь на предыдущее описание метода. Единственное, зададим более естественное определение точки без параметров. Пусть это будет точка 00, начало координат, исправляя и в случае двумерной точки.

Теперь то же самое напишем в трехмерном случае: this. Далее скобка и на этот раз у нас так сказать будет три нуля, и закрыть скобку.

Вот теперь, если мы указываем метод Point 3D без параметров, то сразу же создается точка с началом координат.

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

Для этого сдвинемся при помощи ползунка вниз и определим еще новые точки Point. На этот раз Point 3D. Предварительно распечатаем еще один println, для того чтобы отделить, так сказать, всю нашу работу с двумерными точками от трехмерной точки. Для этого выделим вот этот кусочек текста. Для этого правая кнопка мыши. Сору.

И этот println вставим на следующей строчке, Paste. И внутри кавычек напишем просто-напросто вот такую разделительную черту. Далее кавычки. Закрыть скобку. Точка с запятой.

Теперь же зададим трехмерные точки. Для этого нужно написать имя нашего класса Point. На этот раз, конечно же, 3D. И далее пусть это будет, Р4 точка. Знак равенства, далее new. Как обычно Point.

И точку Р4 определим без параметров, как есть по умолчанию. Возьмем еще одну точку Point, тоже 3D. Пусть эта будет точка Р5, равняется new.

Point. И далее внутри скобок определим его все 3 координаты, X, Y и Z. Ну, пусть эти координаты будут такими, 25, например, 37 и 44. Закрыть скобку. Точка с запятой.

Вот у нас уже теперь есть две точки Р4 и Р5, которые являются трехмерными. Для их распечатки воспользуемся вот таким оператором println, поэтому скопируем вот эти две строчки. Далее правая кнопка мыши и Сору. А теперь встанем сюда. Правая кнопка мыши и Paste.

И теперь, во-первых, переделаем единицу на 4, нам нужна именно точка Р4. И двойку на 5, чтобы распечатать именно Р4 и Р5.

И далее, после того, как мы все это сделали, нам надо добавить еще кусочек текста, для того чтобы распечаталась еще и третья координата Z. Поэтому напишем таким образом, Р4 точка Z. равняется. Закрыть кавычки.

Плюс, далее Р4 точка Z, само значение. Ну и то же самое нам нужно написать для точки 5. Кавычки. Далее Р5, точка Z, его Z координата равняется кавычки, плюс и его значение. Р5 точка Z.

Теперь же попробуем запустить наше приложение и его выполнить. Но прежде, нам нужно исправить несколько ошибок, которые мы допустили. В частности, при задании метода Point 3D мы тут пропустили точку с запятой, после оператора, что необходимо, а также при задании новой точки Р4 и Р5, мы по старой памяти определили new Point, вместо Point 3D.

Поэтому вставим здесь 3D, в той же самой строчке ниже. Вот теперь мы можем запустить наше приложение. Для этого сначала скомпилируем, Tools, Compile Java и после этого можем запустить наше приложение на выполнение. Для этого Tools, Ran Java Application.

И вот можно видеть результат выполнения нашей программы. Ну точка Р4, которая у нас была точка по умолчанию, это у нас точка с координатами 000, так же как и было задумано. То же самое с точкой Р3, которая у нас двумерная, но по умолчанию опять-таки теперь задается с координатами 00.

И вот эта точка Р5 приняла соответствующее значение, которое мы вписали при ее задании. Закроем теперь наше консольное окно и вернемся в наш текстовый редактор.

НаследованиеК оглавлению

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

Сдвинемся сначала при помощи ползунка вверх, немножко переделаем наш класс Point 3D. Напишем, таким образом, после названия и класса Point 3D, напишем ключевое слово extend, и далее класс Point.

Что теперь это означает. Это означает, что класс Point 3D будет создаваться на основе класса Point, является его наследником. И в этом случае, нам уже Х и Y указывать во время создания этого класса уже совсем необязательно. Х и Y мы здесь удалим, и оставим только переменную Z.

А переменные Х и Y класс Point 3D возьмем из своего родительского класса Point, вот из этого места. Если мы сейчас скомпилируем и запустим нашу программу, Tools, Compile Java, далее Tools, Ran Java Application.

то можно увидеть, что мы получили абсолютно то же самое, что и в предыдущем случае. Т.е. все это успешно работает. Поэтому закроем это окно.

Класс Point мы можем использовать не только для использования его переменных в классе Point 3D, но можно использовать его методы. В частности, при написании метода Point 3D конструктора, при помощи которого мы создаем трехмерную точку, мы можем использовать часть кода, который у нас уже существует в классе Point. Вот это место.

Для этого вместо присваивания Х и Y, которые у нас здесь есть, мы можем написать несколько другим образом. Удалим этот текст и далее напишем super, и далее внутри скобок Х и Y, передавая, таким образом, координаты Х и Y, конструктору класса Point.

Т.е. вот этим оператором super, мы непосредственно обратились к конструктору класса Point, который как раз и выполнил вместо класса Point 3D присваивание координаты Х и Y, а вот координату Z, тут пришлось присваивать непосредственно, потому что, конечно, в двухмерном случае этой координаты не было.

Теперь, если мы опять скомпилируем и запустим нашу программу Tools, Compile Java. Далее Tools, Ran Java Application, можно увидеть, что и в этом случае у нас все прошло абсолютно точно так же, как и ранее. Т.е. вот таким образом, мы вполне свободно можем пользоваться методами, переменными суперкласса, родительского класса.

Закроем. Теперь же надо отметить еще одно обстоятельство. Поскольку у нас класс Point 3D является наследником класса Point, то все методы, которые есть у класса Point, мы можем использовать. В частности у метода Point есть метод distance, который считает расстояние между двумя точками. Попробуем им воспользоваться. Для этого сдвинемся при помощи ползунка ниже. Скопируем вот эту строчку. Для этого ее выделим. Правая кнопка мыши и Сору.

Далее вставим его в конец нашего текста. Правая кнопка мыши и Paste. И теперь изменим немножко эту строчку. Вместо Р2 возьмем точку Р5 и возьмем расстояние от центра координат 0 до этой точки Р5. Как оно будет выражаться.

Вместо Р2 напишем Р5, а параметров здесь у нас должно быть 2, так как это у нас было в двумерном случае. Поскольку этот метод distance, он у нас взят прямо из двумерного случая. Поэтому на самом деле он считает расстояние не между двумя точками, а расстояние между проекцией точки Р5 на ось XY и точкой 00, т.е. центром координат. Координата Z в этом случае абсолютно не учитывается. Посмотрим, так ли это.

Щелкнем на пункте Tools, Compile Java. Далее Tools, Ran Java Application, и можно видеть, что расстояние от точки Р5, вернее от ее проекции на ось XY до центра 00, равняется вот такой величине. Закроем теперь наше приложение. Щелкнем на вот этом крестике. Сдвинемся теперь опять при помощи ползунка вверх.

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

Для того чтобы это сделать, щелкнем вот здесь на клавише Enter, освободим нам место и вставим сюда вот эти несколько строчек кода, где у нас считается расстояние в двухмерном варианте, и далее модернизируем этот код. Для этого выделим, вот, начиная с вот этого места и до конца. Вот эти строчки кода. Далее правая кнопка мыши. Сору. Теперь встанем сюда. Правая кнопка мыши и Paste.

Теперь, поскольку у нас distance должен считать трехмерным вариант этого выражения, напишем здесь запятую и введем третье измерение Z: int, Z, далее введем аналогично с DX и DY еще разность координат по оси Z. Она тоже будет целой, int.

Далее DZ, разность между this Z и параметром Z. Точка с запятой. Ну и в выражении для квадратного корня надо еще дописать третью координату: DZ умноженное на DZ.

Вот теперь этот метод у нас будет работать правильно, и для общности переделаем вот этот метод distance, который считает расстояние между двумя точками, не ссылаясь не на три параметра X, Y, Z, а на другую точку p.

Напишем здесь, таким образом, запятая и введем третью координату Z. Р точка Z. Далее переделать надо еще определение точки Р. Она у нас, конечно же, должна быть не Point, а Point 3D. Напишем здесь 3D. Далее воспользуемся плодами наших трудов, для того чтобы подсчитать расстояние между двумя точками.

Сдвинемся при помощи ползунка ниже. И подсчитаем на этот раз расстояние между двумя точками. Ну, подсчитаем расстояние от точки Р5 до начало координат. Для этого выделим опять эту строчку. Правая кнопка мыши. Сору.

Встанем сюда. Правая кнопка мыши и Paste. И на этот раз возьмем расстояние не от точки 00, не от проекции, а введем еще одну точку 0, для того чтобы подчеркнуть, что это у нас трехмерный вариант. Ну и в метод distance введем третий параметр 0. То же самое можно сделать и по-другому, поскольку у нас точки 000 началом координат является Р4. Поэтому напишем таким образом. Встанем сюда эту же строчку. Правая кнопка мыши и Paste.

И напишем здесь так distance Р4, Р5. Расстояние между точками Р4 и Р5 будет Р5 distance, и в качестве параметра укажем Р4. Вот эту точку. Теперь скомпилируем эту программу. Для этого Tools, Compile Java.

Далее Tools, Ran Java Application. и можно увидеть на этот раз, что у нас получилось. Как мы видим, расстояние между проекцией точки Р5 и началом координат 44 целых и далее дробная часть. А расстояние от точки Р5 до начало координат так сказать в трехмерном варианте уже равно 62 и т.д.

Ну и ниже, расстояние между точками Р4 и Р5, Р4 как раз и является точкой началом координат. Ее координата 0, 0, 0, тоже, конечно, та же самая величина 62 целых и т.д. дробная часть. Закроем теперь это консольное окно и вернемся в наш текстовый редактор.

Создание собственных классов. Конструкторы. МетодыК оглавлению

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

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

Назовем его Employee, и затем фигурные скобки. И уже в таком виде программу можно скомпилировать. Она не выдаст ошибку, поскольку класс полностью создан. Правда, он абсолютно пустой и ничего не делает. Попробуем сейчас ввести для него какие-либо параметры. И первое, что нам нужно сделать, это создать те поля, те переменные, которые будут в нашем классе, и которыми он будет оперировать. Ну и, конечно же, если это у нас класс, касающийся сотрудников, обязательно должно быть имя этого сотрудника. Поэтому напишем таким образом, String, потому что имя у нас должно обязательно находиться в переменной строкового типа. Выберем имя для этой переменной. Пусть это будет name, точка с запятой. Далее зарплата этого сотрудника.

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

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

Вот, теперь у нас эти две переменные закрыты. Ими можно пользоваться только внутри этого класса Employee. Теперь, после того, как мы определили поля этого класса, его переменные нам, конечно же, нужно создать конструктор. Т.е. тот метод, при помощи которого и создается объект этого класса. Как мы помним, имя конструктора обязательно должно совпадать с именем самого класса. Поэтому напишем таким образом, public,

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

Пусть это будет у нас n, далее запятая и зарплата salary, которая опять будет числом с двойной точностью double. И далее возьмем имя для этой переменной. Пусть это будет просто буква s.

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

name, знак равенства n, точка с запятой. Далее salary знак равенства s, точка с запятой. Вот, после этих строчек у нас уже полностью определен конструктор Employee. Теперь нам надо позаботиться о том, как же нам из этого объекта данного класса получить его данные. Т.е., например, его имя, которое у нас находится в переменной name и зарплату salary. Конечно, мы могли оставить эти две переменные открытыми, убрав private и вместо них написав public, или оставить без явного определения кода доступа, что в принципе по умолчанию означает public, но поскольку мы их обоих закрыли, теперь надо позаботиться о доступе к этим переменным. Для этого в нашем классе Employee предусмотрены два метода, при помощи одного из них, выдается имя, а при помощи другого, зарплата. Эти методы, конечно же, надо сделать public, открытыми для доступа.

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

Поэтому напишем return и далее просто name, точка с запятой. Теперь напишем еще один метод, аналогичный этому, который возвращает зарплату salary.

Он, конечно, тоже у нас должен быть public. Далее опять get. Поскольку мы хотим получить зарплату и далее Salary. Скобки. И далее, внутри фигурных скобок нам нужно опять написать return и далее salary,

возвращаемые данные, return salary и точка с запятой. Теперь у нас какой-то минимальный код для работы нашего класса Employee уже есть и теперь попробуем его применить, т.е. создать несколько объектов этого класса. Это все мы уже сделаем внутри класса My12, внутри которого и находится у нас самый главный метод main, который и выполняет наши программы. Поэтому вот здесь введем return после вывода вот этой стандартной строки, с которого начинается наша программа и ее выполнение. И далее создадим несколько объектов нашего класса Employee.

Поэтому напишем имя этого класса Employee, пробел и далее создадим именно этот объект. Пусть это будет staff. Далее знак равенства и ключевое слово new, при помощи которого мы создаем новый объект и название класса Employee. Этим мы вызываем возможность создания нового объекта этого класса. Конечно, вот таким образом у нас создастся один экземпляр этого класса. А если же мы хотим создать несколько экземпляров, то для этого лучше всего воспользоваться возможностями, которые нам предоставляет массив. Поэтому мы создадим массив такого типа. Для этого нам после Employee надо написать открывающие и закрывающие квадратные скобки

и то же самое надо сделать в конце объявления класса Employee. Здесь тоже открывающие и закрывающие квадратные скобки, внутри которых нам нужно указать размерность нашего массива. Ну, пусть, например, у нас три сотрудника в нашем списке.

Модифицирующие методы и методы доступаК оглавлению

Точка, закроем кавычки, запятая. Теперь следующий параметр, который является его зарплатой. Пусть его зарплата выражается числом 50000, закроем скобку, точка с запятой.

Создадим еще одного сотрудника. Опять staff. На этот раз индекс у него будет 1, знак равенства. Опять new Employee. Скобка. Далее кавычки и внутри кавычек напишем его имя. Пусть имя у него будет Adams R. A. Закроем кавычки, запятая и дальше надо написать его зарплату. Пусть у него зарплата будет 60000. Закроем скобку, точка с запятой. Введем третьего сотрудника.

У него индекс будет 2. Знак равенства, далее скобка и кавычки. И напишем имя для этого сотрудника. Пусть его фамилия будет Taylor А.А, кавычки, запятая. Теперь нам надо написать его зарплату. Пусть у него будет поменьше. Допустим, 35000. Закроем скобку, точка с запятой.

И вот, после того, как мы заполнили данные обо всех наших сотрудниках, мы это все можем вывести на экран. Для этого организуем цикл. Цикл, конечно же, возьмем for. Далее скобка, int i, переменная цикла, точка с запятой. Далее i меньше, чем staff length, чем длина нашего массива. Далее увеличение его на единицу за один цикл. Закроем скобку. И теперь внутри фигурных скобок попробуем распечатать данные о наших сотрудниках. Для этого воспользуемся вот этим println. Выделим вот этот кусочек текста. Скопируем его. Правая кнопка, Сору. Вставим сюда. Правая кнопка и Paste.

И затем напишем таким образом. В кавычках name, далее введем знак равенства. Закроем кавычки, плюс и имя нашего сотрудника. Для этого напишем staff, его индекс i, точка и тот параметр, который мы хотим получить. А именно getName.

Введем скобки. Внутри скобок мы ничего не должны писать, поскольку параметров у этого метода нет. Далее закроем еще одну скобку и точка с запятой. Вот таким образом мы уже сможем вывести имена наших сотрудников. Но теперь заметим, что в параметре i, в параметре цикла мы забыли присвоить начальное значение, и к тому же при задании метода getName и getSalary, мы не указали тип возвращаемого значения. Это неправильно. GetName возвращает нам имя. Оно должно быть параметром String, поэтому зададим таким образом. А getSalary, зарплата, у нас должна выражаться действительным числом. Поэтому напишем double.

Теперь попробуем скомпилировать и посмотреть, что у нас получилось. Для этого Tools, затем Compile Java, и в результате компиляции, тем не менее, нам компилятор выдал ошибку. В чем дело? Дело в том, что если присмотреться, то можно увидеть, что в слове Employee мы пропустили букву p. Перейдем на текст нашей программы и исправим эту ошибку. Вот сюда надо вставить p. Это просто грамматическая ошибка. Далее Tools, Compile Java. Запустим нашу программу, Tools и Run Java Application. И можно увидеть, что у нас получилось. Выданы имена всех трех сотрудников.

Закроем наше консольное окно. И попробуем сделать так, чтобы вместе с именами, выдавалось еще и их зарплата. Для этого введем здесь плюс, далее кавычки и внутри них напишем слово salary, знак равенства, закроем кавычки, плюс. Опять get, на этот раз getSalary, переменная staff с индексом i, точка. Далее getSalary,

открывающая и закрывающая скобки. И после этого у нас уже вся программа полностью готова для выдачи не только сотрудников, но и их зарплаты. Попробуем это сделать. Tools, Compile Java. Далее опять Tools и Run Java Application. И вот, можно увидеть результат выполнения нашей программы. Выданы фамилии сотрудников и их зарплаты. Закроем это консольное окно и теперь попробуем предусмотреть метод, при помощи которого мы можем изменять зарплату нашим сотрудникам, и, конечно, самое простое, это повысить им всем зарплату на какое-то количество процентов. Для этого нам нужно предусмотреть специальный метод, который назовем raise Salary. Напишем его здесь.

Для этого введем Enter, конечно же, этот метод у нас должен отмечаться, как public, чтобы он был доступен из нашей программы. Далее тип возвращаемого значения. Но, поскольку возвращаемого значения в данном случае не будет, напишем просто void, далее имя этого метода raiseSalary.

Далее скобка. И внутри скобки нам нужно указать формальный параметр, в котором у нас будет процент повышения этой зарплаты. Он у нас тоже будет действительным числом с двойной точностью. Double и далее byPercent,

на сколько повышается эта зарплата. Закроем скобку. Далее откроем фигурные скобки, внутри которых нам нужно написать код. Это реализуем при помощи следующего выражения. Salary, знак умножения, зарплата должна увеличиться, знак равняется и далее таким образом. Единица плюс количество процентов, на которое мы должны увеличить, byPercent

и далее делить на 100, поскольку коэффициентов у нас ровно 100. Вот таким образом мы увеличиваем зарплату наших сотрудников. Теперь попробуем это реализовать внутри нашей программы. Для этого нам нужно организовать опять цикл, который мы можем скопировать из вот этой строчки. Скопируем. Правая кнопка мыши, Сору. Вставим сюда. Далее правая кнопка и Paste. И теперь напишем здесь то, что мы хотим выполнить. А именно, увеличить зарплату нашим сотрудникам. Реализуем при помощи staff, номер сотрудника i, точка и метод raiseSalary.

В скобках нам нужно указать, на сколько мы увеличиваем зарплату. Будет достаточно щедрыми, и увеличим на 10 процентов. Закроем скобку, точка с запятой. Теперь, после повышения зарплаты выведем список всех сотрудников с новыми значениями зарплаты. Для этого скопируем вот эти две строчки. Правая кнопка мыши и Сору. Встанем сюда. Далее правая кнопка мыши, Paste. Попробуем теперь выполнить эту программу. Для этого Tools, Compile Java. И после того, как все прошло успешно, запустим окно, Tools и Run Java Application. Можно видеть, как у нас увеличилась зарплата наших сотрудников,

после повышения на 10%. Закроем теперь это консольное окно и попробуем, во-первых, ввести какой-либо разделитель между двумя выводами текста с обычным выводом и с повышением зарплаты. Для этого скопируем вот этот println. Правая кнопка мыши, Сору. Встанем сюда. Правая кнопка и Paste. Теперь внутри фигурных скобок напишем new salary,

кавычки, закроем скобку, точка с запятой. А цикл, при помощи которого мы выводим на экран наших сотрудников, организуем иначе. А именно, введем новый объект типа Employee. Для этого напишем Employee. Пусть это будет просто одна буква e, которой присвоим значение staff с индексом i.

Это у нас сотрудник с индексом i, точка с запятой. И теперь, при распечатке в следующей строке println мы можем, как раз использовать вот это e, где у нас текущий сотрудник, вместо имени staff, что несколько сокращает нашу запись и делает ее несколько более читабельной. Так, в принципе выполняет она все то же самое. Попробуем теперь скомпилировать и выполнить нашу программу. Для этого Tools, Compile Java. Компьютер нам выдал ошибку. У нас опять проблема с буквой p. Она у нас пропечаталась в названии Employee, поэтому перейдем на текст нашей программы

и вставим эту букву. Далее Tools, Compile Java. На этот раз все нормально. Запустим программу, Tools и Run Java Application. И можно увидеть, что у нас получилось. Эти два списка сотрудников отделились друг от друга. Между ними появилась надпись New salary. А сами числа, конечно же, остались теми же самыми. Закроем теперь наше окно и вернемся в наш текстовый редактор.

Доступ к закрытым даннымК оглавлению

чтобы определить смогли ли мы придать новое значение нашему сотруднику и далее setSalary. Если мы раньше делали getSalary, то на этот раз у нас будет setSalary. Поскольку мы хотим именно присвоить значение. Далее скобка и далее тот параметр, который мы хотим передать нашему классу с этим методом. Это опять будет переменная типа double, действительное число. Далее пусть это будет newSalary.

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

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

Если это значение, например, меньше, чем 10 000, представим себе, что у нас политика компании такая, что зарплату меньше 10 000 мы никому не назначаем. Это у нас минимальная зарплата. Далее закроем скобку. Что мы должны делать в этом случае? В этом случае, если у нас введено вот такое маленькое число, то мы ничего не делаем, новую зарплату не присваиваем, а просто возвращаем false для нашего метода, в качестве возвращаемого значения, return,

и далее false. Поместим теперь этот оператор return внутри фигурных скобок, и далее напишем оператор else, т.е. что у нас должно происходить в ином случае, если у нас все нормально, и число мы задали правильно. Оно больше или равно этих 10 000.

Далее введем фигурные скобки, внутри которых введем вот это присваивание новой зарплаты сотруднику. А далее введем возвращаемое значение при помощи return, и на этот раз у нас все нормально. Поэтому так и напишем, true, точка с запятой и закроем фигурную скобку. Введем еще точку с запятой после первого оператора return, с return, который возвращает false, и теперь попробуем использовать этот метод в нашей программе. Двинемся для этого скроллингом вниз, и введем нашему сотруднику с индексом 1 новую зарплату. Для этого staff, далее фигурная скобка, 1, точка. Теперь воспользуемся этим новым методом setSalary.

Далее скобка, внутри которой напишем новое значение зарплаты. Пусть у него зарплата будет вместо 60 000, которая у него была, 73000. Закроем скобку. К тому же мы можем воспользоваться возвращаемым значением, которое нам выдает вот этот метод setSalary, поэтому впереди напишем оператор if.

Далее вот это значение. Как мы помним, оно выдает нам true, если присваивание произошло совершенно нормально, и поэтому теперь напишем Salary. Для этого введем фигурные скобки, внутри которых можем скопировать и вставить вот эти две строчки. Выделим их. Далее правая кнопка мыши, Сору.

И вставим в это место. Правая кнопка мыши и Paste. А теперь, вместо i, там нужно написать 1, и неплохо было бы еще написать кусок программы, который будет выполнять какие-либо действия, если мы ошиблись и ввели неправильное значение зарплаты. Поэтому напишем здесь false

и далее внутри фигурных скобок возвратим на наш экран новый текст, в котором просто напишем слово error. Для этого скопируем вот этот println. Правая кнопка мыши, Сору. Далее опять правая кнопка мыши, Paste. Далее кавычки и напишем error. Закроем кавычки, скобки, точка с запятой. После этого выведем опять вот это значение зарплаты. Для этого выделим вот эти две строчки. Правая кнопка мыши, Сору. Двинемся скроллингом. Теперь вставим. Правая кнопка мыши и Paste.

И напишем здесь другой текст. А именно, напишем oldSalary, старая зарплата. И теперь попробуем выполнить наше приложение. Для этого Tools, Compile Java. Далее Tools и Run Java Application.

Как видим, на этот раз все прошло достаточно гладко. Адамсу присвоили новую зарплату, 73 000. Закроем и попробуем теперь совершить ошибку. Вместо 73 000 мы написали, например, 730. В этом случае, после компиляции и запуска нашей программы система выдала ошибку error и оставила Адамсу старую зарплату, 66 000, которая появилась у него после повышения зарплаты на 10%.

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

Укажем public. Далее нам нужно указать тип возвращаемого значения. Пусть тип возвращаемого значения у нас будет целого типа, int. Поэтому напишем int, и будем выдавать (-1), если у нас зарплата сотрудника меньше, 0 - если равно, и 1, если больше, чем зарплата другого сотрудника.

Введем имя для нашего метода. Пусть это будет equals и далее передаваемый параметр. Это у нас будет Employee, т.е. мы будем передавать, с другого сотрудника, с которым нам нужно сравнить. Второй сотрудник у нас пусть будет other. Закроем скобку.

Использование нескольких исходных файловК оглавлению

Как мы видим, в нашем сравнении мы использовали доступ к закрытому полю salary, который теоретически является закрытым, для обращения из вне этого класса. Но дело в том, что метод может получить доступ к закрытым данным всех объектов своего класса. И поэтому такая запись является правомочной. И нам не придется при помощи get salary вытаскивать зарплату другого сотрудника. Достаточно воспользоваться вот таким прямым методом доступа. И теперь напишем, что будет происходить в этом случае. Конечно, если одна зарплата больше другой, тогда return, возвращаемое значение у нас будет 1. Точка с запятой, закроем фигурную скобку.

Теперь напишем, что у нас должно происходить в другом случае. Else, и внутри фигурных скобок напишем опять конструкцию if. If на этот раз salary равняется other salary. И если такое равенство верно, тогда возвращаемое значение будет return, равное 0. Точка с запятой, закроем фигурную скобку. Далее опять оператор else.

И, наконец, если у нас это неверно, тогда у нас salary будет меньше. Тут уже сравнение нам не нужно и поэтому просто напишем return минус 1. Точка с запятой, закроем фигурную скобку. Уберем лишнюю букву е. Исправим еще ошибку равенства. Конечно же, вместо знака равенства нужно было использовать знак сравнения. Теперь попробуем это все использовать в нашей программе. Для этого двинемся скроллингом вниз. Выделим теперь текст вывода нашей программы, оттого, что мы будем выводить ниже. Для этого скопируем println. Правая кнопка мыши, Сору.

Вставим сюда. Правая кнопка мыши и Paste. И внутри кавычек напишем вот такую разделительную линию. Закроем кавычки, скобку и точка с запятой. К тому же исправим вот эту ошибку. Вернее не ошибку, а то, что мы здесь экспериментировали. Задали маленькую зарплату, в результате чего компьютер при выполнении нашей программы выдает, что зарплата недостаточна. Увеличим ее опять. Пусть будет у него 73 000. Будем щедрыми к этому сотруднику. И далее сравним зарплаты двух сотрудников.

Введем теперь переменную типа String. Вернее массив, который будет состоять из трех значений. Назовем эту переменную s1, знак равенства, и внутри фигурных скобок проинициализируем таким образом. Первое значение будет less then. Закроем кавычки, запятая. Второе значение будет equals, запятая. И последнее значение more then. Закроем кавычки, скобку, точка с запятой.

Теперь, используя эту переменную s1, попробуем сравнить зарплаты двух сотрудников. Например, 1 и 3. Для этого напишем println. Скопируем вот этот кусок текста. Правая кнопка мыши, Сору. Вставим сюда. Правая кнопка мыши и Paste. В кавычках напишем salary of. Далее имя первого сотрудника, staff, далее 0. Первый сотрудник у нас с индексом 0. Плюс. Затем нам нужно использовать сравнение. Для этого возьмем s1. Сначала введем пробел,

далее плюс, s1 и внутри квадратных скобок попробуем произвести сравнение зарплат двух сотрудников. Поэтому напишем staff 0, точка. А теперь используем его метод equals. Затем внутри скобок нам нужно указать другого сотрудника, с которым мы его и сравниваем. Staff, другой сотрудник у нас будет с номером 2. Закроем скобку и прибавим единицу, у нас как мы пополним значение, которое возвращает нам метод equals от (-1) 0 и 1. Один у нас, как и любой массив начинается от 0, поэтому прибавим единицу, и все у нас тогда будет нормально.

Закроем теперь квадратную скобку. Поставим плюс и, перейдя на новую строку, введем пробел, далее salary, of. И введем имя этого второго сотрудника. Для этого staff и внутри квадратных скобок его номер 2. Закроем скобку, точка с запятой. Попробуем теперь скомпилировать и выполнить эту программу. Для этого Tools, Compile Java. Программа скомпилировалась нормально. Если мы сейчас запустим нашу программу, Run Java Application,

то можно увидеть, что у нас получилось. В принципе, получилось немножко не то, что мы ожидали. Вместо имени наших сотрудников, получается вот такая абракадабра. Закроем это консольное окно и рассмотрим в чем тут проблема. Дело в том, когда мы писали здесь имена сотрудников staff, мы не указали, что же мы хотим от него вывести на печать. А хотим мы, конечно же, имя этого сотрудника. Поэтому здесь нужно написать точку и далее метод getName. Тут параметров нет, поэтому просто закрывающая и открывающая скобки, и то же самое относится ко второму нашему сотруднику.

Точка, Get Name и открывающая и закрывающая скобки. Теперь попробуем опять скомпилировать нашу программу. Для этого Tools, Compile Java. Опять все нормально. Запустим приложение, Tools и Run Java Application. И видим, что на этот раз все в принципе достаточно нормально. Зарплата Houg-а меньше, чем зарплата Тейлора, что в принципе можно проверить, визуально посмотрев на зарплату этих сотрудников, на последнее их значение. Закроем это консольное окно и вернемся в наш текстовый редактор.

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

Сделаем, например, таким образом. Выделим вот этот класс Employee, и все строки к нему относящиеся. Вот таким образом. Далее правая кнопка мыши, Сору. Скопируем в буфер обмена и вырежем все, что у нас относится к этому классу. Теперь, у нас внутри нашего файла остался только класс, совпадающий с именем нашего файла. Для второго класса, класса Employee создадим отдельный файл. Для этого щелкнем на кнопку создания нового документа.

Вот он создался, пока абсолютно пустой. Заполним его данными, которые мы скопировали в буфер обмена. Для этого правая кнопка мыши и Paste. Вот все это у нас появилось здесь, и сохраним его теперь под соответствующим именем, под именем Employee. Для этого щелкнем на кнопку сохранения. Появляется стандартное окошко сохранения нашего файла. Сдвинем его чуть-чуть ниже и вот это название Employee перепишем, как имя нашего файла.

Теперь щелкнем на кнопку Сохранить. И теперь, если мы перейдем в наш исходный файл My12.java. Попробуем его скомпилировать и выполнить на этот раз. Для этого Tools, Compile Java. Компиляция прошла успешно. Теперь запустим Tools и Run Java Application.. И можно заметить, что вся программа у нас прошла достаточно нормально. Никаких проблем. Все, что мы видели ранее при выполнении нашей программы, все это мы сейчас и видим на нашем консольном окне. Т.е. разделив, таким образом, наш класс на две составляющие, вернее наш файл на две составляющие по количеству классов, мы ничего не проиграли. Компьютер все абсолютно нормально скомпилировал и выполнил. Закроем консольное окно и отметим, что все это происходит, поскольку при компиляции вот этого исполняемого файла My12, компьютер автоматически, заметив использование класса Employee, ищет файл соответствующий ему, Employee Class. Если он его не находит, то автоматически находит класс Employee Java и далее его компилирует.

В принципе, даже верно более сильное утверждение, что если версия обнаруженного файла Employee Java создано позже, чем существующий файл Employee Class, компилятор Java автоматически перекомпилирует наш файл.

Блок инициализации. Статический блок. Статические поляК оглавлению

Так же, как мы помним, в этом классе есть несколько методов, метод получения имени, getName, метод getSalary, получения зарплаты, метод raiseSalary, повышения зарплаты сотруднику. Сдвинемся скроллингом ниже.

И здесь есть еще два метода, метод задания зарплаты отдельному сотруднику. При этом, как мы помним, здесь проверяется корректность задания этой зарплаты. Является ли эта зарплата меньше, чем 10000, а также сравнивается зарплата двух сотрудников.

Наверху, в начале нашего листинга, у нас находится блок нашего основного класса, в котором находится метод main, который и выполняет нашу программу. И в нем мы заполняем список сотрудников. Создаем три объекта типа Employee с соответствующими именами и их зарплатами, и выводим это все на печать, на наше консольное окно.

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

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

Выберем новую папку. Зададим ей имя My 13. Щелкнем на кнопке Открыть. Зададим имя для нашей программы. Как мы помним, оно должно полностью совпадать с именем класса. Поэтому назовем таким образом, My 13 и щелкнем на кнопке Сохранить.

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

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

Поэтому введем для начала поле id, в котором и будем сохранять это идентификационный номер. Зададим его, как обычно, private. Далее пусть оно будет типа int, целого типа. id, точка с запятой. Вот, после этой строки у нас уже в классе Employee есть поле id.

И, как мы сказали, вот в этом месте его можно было бы добавить в конструктор. Но мы пойдем по другому пути. А именно, зададим еще одну переменную, которая у нас тоже будет private. Далее пусть она будет static, int (целого типа) и обозначим ее nextId.

И для начала проинициализируем ее единицей.

Теперь, что означает эта строка. И что означает здесь слово static, которое мы применим. Как мы видим, в других случаях, это ключевое слово мы не употребляли. Дело в том, что слово static означает, что эта переменная nextId, сосуществует в одном единственном экземпляре, в отличие от всех других полей. В отличие от имени, от зарплаты, которые принадлежат каждому объекту. Сколько объектов, столько и имен, столько и зарплат. А вот это поле nextId, оно одно на все объекты. Оно принадлежит самому классу.

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

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

Ну, первое, что нам нужно сделать, это задать id для нашего объекта. Для начала его зададим, как просто nextId. Точка с запятой. А следующей строкой вот эту переменную nextId увеличим на единицу. nextId++, точка с запятой. Вот теперь, при создании каждого нового объекта, он будет получать свой id, свой идентификационный номер. А вот это поле nextId, которое является общим, еще раз повторяю, общим для всех объектов, оно будет каждый раз при создании объекта увеличиваться на единицу, и именно на него мы и опираемся при создании нового идентификационного номера.

Теперь же, для того чтобы все это было более интересно, зададим в классе Employee метод, при помощи которого мы сможем получить этот id. Для этого, после конструктора зададим еще один метод, который у нас будет, как обычно, public. Далее, тип возвращаемого значения. Конечно же, он должен быть целым - int. И далее getId, получить id. getId, тут параметров нет. Поэтому введем открывающие и закрывающие скобки

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

Попробуем теперь его распечатать вместе с именем и зарплатой. Для этого введем в начале метода println дополнительный текст. Напишем таким образом. id знак равнения, закрывающая кавычка, далее плюс и далее введем само id. е как мы помним, мы этого сотрудника присвоили к объекту е, который является класса Employee. Поэтому просто зададим е точка и далее getId.

Далее введем скобки и плюс. Перед именем name введем еще один пробел для разделителя. Теперь попробуем все это скомпилировать. Для этого развернем меню Tools. Далее Compile Java. Теперь, после успешной компиляции выполним эту программу.

Для этого в меню Tools выберем команду Run Java Application. И вот, мы видим, все, что у нас получилось. Перед именем и зарплатой, впереди появилось новое поле id, и как мы видим, оно у нас задается цифрами 1, 2 и 3. У каждого сотрудника свой уникальный идентификационный номер.

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

Статические методыК оглавлению

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

Как мы помним, мы здесь использовать можем только вот эту статическую переменную nextId. Для этого уберем здесь =1. Такая инициализация нам уже больше не нужна. Здесь мы можем написать таким образом. nextId равняется, и здесь можно написать, конечно же, любое выражение. Но сейчас возьмем, просто nextId, например, равно 10. Точка с запятой. Запустим теперь наше приложение и посмотрим, что у нас получилось. Развернем меню Tools.

Далее Compile Java. Далее вновь меню Tools, Run Java Application. И вот теперь можно увидеть, что наше id начинается с 10. 10, 11 и 12, так как у нас было задано вот в этом статическом методе.

Закроем консольное окно и теперь попробуем создать здесь еще один статический метод, уже с неким именем, при помощи которого мы внутри нашего метода main сможем проинициализировать начальным образом id нашего класса Employee.

Для этого зададим таким образом. public, далее static. И далее имя нашего метода. Пусть это будет, конечно же, setId. В скобках вставим тот параметр, который мы хотим передать. Конечно же, мы хотим передать id, поэтому напишем int. Пусть это будет i. Закроем скобку.

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

Теперь вставим вот эту инициализацию внутрь нашего метода main. Если мы этого не сделаем, то, конечно же, с самого начала у нас инициализация пройдет при помощи числа 10, что у нас подразумевается по умолчанию. Ну, а мы можем это сделать по-другому.

Например, между заданием 0 и нашего первого сотрудника с номерами 0 и 1, вставим такую строчку. Employee, мы можем непосредственно обратиться к этому классу. Поскольку этот метод статический. Он принадлежит именно к классу, а не к объекту. Далее setId,

и далее то число, внутри скобок, которое мы хотим инициализировать наше id. Ну, пусть следующее id наших сотрудников, начинается с числа 100. Закроем скобку. Точка с запятой.

Теперь, прежде чем мы скомпилируем нашу программу, нам нужно указать еще, какой возвращаемый параметр у нас, у метода setId. Конечно же, такого возвращаемого значения у него вообще нет, поэтому нам нужно указать ключевой слово void. Теперь можно уже скомпилировать программу. Для этого развернем меню Tools, Compile Java. Далее опять Tools, Run Java Application.

И как мы видим, как мы и ожидали, у нашего первого сотрудника индекс id равен 10, у следующего 100, и далее следующий номер 101. Закроем теперь консольное окно. Вернемся в наш обычный текстовый редактор.

Если присмотреться к нашей программе, то можно заметить, что у нас есть еще один статический метод. А именно, вот этот стандартный статический метод main, который, как мы видим, точно так же, как и вот этот статический метод выполняется даже без создания самого объекта. Как мы знаем, интерпретатор языка Java, как раз вот этот метод main и вызывает при начале своей работы. Но при этом, никакого объекта пока еще даже не существует. Прямо выполняется вот этот метод main.

В принципе, каждый класс может иметь свой метод main. Например, в классе Employee, который у нас есть, мы можем ввести здесь метод main и при помощи него, вставив в него какие-либо тестирующие этот класс строки, можно отдельно запускать вот этот класс Employee, его метод main и тестировать отдельно этот класс.

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

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

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

Посмотрим, что у нас получилось. Развернем меню Tools. Далее Compile Java. Вот компиляция прошла успешно. Теперь в меню Tools выберем команду Run Java Application. И, как мы видим, у нас в принципе, все строчки нашей программы, вывелись абсолютно правильно. Вот наши сотрудники первый, второй и третий.

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

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

Теперь, если мы развернем меню Tools и выберем команду Compile Java. Теперь опять Tools и Run Java Application, то можно увидеть, что у нас получилось. А получилось у нас в принципе, по крайней мере, чисто внешне, совершенно обычное, нормальное выполнение нашей программы. Вот все наши сотрудники. Все, что у нас задавалось в нашей программе выполнено и код выхода совершенно нормальный. Никакой ошибки нам компьютер не выдал. Закроем наше консольное окно

и отметим, что вот при таком, конечно же, методе работы нашего приложения, мы, зато теряем возможность, использовать те передаваемые параметры, которые у нас могут быть переданы нашей программой при помощи командной строки. Это уже в таком методе написания программы, конечно же, не учитывается. Вернем теперь все к прежнему виду. Уберем вот этот комментарий. Уберем слово static и вот эту строчку System.exit.

Конструкторы. Перегрузка конструкторовК оглавлению

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

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

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

Ну, попробуем теперь перегрузить наш конструктор Employee, воспользовавшись при этом разным набором передаваемых параметров. Напишем public. Конечно, у нас все конструкторы должны быть public, далее Employee. Далее откроем скобку

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

Ну, первое, что мы должны сделать, это, конечно же, написать name равняется n, точка с запятой. И далее зарплата Salary, знак равнения. И можем задать какое-либо значение по умолчанию, которое в этом случае будет присваиваться этому объекту. Этому сотруднику. Ну, пусть, если мы зарплату не указываем, то зарплата у нас будет 10000, то минимальное значение, которое у нас есть для сотрудника, которое фигурирует и вот в этом месте, где мы задаем зарплату.

Зададим еще один конструктор. Напишем public. Далее Employee и далее внутри скобок, зададим параметры. В качестве параметра без имени зададим только один параметр "зарплата", double. Далее его значение s. Закроем скобку. И далее фигурные скобки.

Ну, а теперь нам уже нужно каким-то образом сконструировать, имя этого сотрудника. Проще всего, вспомним, что у нас каждому сотруднику присваивается его уникальное id, опереться на него. Поэтому напишем таким образом, name знак равнения. Далее кавычки. Employee, далее вот такой значок. Закроем кавычки. Плюс. И прибавим к имени Employee еще и его номер id, nextId. Точка с запятой.

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

Для этого вместо отдельного задания имени и зарплаты вот в этом блоке конструктора, зададим вызов именно вот этого первого метода. Для этого переделаем здесь вот эти две строчки и для вызова конструктора, напишем ключевое слово this. Далее откроем скобку и внутри скобок, вот эти два параметра. Первый параметр, вот это имя, которое мы сконструировали таким образом, далее запятая. И зарплата s. Закроем скобку. Точка с запятой.

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

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

И, конечно же, исходя из общности, как мы делали ранее, понятно, что мы должны сделать. Скопируем вот эту строчку, для того чтобы много не писать. Выделим ее. Щелкнем правой кнопкой мыши, Сору. Далее вставим сюда. Правая кнопка мыши и Paste.

И теперь вместо зарплаты s, которая у нас здесь задается. Ее, конечно же, взять неоткуда, просто напишем прямо число 10000, которое у нас является минимальной зарплатой. Т.е. если мы не указываем ни одного параметра, при создании нового сотрудника, нового объекта, то сразу создается новый сотрудник с именем Employee и номер его id, и далее ему присваивается минимальная зарплата 10000.

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

Теперь щелкнем на клавише Enter. Вставим содержимое буфера обмена. Для этого опять щелкнем правой кнопкой мыши и Paste. Вместо 2 здесь напишем 3. И далее проинициализируем его только одним именем. Для этого введем кавычки и далее напишем имя нашего нового сотрудника. Ну, пусть у него фамилия будет Mitchel.

Введем какие-либо инициалы. Пусть инициалы будут A далее точка R. Далее кавычки и закроем скобку. Это уже вполне достаточно. Зарплата этому сотруднику присвоится автоматически. Опять вставим. В буфере обмена у нас уже содержится вот эта строчка. Поэтому прямо правая кнопка мыши. Далее Paste.

Вместо 2 пишем 4. Далее укажем только зарплату без указания фамилии. Пусть, например, будет 17000. Закроем скобку. Точка с запятой.

Введем еще одного сотрудника. Правая кнопка мыши, Paste. Это у нас будет сотрудник с номером 5. Опять введем его при помощи ввода зарплаты. Ну, пусть у него зарплата будет 14000. Закроем скобку. Точка с запятой. И введем еще одного, последнего сотрудника, Paste. Его номер будет 6, и его зададим по умолчанию. Не задавая ни зарплаты, ни фамилии, ни имени.

В принципе, для общности введем еще одного сотрудника. Paste. Пусть это будет 7-ой сотрудник, у которого опять сами ничего не задаем. Теперь, для того чтобы у нас не было ошибки, мы должны определение нашего массива увеличить с 3 до того количества, которое у нас здесь есть.

У нас есть уже целых 8 сотрудников, поэтому здесь напишем вместо 3, 8. Скомпилируем теперь нашу программу и посмотрим, что у нас в результате всего этого получилось. Для этого развернем меню Tools. Далее Compile Java. Далее Run Java Application.

И вот можно увидеть, что у нас в результате получилось. Если первые три сотрудника нам уже так сказать, знакомы, то следующие сотрудники у нас новые. Это сотрудник по имени Mitchel, у него зарплата 10000, которая автоматически посчиталась во время создания конструктора, поскольку мы здесь ничего ему не задавали в виде зарплаты. Также следующие сотрудники, у которых мы имена не задавали, поэтому они получили вот такие безликие имена с номерами. Первые два из которых у нас задавались вместе с зарплатой, а последние два, просто-напросто, с минимальной вот такой зарплатой. Закроем теперь наше консольное окно и вернемся в наш текстовый редактор.

Конструкторы. Перегрузка методовК оглавлению

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

Попробуем это сделать. Ну, для того чтобы много не писать, просто-напросто скопируем вот эти строчки. Щелкнем правой кнопкой мыши и Сору. Теперь вставим их вот сюда. Встанем здесь. Правая кнопка мыши и Paste.

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

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

Теперь нам нужно переделать сам метод. Вместо other.salary, везде нам нужно использовать действительное число d, поэтому выделим вот этот кусочек текста, удалим его, напишем здесь вместо него букву d и то же самое сделаем вот в этом месте. Удалим other.salary и введем переменную d. Вот теперь у нас есть два метода, которые сравнивают между собой зарплаты.

Если в первом случае, это сравнение зарплат одного сотрудника с зарплатой другого сотрудника, то во втором случае, это метод, который сравнивает зарплату сотрудника с неким параметром.

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

Для этого впишем опять вот такую же конструкцию. Проще всего, конечно же, ее скопировать. Для этого выделим вот эти строчки. Щелкнем правой кнопкой мыши, Сору. Вставим сюда. Далее правая кнопка мыши и Paste. И теперь здесь немножко переделаем. Введем оператор if.

Напишем if. Далее e точка equals. Откроем скобку. Далее укажем то число, с которым мы должны сравнивать. Ну, мы хотели взять 15000, и если эта величина больше, чем 0, в этом случае, будем выводить на печать вот такой текст. Введем тут тоже скобку.

Между этими двумя выводами напишем еще один метод println, при помощи которого отделим один список сотрудников от другого. Для этого выделим, например, вот эту строчку. Далее щелкнем правой кнопкой мыши и Сору.

Вставим ее вот в это место. Встанем сюда. Правая кнопка мыши и Paste. И вместо того, что тут написано, введем просто-напросто такую вот черту. Теперь скомпилируем нашу программу.

Для этого развернем меню Tools, Compile Java. Теперь выберем команду Run Java Application. И вот можно видеть наверху список всех сотрудников, а внизу список тех сотрудников, у которых зарплата больше, чем 15000. Закроем теперь наше консольное окно. Щелкнем на вот этом крестике. И вернемся в наш обычный текстовый редактор.

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

Но, для этого нам придется организовать цикл, причем цикл двойной. И чтобы это сделать, скопируем вот этот цикл for. Но до этого, скопируем сначала вот эту линию, для того чтобы отделить то, что мы сейчас делаем, от того, что делали ранее. Для этого выделим ее. Далее правая кнопка мыши, Сору. Встанем сюда.

Правая кнопка мыши и Paste. И теперь уже начнем копировать вот этот цикл. Выделим его опять. Вот всю строчку выделили. Теперь правая кнопка мыши, Сору. Встанем сюда. Правая кнопка мыши, Paste. Вставим еще раз. Правая кнопка и Paste. Поскольку нам придется делать двойной цикл. Щелкнем на клавише Enter.

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

Теперь напишем оператор if, далее откроем скобку. И теперь сравним два значения при помощи нашего метода equals. Поэтому напишем таким образом, if, staff с параметром i. Точка, equals. Далее скобка.

А теперь нам нужно указать другого сотрудника. Поэтому напишем staff. На этот раз это будет сотрудник с номером j. Закроем скобку. И если эта величина меньше 0, закрыть скобку, тогда предпримем какие-то действия. Напишем фигурные скобки, внутри которых проведем обмен этих двух сотрудников местами. Если вот это соотношение меньше 0.

Зададим поэтому новую переменную типа Employee. Пусть эта переменная называется, как и было раньше e. Ему присвоим значение staff, сотрудника с номером i.

Далее сотруднику с номером i, присвоим значение сотрудника с номером j. А на месте сотрудника с номером j, вставим сотрудника с номером i, которого мы сохранили в переменной e. Поэтому напишем знак равнения e, точка с запятой.

А теперь, после того, как мы все это сделали, нам остается только опять распечатать список всех наших сотрудников. Для этого выделим вот эти строчку, поскольку именно они распечатывали список всех сотрудников. Вот эта распечатка нам не подходит, поскольку здесь распечатывались только сотрудники, у которых зарплата определяется по каким-то критерием, больше 15000. Но, это нам не подходит, поэтому выделим вот эти строчки. Они распечатывают весь список. Теперь щелкнем правой кнопкой мыши, Сору.

Далее встанем сюда. Правая кнопка мыши и Paste. И теперь попробуем скомпилировать и запустить наше приложение. Для этого развернем меню Tools, Compile Java. Теперь, после успешной компиляции запустим само приложение. Для этого активизируем команду Run Java Application.

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

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

ПакетыК оглавлению

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

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

Попробуем вот эту нашу программу записать, таким образом, т.е. ее класс Employee, который у нас определен ниже, вот этот, сохранить в виде пакета, сохраненном в некой иерархической структуре. Представим себе случай, когда имя нашей компании в Интернете такое: mycompany.net

Этот класс Employee сохраним в неком файле. Этот файл будет находиться в иерархическом дереве каталогов, которое построено по тому принципу, о котором мы говорили. Для этого выделим вот этот весь класс. Далее щелкнем на правую кнопку мыши и далее на Cut. Вот после того, как все это вырезали, создадим новый файл. Щелкнем на кнопку New document.

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

Теперь введем в нем новый каталог. Для этого щелкнем на кнопку create new folder, создание нового каталога. И этот каталог назовем каталогом com. Щелкнем на кнопку Open. Открыть. Далее создадим еще один каталог, который назовем mycompany. Выделим этот каталог, чтобы зафиксировать имя. И щелкнем на кнопку Open.

И далее введем уже название нашего класса Employee. Щелкнем теперь на кнопку Save, сохранить.

Перейдем теперь на основной наш файл нашей программы. Щелкнем на M13. Сдвинемся при помощи ползунка выше и попробуем теперь скомпилировать. Для этого tools, compile Java. И далее tools, Run Java Application.

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

Ну, для чистоты эксперимента, удалим его. Например, щелкнем на кнопку Open. Далее переключимся на Все файлы. Вот появляется этот класс Employee.class, который на самом деле является классом, скомпилированным нами ранее. Поэтому щелкнем на правую кнопку мыши и Delete, сотрем его.

И появляется стандартный вопрос, Правда ли мы его хотим удалить. Щелкнем на кнопку Yes. Вот теперь этого класса нет. Закроем это окно. Щелкнем на вот этом крестике. Здесь нам больше делать не надо ничего. И попробуем снова скомпилировать и запустить нашу программу. Tools, Compile Java.

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

Для этого нам, наверху нашего приложения, в самом начале, надо указать ключевое слово import. И далее путь к нашему классу. Как мы помним, путь, начиная с нашего текущего каталога, выглядит таким образом: Com, далее точка. Далее mycompany. Далее точка. Далее напишем звездочка. Точка с запятой.

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

Но, если мы в таком виде попробуем компилировать нашу программу, щелкнем на кнопку Tools, и далее Compile Java, что все равно мы получаем ошибку. Компьютер нам выдает, что в нашем файле Employee.java который в принципе он находит, этого класса нет. И указывает класс вместе с путем.

Для того чтобы компьютер все правильно воспринимал, для этого нам нужно перейти в сам класс Employee.java и в его самом начале написать ключевое слово package. Для того чтобы подчеркнуть, что этот класс у нас находится в соответствующем пакете. И далее путь к этому пакету, который, как мы помним, является com далее точка и далее mycompany. Далее точка с запятой.

Теперь перейдем обратно на нашу программу и попробуем скомпилировать на этот раз. Для этого Tools, Compile Java. Но, в принципе, мы опять получили ошибку, но дело в том, что мы сам файл Employee.java не сохранили на жестком диске. Поэтому при обращении к нему, компьютер использует так сказать его старую версию. Поэтому переключимся туда.

Щелкнем на значке сохранения. Теперь обратно. Далее Tools, Compile Java. Мы опять получили довольно большое количество ошибок. И если посмотреть в чем тут дело, можно увидеть какую ошибку нам выдал компилятор.

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

Теперь переключимся обратно на наш файл программы. Скомпилируем. Для этого Tools, Compile Java. И на этот раз у нас все получилось совершенно гладко. Поэтому Tools, Ran Java Application, и мы, наконец, получили все то же самое, что мы видели в самом начале нашей работы.

Т.е. все наши классы и наша программа, работают корректно. Закроем. И мы вернулись в наш обычный текстовый редактор. Пример, который мы сейчас только что рассматривали, каталог пакета является подкаталогом нашего каталога программы. Однако такое расположение далеко не всегда является удобным, особенно, если вот этот класс Employee мы хотим применить в нескольких наших программах.

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

Установка путей к классам зависит уже от среды, в которой компилируется программа и от операционной среды. В среде Windows нужно указать это все в переменной окружения класса put.

Автоматическое создание документацииК оглавлению

Чтобы познакомиться с этим поближе, рассмотрим программу, которую мы создали ранее, которая создает список наших сотрудников и состоит из двух классов. Из основного нашего класса, в котором находится у нас основной метод main, который и выполняется нашей Java интерпретатором. И находится класс Employee, который и описывает каждого нашего сотрудника.

Сохраним сначала этот наш класс. Переименуем его в My14. Далее теперь щелкнем на кнопку сохранения. Введем папку My14, в которой и будем сохранять наши файлы. Щелкнем на кнопку Open.

Введем имя для нашего файла My14. Как мы помним, имя файла должно совпадать с названием нашего класса, и щелкнем на кнопку Save, сохранить. Теперь же, даже не написав еще ни одного комментария, попробуем запустить программу Java.doc. Для этого настроим наш текстовый редактор, для того чтобы мы могли его запустить. Это можно сделать проще всего при помощи пункта меню Configure, конфигурация и далее Preferences.

Далее, в список исполняемых модулей, который у нас здесь есть, как мы видим, их здесь три: Compile Java, Run Java Application и Run Java Applet. Добавим еще один, который будет запускать наш Java doc. Для этого щелкнем на кнопку Add и далее Add Program, добавить программу.

Вот, мы попали в стандартное окно выбора файла, в котором мы должны найти нашу программу Java.doc. Для этого теперь щелкнем на Мой компьютер и далее найдем диск D, на котором нас инсталлирован пакет Java. Далее найдем ту папку, в которой все это у нас находится. Вот в данном случае у нас находится в папке Java2 и далее номер версии. Щелкнем на ней дважды.

И далее нам нужна директория bin, в котором и находятся все исполняемые файлы, в котором найдем программу Java.doc. Вот она. Щелкнем теперь на кнопку Open. И, как мы видим, эта программа у нас добавилась в список исполняемых модулей. Щелкнем на кнопку Apply. Теперь, если мы откроем плюсом, то можно увидеть, что Java doc добавилось у нас вот в это место. Выберем его и можно увидеть, какими параметрами мы выполняем эту программу.

Как мы видим, текстовым параметром мы передаем текущий файл. В качестве папки инициализации, текущую директорию. Согласимся со всеми этими установками и щелкнем на кнопку ОК.

Запустим теперь программу. Для этого щелкнем на пункте Tools. Далее Java.doc. Вот можно увидеть результат выполнения этой программы Java.doc, как мы видим, компьютер сгенерировал достаточно много html файлов.

Для того чтобы посмотреть, какие файлы он сгенерировал, щелкнем на пункте Tools и далее на пункте Explorer. Открывается наш обычный Explorer, в котором мы можем увидеть все файлы нашей текущей директории. И как мы видим, здесь находятся очень много html файлов, которые создал наш пакет Java и которые при помощи перекрестных ссылок, создал достаточно цельную систему помощи по нашим классам.

Теперь же, как всегда, когда мы находимся в папке с html файлами, откроем первый файл с именем Индекс, в котором обычно и находится начальная информация по всем html файлам. Щелкнем на нем дважды, и открывается вот такой файл помощи, html файл, в котором описываются оба наших класса, класс Employee и класс My 14.

Как мы видим, в самом начале у нас открылся класс Employee, и в нем, если мы сдвинемся при помощи ползунка, можно увидеть все его методы, которые у нас подряд выписаны. И все его поля. Ну, конечно, те из них, которые помечены, как public, доступные.

То же самое касается класса My14. Если мы щелкнем на нем, то можно увидеть полную информацию по этому классу, включая, конструктор, включая метод main, который выполняет нашу программу и т.д. Наверху можно увидеть ряд ссылок, при помощи которых мы можем видеть разные представления нашего документа. Если мы щелкнем на кнопку Индекс, то можно увидеть список всех наших классов, методов и т.д., которые расположены по алфавиту.

Ну, на букву Е у нас находится Employee и все, что начинается с него. Вот, на букву G у нас находятся методы Get ID, Get name и т.д. Ну, и т.д. Все это рассортировано по алфавиту. Если мы щелкнем на ссылку Tree, то можно увидеть иерархию наших классов.

Как мы видим, по иерархии у нас два класса, Employee и My14, каждый из которых является наследниками класса Object. Если мы щелкнем на ссылку Help, то можно увидеть, как организован этот документ. И полное его описание.

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

Перейдем на наш файл программы. Щелкнем здесь. Вставим теперь комментарии, которые будут относиться непосредственно к нашему классу. И первый комментарий будет относиться к классу My14, в котором и находит исполняемый модуль main. Комментарии к классу, должны помещаться до первого оператора Import. Ну, и конечно, непосредственно перед определением класса, перед вот этим оператором.

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

Ну, напишем, например, таким образом. Просто напишем: It is class My14. И в качестве следующей строки напишем: There is method main.

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

Ну, пусть, например, будет автором данного класса Flaming. Напишем Flaming, далее его инициалы. Пусть, например, будет А, далее R. Введем еще одного автора. Для этого тот же самый значок. Далее author.

И впишем второго соавтора, который по нашим предположениям есть у этой программы. Ну и другим автором пусть будет Morris, с инициалами А и J. Еще одним очень интересным аспектом, который может заинтересовать потенциального потребителя нашего класса, это номер версии нашего пакета. Поэтому напишем опять дескриптор и далее version.

И далее номер версии. Введем, например, Edition 2 точка 1. Поставим еще один комментарий, ну на этот раз, нашему следующему классу, классу Employee. Для этого сдвинемся при помощи ползунка ниже. И вот в этом месте, до начала нашего класса, введем косую черту, далее звездочку, еще одну звезду. Далее звездочка и косая черта, закрытие нашего автоматического комментария. И внутри него теперь напишем какой-либо текст.

Как мы видим, именно вот этот комментарий попадем в наш файл помощи. А, например, вот этот комментарий, который у нас находится чуть выше и который просто-напросто в нашем случае является не комментарием, а разделителем, он в никакую помощь не попадет. А здесь напишем таким образом. Не долго думая, опять напишем: It is class employee.

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

Вставка дополнительных комментариев в документациюК оглавлению

И далее напишем передаваемые переменные, которые есть в этом конструкторе: это имя и зарплата. Для этого введем вот такой значок дескриптора и далее param ключевой слово, которое будет означать, что за ним будет идти название переменной. Далее N, далее тот текст, который ему соответствует. Ну, напишем просто-напросто Name.

Еще один параметр, ключевое слово param, далее переменная S и его описание salary. Сдвинемся теперь при помощи ползунка ниже и напишем описание, ну, например, вот этому методу getName.

Введем опять значок начала комментария, косая черта, две звездочки, затем звездочка и косая черта, закрытие комментария и между ними напишем просто-напросто: It is method getName. И далее возвращаемый параметр.

Для этого введем вот такой значок дескриптора и далее return. И далее, что мы хотим написать по этому поводу. Напишем просто-напросто, method return Name of staff.

Попробуем теперь снова перекомпилировать нашу помощь. Для этого запустим Tools и далее Java.doc. Щелкнем на нем. Вот мы получили листик того, как это программа исполнила компиляцию нашей помощи. И теперь попробуем посмотреть, что у нас получилось. Для этого щелкнем на Tools и далее Employee. И запустим опять Индекс. Щелкнем на нем дважды.

Вот запустилась система помощи и здесь мы должны увидеть те комментарии, которые мы вставили. Вот в частности к нашему классу Employee мы вставили строку It is class Employee. Далее, если мы сдвинемся при помощи ползунка ниже, то можно увидеть у конструктора Employee внизу надписи it is constructor, которая опять-таки строка, которую мы ввели. Такую же строку можно было ввести в каждом из других перегруженных конструкторов, которые есть в нашем классе.

Далее сдвинемся при помощи ползунка вниз и можно увидеть тот комментарий, который мы написали нашему методу Gen Name. И далее можно подробно рассматривать каждый из этих методов и конструкторов. Например, вот этот метод Get Name, если мы на нем щелкнем, то мы сразу попадаем в это место и можно увидеть полное описание этого метода.

Как мы видим, тут находится и та надпись, которую мы для нее ввели It is method getName, а также то, что мы ввели для возвращаемого значения. Что оно возвращает нам имя сотрудника. Если же мы вернемся назад чуть-чуть и щелкнем на конструкторе Employee, то можно увидеть наряду с теми комментариями, которые мы для нее ввели, описание параметров, которые есть в этом конструкторе. Переменная N, это у нас имя, а переменная S- это у нас зарплата нашего сотрудника. А если мы переключимся на класс My14,

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

Перейдем опять на наш файл My 14, сдвинемся при помощи ползунка вверх. Отметим, что наряду просто с комментариями, которые мы написали нашим классам, методам, полям и т.д., мы можем ввести и какие-либо разного рода теги, которые есть в html файлах, для придания нашей помощи более красивого вида.

Но, например, попробуем сделать так в нашем описании нашего класса Employee, чтобы отдельные его слова как-либо выделялись. Но, например, название класса Employee выделим курсивов. Для этого перед ним, и после него вставим соответствующие теги. Ну, вот больше- меньше, и далее напишем em, что будет означать началом курсива.

Далее опять после слова Employee опять это больше - меньше тег и далее косая черта и em, что будет означать конец нашего курсива. А вот слово class, выделим жирным шрифтом. Для этого опять вставим тег перед ним. И напишем там слово strong. А после слова class, вставим тоже тег больше - меньше и напишем косая черта и Strong. Запустим теперь нашу программу Java.doc. Для этого Tools. Далее Java.doc. Щелкнем на нем.

Все у нас прошло успешно, А теперь щелкнем на Employee, и запустим опять наш файл Индекс. И можно увидеть теперь, как выглядит комментарии к нашему классу Employee. Как мы видим, у нас слово class выделился жирным шрифтом, а Employee, вот таким курсивом. Закроем теперь этот Explorer.

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

Далее Preferences и там, где у нас находится строчка Параметр с параметры, добавим опции: author и еще одна опция, это version. Как мы видим, перед каждым из этих параметров, мы поставили значок минус. Щелкнем теперь на кнопку ОК.

Опять запустим эту программу. Для этого Tools, Java.doc. Далее теперь запустим Explorer. Для этого Tools, Explorer. Запустим опять Индекс. Щелкнем на нем дважды. Переключимся на класс My14.

И теперь уже в описании класса, наряду с тем текстом, который мы ввели, что это наш класс My14, и здесь есть метод main, тут же появилось сведение о версии и об авторах. Как видим, версия у нас addition2.1. Но и ниже находятся два автора. Закроем теперь этот Explorer и вернемся в наш обычный текстовый редактор.

Надо еще отметить одно обстоятельство. А именно то, что комментариями довольно-таки щедро заполнены исходные файлы, которые поставляются вместе со стандартной поставкой Java. А если их извлечь при помощи вот этой утилиты Java doc, то получится довольно-таки хорошая помощь и подспорье для нашей работы.

Перейдя в режим командной строки, при помощи вот этой оболочки far, можно добраться до директории, в которой у нас инсталлированы все файлы Java. И в нем можно найти вот такой файл sors.zip, распаковав который, и можно получить доступ ко всем исходникам Java.

Для этого щелкнем на нем дважды. Далее попробуем создать какую-либо помощь по какому-либо из разделов нашей программы Java. Для этого зайдем, например, в директорию Java. Далее зайдем, например, в директорию Util и попробуем открыть и создать помощь по вот этим файлам.

Для этого с правой стороны создадим какую-либо директорию. Например, назовем ее просто-напросто Help. Enter.

Далее скопируем теперь вот эту всю папку Util туда. Для этого, конечно же, надо щелкнуть на клавише F5. Далее Enter. Вот теперь с правой стороны у нас появилась папка Util. Она уже не заархивированная, а так сказать живая. Теперь попробуем воспользоваться нашей утилитой Java doc. Для этого перейдем на правую сторону и войдем в папку Util. Для этого щелкнем на ней дважды.

И далее напишем командную строку, при помощи которой мы хотим создать нашу помощь. Конечно, нам сначала нужно написать Java.doc. Это и является той программой, которая создает нам помощь. Далее (-D). Это у нас ключ, которым мы указываем нашей программе Java.doc, что все наши файлы помощи нужно поместить в отдельную директорию, название которой пусть, например, будет опять Help.

И далее нам нужно указать, какие файлы нам нужно поместить в наш файл помощи. Для этого напишем просто-напросто звездочку. Далее точка и расширение Java, которое есть у всех наших файлов Java. Теперь щелкнем на клавише Enter. И вот можно увидеть, что у нас появилась еще одна папка Help.

Щелкнем на ней дважды. И запустим индекс html, с которого обычно начинаются все експлоровские файлы. Щелкнем на нем дважды. И можно увидеть тот файл, который мы создавали. А именно, достаточно подробную помощь в формате html по всем классам, которые находятся в нашей директории Util.

Слева находятся все наши классы, а справа, их описание. Ну, например, если посмотрим класс Дату, то с правой стороны можно увидеть описание этого класса. Можно посмотреть, какие у него есть конструкторы, методы и т.д. Итак, по любому другому классу. Например, класс Календарь. У него так сказать свое описание. Ну, и т.д.

Создание подкласса. Вызов родителяК оглавлению

Вот это все, что делает класс Employee. И далее в нашем основном классе My15, реализован класс main, который выполняется нашим интерпретатором Java и в нем создан массив сотрудников staff. Затем каждому из этих элементов, каждому из сотрудников присвоено соответствующее имя и зарплата, а также после всего этого, после инициализации, весь список наших сотрудников выводится на печать вместе с именами и их зарплатами.

Вот это то, что делает программа, которая написана и которая находится перед нами. Сохраним ее на нашем жестком диске. Для этого щелкнем на кнопку сохранения. Далее создадим новую папку. Щелкнем на точке создания новой папки. Зададим ему имя по имени нашей программы, My15. Далее щелкнем на кнопку Open. Зададим имя для нашего приложения. Как мы помним, оно должно совпадать с именем нашего класса,

поэтому напишем My15. И щелкнем на кнопку Save. И вот мы опять попали в наш обычный текстовый редактор. Теперь обратим внимание на класс Employee, на класс сотрудников, который у нас есть.

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

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

Теперь приступим к созданию класса менеджеров. Что для этого надо? Надо написать ключевое слово Class, с которого мы и начнем нашу работу. Для этого, в конце нашего приложения, в конце нашего листинга, начнем писать наш класс. Class, далее название этого класса, Manager. Если раньше мы на этом и обрывали определение класса и далее переходили к описанию полей и методов внутри фигурных скобок, то теперь положение несколько иное, поскольку мы хотим класс менеджеров сделать наследником класса Employee, нам нужно это явно указать.

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

Если использовать терминологию, то класс Employee у нас называется обычно или суперклассом или базовым классом, или родительским. А вновь создаваемый класс, вот этот класс менеджеров, обычно называется подклассом, производным классом или дочерним классом. Теперь введем те обещанные дополнительные поля, которыми класс менеджеров и будет отличаться от класса Employee. И это, конечно же, специальное поле Bonus, премия, которая, как мы считаем, выплачивается менеджерам, в отличие от всех остальных сотрудников.

И поэтому напишем таким образом. Private, чтобы это поле было закрыто для доступа из вне программы. Далее тип нашей переменной. Конечно же, это должно быть double, действительное число. И введем название для нашего поля. Пусть это будет bonus,

точка с запятой. И теперь, раз у нас в этом классе Manager есть поле bonus, надо предусмотреть какой-либо метод, при помощи которого мы можем задавать его величину. Поскольку, пользуясь методами и полями, которые есть в классе Employee, это, конечно же, сделать невозможно. Поле bonus является, эксклюзивным полем именно для класса Manager.

Поэтому напишем новый метод setBonus. Конечно же, создадим его public, чтобы можно было бы использовать. Напишем ключевое слово void, поскольку никакого возвращаемого значения у этого метода не будет. И напишем setBonus.

Далее, внутри скобок, укажем действительную величину, которая будет определять величину этого bonus-a. Поэтому она должна быть double, и далее пусть это будет файл с именем В. И далее, внутри фигурных скобок нам нужно написать, как этот метод работает. А именно, наша переменная bonus присваивает значение, находящееся в передаваемом параметре В.

Далее точка с запятой. Вот и все, в принципе, что делает этот метод. Теперь для обеспечения полной работоспособности нашего класса Manager, изменим тот конструктор, при помощи которого у нас создается новый экземпляр этого класса. Как мы помним, в классе Employee конструктор есть. Вот он. Но он создан с учетом только обычных сотрудников, а не менеджеров. И поэтому нам придется немножко переделать этот конструктор. Напишем теперь таким образом.

Сначала будет, конечно же, ключевое слово public, далее имя этого метода, имя этого конструктора. Как мы помним, оно должно совпадать с именем нашего класса. Поэтому напишем слово Manager. Далее, внутри скобок, мы должны указать его параметры. Возьмем те же самые параметры, которые есть в конструкторе Employee. Поэтому просто скопируем вот этот кусочек текста. Далее правая кнопка мыши, после того, как мы все выделили, Сору. Теперь вставим сюда. Правая кнопка мыши и Paste.

И после этого список формальных параметров у нас уже определен. Далее, внутри фигурных скобок напишем таким образом. Во-первых, первое, что нам нужно сделать, это зарегистрировать имя и зарплату нашего сотрудника, который в данном случае является менеджером. Причем надо заметить, что поскольку у порождающего класса, класса наследника нет прямого доступа к полям своего родителя, к полю name и к полю salary, поэтому придется нам написать таким образом. А именно, вызвать конструктор, который есть у класса Employee, у родительского класса.

Напишем для этого слово super. Именно это слово super и является вызовом родителя для класса Manager. Далее скобка, внутри которой нам нужно указать имя n и зарплату s. Поэтому напишем таким образом. N, запятая, s, закроем скобку, точка с запятой. И теперь нам надо позаботиться о новом поле, которое у нас есть в классе Manager. Это поле bonus.

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

ЗамещениеК оглавлению

И попробуем сейчас, сделать так, чтобы сотрудник с индексом 1, вот этот сотрудник, стал менеджером. Для этого щелкнем здесь на Enter и далее введем переменную этого класса, класса Manager. Напишем Manager, уберем лишнюю букву "a", и далее выберем имя переменной для нашего сотрудника менеджера. Пусть это будет m,

далее знак равенства, как обычно new, опять Manager. Теперь нам нужно вызвать его конструктор. Далее, внутри скобок, мы должны написать его фамилию и зарплату, которую в принципе можем скопировать вот из этого места. Пусть это будет Адамс, с зарплатой 60 000. После того, как выделили, правая кнопка мыши, Сору.

Далее вставим сюда. Правая кнопка мыши и Paste. И теперь напишем таким образом. Во-первых, зададим тот bonus, который должен прибавлять каждый раз этому менеджеру, поскольку при начальной инициализации в нашем конструкторе, bonus присваивает себе значение 0. Но, для задания bonusa у нас есть в классе Manager специальный метод setBonus, который мы сейчас и вызовем. Поэтому напишем таким образом, m, точка, далее setBonus.

И внутри скобок укажем ту величину, которая должна ему добавляться. Пусть это будет, например, 10 000. Закроем скобку, точка с запятой. Теперь, сотруднику с индексом 1, как раз и нужно присвоить те характеристики, которые у нас есть в объекте m.

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

Теперь, что самое интересное, в нашем массиве есть объекты двух типов. Это уже не однородный массив, а некая смесь, частью которой являются объекты класса Employee, а частью, в частности, вот этот текст с номером 1, является объектом класса Manager.

И отметим также, что впрямую создать этот объект, без помощи вот этой промежуточной буферной переменной m было нельзя. Поскольку вызвать метод setBonus нам тогда было бы невозможно. Но, если представить себе вот такую конструкцию, вместо Employee здесь напишем new Manager,

уберем знак комментария, поставим его перед предыдущей строкой. В принципе, вот такая постановка вопроса правомерна. Если мы сейчас скомпилируем программу и выполним, она у нас пройдет совершенно нормально, но, правда, следующую строку, а именно если взять staff с индексом 1, задать в bonus, setBonus,

и далее взять те же самые 10 000, вот это уже неправильно. Это уже ошибка. Если мы сейчас попробуем скомпилировать, Tools, Compile Java, то, можно увидеть, что у нас произошло. А именно, у класса Employee, представителем которого является наш сотрудник, staff с индексом 1, метода setBonus, конечно же, нет.

Поэтому возвратимся к нашей программе и зададим так, как у нас и было правильно. А именно, здесь уберем комментарии, а к следующим двум строкам комментарии добавим, написав, что вот эта строчка является ошибкой, error, для того чтобы мы так в дальнейшем не писали. Теперь же скомпилируем нашу программу в наш класс. Для этого Tools, далее Compile Java. Как мы видим, на этот раз у нас все прошло абсолютно идеально. Запустим нашу программу, Tools и Run Java Application. И, как мы видим, на этот раз у нас уже все прошло достаточно гладко.

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

А теперь попробуем описать метод getSalary для случая менеджера, для того чтобы он выдавал нам не просто зарплату, а зарплату вместе с bonus-ом, сумму этих двух составляющих. Для этого сдвинемся скроллингом вниз, туда, где у нас находится класс Manager, и здесь введем метод getSalary, который будет являться методом, замещающим метод своего суперкласса, своего родительского класса. Поэтому напишем таким образом. Public,

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

Первое, что приходит в голову, это написать что-то такого типа, return, и в качестве возвращаемого значения, взять сумму salary, основной зарплаты, и bonusa, точка с запятой. Но, такой простой метод в наших классах не работает. Если мы сейчас попробуем скомпилировать, Tools, Compile Java, то у нас возникает ошибка.

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

Поэтому придется воспользоваться другим способом. Что теперь делать? Придется написать что-либо другое. Сотрем эту строчку, и попробуем задать новую переменную типа double. Пусть она будет у нас переменная s, знак равенства, и попробуем вызвать getSalary из нашего класса Employee.

Для этого напишем таким образом, getSalary, для того чтобы получить исходную зарплату нашего сотрудника, скобки, точка с запятой. Далее как раз и напишем возвращаемое значение, return и далее гораздо проще s+bonus.

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

точка. И вот таким образом наша зарплата будет выглядеть правильно. Запустим теперь наше приложение и посмотрим, что у нас получилось. Для этого Tools, Compile Java, далее Tools и Run Java Application. На этот раз у нас все абсолютно правильно получилось. Зарплата сотрудника Адамса, который является менеджером, вместо 60 000, у нас стало 70 000. К его зарплате прибавился bonus в количестве 10 000.

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

Если с методом, который называет имя нашего сотрудника, все понятно, поскольку этот метод единственный и определен в классе Employee, а в классе Manager он не переопределен, то с методом getSalary уже не все так очевидно. Поскольку вот этот объект e вроде бы является объектом Employee, как и написано вот в этом определении, Employee и далее e.

Но, на самом деле, хотя e у нас определен как объект, принадлежащий к классу Employee, так же как, и массив staff, который у нас тоже определен, как класс Employee, несмотря на все это, на самом деле при присваивании, при i, равном 1, staff от единицы у нас является переменной m. Т.е. является классом менеджера.

И поэтому фактически при i, равном 1 у нас происходит так, что этот объект е является на самом деле Manager-ом, а не классом Employee, не просто сотрудником. И поэтому при вызове метода getSalary, происходит вызов не getSalary от Employee, как можно было бы предположить, просто посмотрев на вот эту строчку, а происходит вызов getSalary от класса Manager, который является наследником класса Employee, его подкласса.

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

Иерархия наследования. Абстрактные классыК оглавлению

Сохраним это все на жестком диске. Для этого щелкнем на кнопку сохранения. Далее создадим новую папку, которую назовем My16, далее Open. Теперь введем имя для нашей программы. Пусть это будет My16, по названию нашего класса. Щелкнем на кнопку Save и теперь рассмотрим наши вопросы с абстрактными классами. Представим себе, наследником чего может быть наш класс сотрудников. В принципе, достаточно естественно, чтобы все сотрудники являлись наследниками просто такого понятия, как человек, персона. Создадим теперь этот класс. Для этого щелкнем здесь на Enter и напишем abstract class

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

Конечно же, у всех людей, самое главное - это, конечно же, имя, то, чем он отличается от других людей. И поэтому вот это определение private String name введем для класса Person. Private, далее String, name,

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

далее скобка и тот параметр, который мы хотим ему передать. Он будет строковой, String. И далее переменная n, закроем скобку. Далее, внутри фигурных скобок, напишем name, равное n. Т.е. вот таким образом, мы зафиксировали в качестве имени вот этот передаваемый параметр.

В принципе, поскольку мы ввели в нашем классе Person имя для нашего человека, то мы должны предусмотреть и специальный метод, при помощи которого мы можем получить его имя в процессе работы программы. Для этого, как мы помним, у нас обычно есть в других классах специальный метод getName, реализуем здесь. Конечно же, этот метод у нас должен быть с пометкой public. Далее тип возвращаемого значения, конечно же, у нас будет String и далее getName. Параметров у этого метода нет, и поэтому просто скобки, а далее, внутри фигурных скобок напишем return и далее name.

Точка с запятой, закроем фигурные скобки. Теперь попробуем переделать наш класс Employee так, чтобы он был наследником вот этого класса Person. Для этого нам нужно здесь добавить ключевое слово extends и далее класс, который будет для него родителем, а именно класс Person. Cдвинемся скроллингом ниже, и отметим, что на этот раз у нас поле name, которое было в классе Employee, уже является лишним, оно у нас определено уже в его родительском классе Person. Поэтому эту строку мы можем совершенно спокойно удалить.

И к тому же нам придется переделать конструктор Employee. Конечно же, вот эта запись name, равное n, это уже пережиток прошлого, пережиток того времени, когда Employee был своим отдельным классом. А сейчас мы должны сослаться на конструктор, который есть в его родительском классе Person. И поэтому напишем таким образом, super, это у нас обращение к классу родителя, и далее в скобках передаваемый параметр имени n. Закроем скобку, точка с запятой.

А теперь отметим одно обстоятельство, что метод getName в нашем классе Employee уже абсолютно лишний, поскольку такой же метод у нас уже есть в его родительском классе Person. Поэтому удалим вот эти две строчки, которые у нас описывают этот метод. Теперь, после того, как мы разобрались с классом Employee, попробуем создать еще один класс, а именно класс студентов, который, конечно же, абсолютно не является нашим сотрудником, никакого отношения к нам не имеет. Это совершенно отдельный класс людей, который тоже являются наследником класса Person. Они тоже люди. Так же, кстати, как и любые сотрудники и менеджеры.

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

Теперь, внутри фигурных скобок, надо написать то, что характеризует именно нашего студента. Пусть у студента будет два поля - имя и его специализация. Поскольку имя у нас уже есть внутри класса Person, его определять заново уже с не нужно, просто определим специализацию. Для этого напишем private. Это поле будет тоже типа String, и далее специализация major.

Точка с запятой. Теперь нам заново надо определить конструктор для этого класса. Поэтому напишем таким образом, public и далее Student.

Скобка. И теперь поля, которые должны быть у этого конструктора. Они будут типа String. String, n, и следующий формальный параметр, который будет типа String, представляющий собой специализацию m, закроем скобку. Далее, внутри фигурных скобок напишем таким образом. Во-первых, вызовем класс родителя при помощи ключевого слова super,

и передадим его конструктору имя n, затем определим и саму специализацию. Major, равное m, точка с запятой. Вот, таким образом мы уже полностью охарактеризовали наших студентов. Можем создать еще один класс. Например, класс Children, дети. Class, Children,

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

И далее возраст, для которого возьмем целый тип int и возраст age, точка с запятой. А теперь нам нужно определить конструктор для этого класса Children. Напишем таким образом, public, далее Children, внутри скобок напишем переменную типа String, это у нас имя n, запятая и возраст, это переменная типа int, переменная целого типа, пусть она будет i. Закроем скобку и далее внутри фигурных скобок надо написать таким образом. Во-первых, вызов своего родительного конструктора super с параметром n, при помощи которого мы будем передавать ему имя. Точка с запятой, и далее нам нужно зафиксировать возраст ребенка.

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

для того чтобы мы могли сюда вписать не только сотрудников, но и студентов, и детей. Поэтому напишем здесь вместо Employee Person. И далее new Person. Теперь нам нужно заполнить этих персон их значениями. Переправим еще и название данного массива. Staff уже не подходит, и напишем просто people, человек. Теперь начнем, как мы сказали, заполнять значениями.

Иерархия наследования. Абстрактные методыК оглавлению

Попробуем теперь создать в нашем массиве people, представителей, всех этих 4 разновидностей. Самое основное, Person, мы, создать не можем, поскольку этот класс является абстрактным. Один из этих представителей, это объект нашего массива с номером 0.

Напишем ему имя people, и пусть он будет типа Employee. И согласимся с фамилией и с зарплатой, которая у него есть. Следующий представить, это у нас Manager, он у нас здесь есть. Единственное, вместо staff нам нужно опять написать people,

название нашего массива. Остальное можно оставить так, как есть, фамилия Адамс, зарплата 60 000 и bonus 10 000. Напишем следующее определение people, которое у нас должно быть, для индекса с номером 2. Пусть будет опять сотрудник с фамилией Тейлор зарплатой 35 000.

Далее, зададим ребенка, Child. Пусть это будет people с индексом 3. Класс, уже будет не Employee, а Person.

Пусть фамилия ребенка будет Митчелл. А возраст 43 000, конечно же, уже не подходит. Поэтому напишем возраст, например, 12 лет. Введем еще одного представителя рода людей. Пусть это будет студент, представитель рода людей people,

с индексом 4. Поэтому напишем знак равенства, new Student. И далее, внутри скобок надо написать его фамилия и специализацию. Фамилия пусть у него будет Морис.

Инициалы J. А, точка, далее кавычки и запятая. И теперь нам нужно написать его специализацию. В качестве специализации, напишем Компьютерные науки. Далее закроем кавычки,

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

Здесь вместо staff, нужно написать people, по названию нашего массива. А далее, вместо Employee, нам нужно написать, Person,

по названию нашего родительского класса. И далее, вместо staff нужно написать название нашего массива people. Теперь обратимся к тем данным, которые мы пытаемся вывести на наш экран. Первый из них, это getName, с этим все понятно, а вот понятие getSalary, далеко не везде присутствует в наших классах. Поэтому от этого метода нам придется отказаться.

Для этого выделим его и полностью удалим. Теперь мы можем скомпилировать нашу программу и посмотреть, что у нас получилось. Для этого щелкнем на кнопку Tools, Compile Java. Теперь запустим наше приложение, Tools и Run Java Application.

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

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

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

Назовем этот метод getDescription, получить описание, и в принципе, мы можем его сделать абсолютно абстрактным, оставив его реализацию, уже для конкретных классов Children, Student, Employee и Manager. Поэтому внутри класса Person напишем таким образом.

Во-первых, он должен быть public, далее abstract, и тип возвращаемого значения, String. И далее имя нашего метода getDescription.

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

Конкретная реализация абстрактных классов и методовК оглавлению

и в классе Employee напишем такие строчки, при помощи которых нам надо перегрузить вот этот абстрактный метод getDescription. Введем здесь Enter, далее pubic.

Далее тип возвращаемого значения, String. Имя нашего метода getDescription.

Далее открывающая и закрывающая скобки, поскольку параметров здесь нет. И далее, внутри фигурных скобок нам нужно написать код, который и будет определять описание нашего сотрудника Employee. Напишем таким образом, return,

откроем кавычки, en employee with a salary of, закроем кавычки, т.е. это сотрудник с зарплатой. Теперь напишем величину этой зарплаты.

Поэтому напишем плюс, саму зарплату salary, точка с запятой. Теперь точно такой же метод getDescription нужно написать всем остальным классам в нашей программе. Для этого сдвинемся скроллингом ниже, предварительно скопировав вот эти строчки, для того чтобы нам было легче проектировать этот метод. Выделим. Далее правая кнопка мыши и Сору.

Теперь сдвинемся ниже. Вот класс Manager, в котором в принципе мы тоже могли бы переделать этот метод. Поэтому щелкнем здесь на Enter, далее встанем сюда. Правая кнопка мыши, Paste.

И теперь, вместо Employee напишем, что это менеджер. Manager, и вместе с зарплатой напишем, что у него есть и bonus. Поэтому напишем таким образом, плюс, кавычки, далее напишем and bonus of.

Далее кавычки, плюс и напишем величину bonusa. Cдвинемся скроллингом далее. И напишем описание нашего студента. Введем здесь Enter. Далее встанем сюда. Правая кнопка мыши, Paste.

И на этот раз напишем несколько по-другому. Уберем то, что написано здесь, напишем a student majoring in, закроем кавычки, плюс и дальнейший текст, тот, который находится в специализации major. Поэтому напишем плюс major.

А теперь сдвинемся скроллингом ниже. И последний представитель, это у нас Children. Щелкнем здесь на Enter. Далее вставим сюда. Правая кнопка мыши, Paste. И теперь напишем таким образом. Во-первых, это все уберем и напишем таким образом,

a child, точка, his age is, и сам возраст. Плюс age, далее плюс, и внутри кавычек дополним еще таким текстом, years old. Попробуем теперь скомпилировать вот эту программу. Для этого Tools, Compile Java. Как мы видим, у нас оказалось две ошибки. Первая из них, это после getDescription не хватает точки с запятой, о чем нам подсказывает наш компилятор. А вторая - уже более серьезная. Мы в нашем классе Manager, обратились к salary, который, как мы помним, является прерогативой класса Employee, доступ к этому полю. Это уже более серьезная ошибка, над которой придется немножко подумать.

Переключимся обратно на My16.java, исправим первую из этих ошибок. Для этого в классе Person, там, где у нас абстрактный метод getDescription, напишем в конце точку с запятой. Это делается совсем просто. Теперь, в классе Manager нам что-то надо делать с этой переменной salary.

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

Super, далее точка и getSalary, скобки. И как раз в этом случае, мы получим правильное значение, мы получим зарплату, без учета bonus-a. А bonus у нас будет идти отдельным числом.

Теперь скомпилируем нашу программу. Для этого Tools, Compile Java. На этот раз все у нас прошло вполне успешно. Поэтому запустим нашу программу, Tools, Run Java Application. И, как мы видим, чисто внешне, пока абсолютно ничего не изменилось. Мы получили только список имен наших людей. Для того чтобы вывести каждой персоне его описание, закроем наше консольное окно, сдвинемся скроллингом вверх и далее, вместе с именем, введем и его описание. Вот в этом месте, там, где у нас выводится текст на наше консольное окно.

Поэтому напишем таким образом. Плюс, далее кавычки, введем запятую, пробел, чтобы немножко отделить имя от описания, далее плюс и переменная e, в которой у нас сконцентрирована наша персона. Далее точка, getDescription, и далее скобки. Теперь скомпилируем нашу программу. Для этого Tools, Compile Java.

Запустим ее, Tools, Run Java Application. И вот теперь мы на нашем экране можем видеть имена всех наших персон вместе с их описаниями.

Все разнообразие людей, которое у нас есть в нашей программе, отображено на нашем консольном окне. Это и сотрудники с разной зарплатой, менеджер со своей зарплатой и с премией, также ребенок со своим возрастом, и студент со специальностью.

Закроем теперь это консольное окно и вернемся в наш обычный текстовый редактор.

Метод equalsК оглавлению

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

Далее создадим для него отдельную папку, назовем ее My17. Далее щелкнем на кнопку Open и зададим имя для нашего приложения. В данном случае это My17, так как это название должно совпадать с названием нашего класса, в котором находится метод main.

Щелкнем на кнопку Save, сохранить, и вот мы вернулись в наш текстовый редактор. Рассмотрим теперь, как в классах нам можно было бы организовать сравнение двух объектов.

В принципе в классе Object, потомками которого являются все классы, существует метод equals. Но он проверяет, занимают ли эти объекты одну и ту же область памяти, что практически бесполезно. Если на самом деле надо убедиться, что два объекта эквивалентны, то надо этот метод equals из Object, перегрузить и создать свой собственный вариант.

В принципе, метод equals мы создавали ранее в нашем классе Employee. Если мы двинемся скроллингом вниз, то можно заметить метод equals, который здесь есть и который реализован таким образом, что он сравнивает зарплату двух сотрудников, и выдает в качестве результата отношение этих двух зарплат. Если одна зарплата больше другой, то выдается единица или минус единица, в зависимости от того, чья зарплата больше. И, если эти две зарплаты равны, тогда выдается значение 0.

Теперь реализуем другой вариант этого сравнения. А именно, попробуем выяснить, идентичны ли два объекта. Удалим сначала те строчки, которые здесь уже есть. Для этого выделим их и удалим. Теперь, в качестве возвращаемого значения, возьмем не тип intagar, а тип boolean, поскольку нас просто интересует, равны эти два объекта или нет. Напишем boolean,

поскольку мы хотим сравнить именно два объекта, тогда вместо Employee other в качестве параметра зададим другой объект. Напишем слово Object. Теперь начнем наши проверки.

Первое, что мы можем сделать, это проверить, не является ли вот этот объект Object, объект other, тем же самым объектом, что и Employee. Поэтому напишем оператор if, скобка, текущий объект, this. Сравним его с этим объектом other.

И, если все это верно, это один и тот же объект, возвратим ему значение true. Точка с запятой. Возвращаем значение истина. Теперь посмотрим, какие еще возможности у нас есть. В принципе, объект other может быть нулевым. И в этом случае, нам надо сразу же возвратить значение false. Учтем это. Напишем if, далее объект other.

Проверим, является ли он нулевым. Null, закроем скобку. И, если это верно, тогда возвращаем ложное значение false. Тогда, эти два объекта не равны друг другу.

Теперь, еще одно, что нам нужно проверить, это являются ли эти два объекта, объектами одного класса. Если они не являются объектами одного класса, в этом случае также надо возвратить значение false, в качестве возвращаемого значения. Поэтому опять напишем if. Теперь определим тип нашего объекта. Для этого используем специальный метод getClass,

далее скобки. Передаваемых параметров здесь нет, и проверим на неравенство, не равно. И затем то же самое с передаваемым параметром other. Other, точка, getClass и закроем скобку. Если эти два класса, класс передаваемого параметра other и класс нашего исходного объекта, не равны друг другу, в этом случае, опять возвращаем false.

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

Поэтому напишем таким образом, Employee. Далее возьмем какую-либо переменную этого класса. Пусть это будет просто одна буква e, знак равенства, и сделаем преобразование типа от нашего объекта Object other к типу Employee. Для этого в скобках напишем Employee,

т.е. тот класс, к которому мы хотим привести значение, и далее название нашего параметра other, точка с запятой. Вот теперь мы этот передаваемый параметр other привели к типу Employee в переменной e. И теперь мы уже может приступить непосредственно к сравнению имени и зарплаты. Поэтому напишем таким образом, return,

проведем сравнение имен, поэтому напишем name, далее equals. Такой метод есть в строковых классах. Далее имя этого объекта e, точка, name.

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

Е, точка, salary, точка с запятой. Вот таким образом мы уже полностью определили сравнение двух объектов, в нашем классе Employee.

Метод equals. Сравнение подклассовК оглавлению

Далее, тип возвращаемого параметра boolean, имя нашего метода, equals, то, что мы и передаем в качестве параметра. А именно, Object и other. Закроем скобки. Теперь напишем внутри фигурных скобок реализацию для класса Manager.

Cначала, опираясь на метод, который мы написали для класса Employee, нужно проверить, что выдает нам родительский метод equals. Напишем таким образом, if, далее скобка, и сравнение. Напишем отрицание сравнения, super. При помощи ключевого слова super мы вызываем метод equals из родительского класса, из класса Employee.

Далее equals, скобка. И далее параметры, которые мы ему передаем, передаем мы объект other. Закроем скобки и теперь посмотрим, что мы написали. Мы написали, что если метод сравнения equals, который реализован в классе Employee, выдает нам false, т.е. уже на стадии родительского класса эти два объекта не равны друг другу, тогда мы сможем возвратить значение false и в нашем случае. Поэтому напишем return и false.

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

А теперь нам нужно сделать еще одно. Так же, как и мы создавали во время написания этого метода в классе Employee экземпляр данного класса, сейчас, конечно же, мы должны создавать экземпляр класса Manager. Поэтому напишем Manager, для того чтобы мы могли привести к одному типу эти два объекта. Пусть эта переменная будет m, далее знак равенства и преобразование типа к типу Manager.

И далее объект other. Конечно же, такое преобразование уже вполне правомочно, потому что появляется возможность сравнить классы и методы прямо в родительском классе при помощи вот этого метода super equals, мы это проверили в родительском классе выяснение о том, являются ли они методами одного класса.

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

и далее сравним бонусы. Эти именно то поле, которым класс Manager отличается от своего родительского класса. Далее сравним с бонусом объекта m. М, точка bonus, точка с запятой.

Теперь этот метод у нас расписан и для Managera. Попробуем теперь просто скомпилировать наше приложение и посмотреть, что у нас получится. Посмотрим, какие ошибки могут выявиться. Поэтому щелкнем на кнопку Tools, и Compile Java. И вот можно видеть список тех ошибок, компьютер у нас нашел. Первая из них в классе той строчки, в которой у нас происходит сравнение двух классов.

В принципе тут достаточно простая ошибка. А именно в методе getClass мы просто забыли записать скобки. Мы написали только с левой стороны, а с правой стороны мы забыли. Но, это достаточно легко исправимая ошибка. Следующие три ошибки, которые компьютер выявил, на самом деле, это все ошибки, которые касаются одной строчки, где мы сравниваем поля нашего класса Employee. Первая из этих ошибок, в этих двух строчках, это ошибка, касающаяся вызова поля name. Конечно же, непосредственно вызывать это поле мы не можем, потому что это поле принадлежит его родительскому классу Person

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

Впишем вместо равенства, знак сравнения между зарплатами и теперь нам нужно что-то делать с нашим вызовом поля name. И как мы сказали, здесь нам нужно написать вызов метода getName. Далее нам нужно написать скобки. И то же самое для вызова имени в нашем втором объекте, в объекте e.

Тут тоже getName, далее скобки. Попробуем теперь опять скомпилировать наше приложение. Для этого Tools, Compile Java. На этот раз у нас компиляция прошла успешно, о чем нам говорит вот эта надпись. Переключимся на наш листинг приложения.

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

Сдвинемся теперь скроллингом ниже. И займемся классом студентов. Щелкнем здесь на кнопку Enter. Далее встанем сюда. Правая кнопка мыши и Paste. Вставим строчки, которые у нас находятся в буфере обмена. И посмотрим, что мы можем сделать в этом случае. Конечно, первые три проверки, вот эти строчки можно оставить без изменения. Тут все подходит и для этого случая, для случая студентов, а далее нам нужно его переделать. Вместо класса Employee нам надо использовать класс Student.

В качестве приведения типа тоже надо использовать, конечно же, приведение к типу Student, а не к типу Employee. Поэтому Employee сотрем, и напишем вместо него Student. Наряду со сравнением имен, нам теперь надо сравнить специализацию студентов. Поэтому уберем это равенство зарплат, и вместо этого напишем таким образом, major,

точка equals, далее скобка, и далее е, точка major, т.е. специализация объекта е. Закроем скобку. В принципе прямое обращение к полю major, к полю специализация, здесь вполне проходит, поскольку поле major находится внутри этого класса, внутри класса Student. За эти пределы мы не выходим, в отличие, той ситуации, которая у нас была с именем. Теперь сдвинемся скроллингом ниже и проделаем аналогичные процедуры с классом Children. Поэтому щелкнем здесь на клавише Enter,

далее правая кнопка мыши, Paste. У нас уже была в памяти вот эта заготовка для сравнения двух сотрудников. Теперь нам нужно вместо Employee написать Children. И то же самое для приведения типа. Вместо Employee нам надо привести все к типу Children.

И далее, нам нужно сравнить не зарплату двух персон, а их возраст. Сравнение имен здесь уже есть, уберем сравнение зарплат и напишем таким образом. age, сравниваем с е.age, возрастом персоны е. Е, точка age.

Метод equals. Выявление одинаковых объектовК оглавлению

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

Следующую персону Children сместим на единицу. Пусть она будет с номером 4, далее персона с номером 5. Пусть она будет равна и тождественна персоне с индексом 1,

точка с запятой. Затем введем еще одну персону, еще одного человека с индексом 6. Присвоим ему значение с индексом 4. И далее у нас идет персона с номером 7, пусть будет это ребенок.

И далее еще одна персона с индексом 8, которая будет равна предыдущей персоне, персоне студента. Те же самые значения, что и в 7 персонале, точка с запятой.

Здесь наверху не хватает точки с запятой. А теперь, после всех этих изменений, нам нужно увеличить количество людей в нашем массиве. Для этого вместо 5 здесь надо написать 9, поскольку теперь у нас 9 объектов в нашем массиве.

И теперь организуем цикл, при помощи которого сможем вывести на наш экран все персоны, которые равны друг другу. Для этого нам придется написать оператор цикла, который проще всего скопировать вот из этого места. Выделим вот эту строчку. Далее правая кнопка мыши и Сору. Вставим сюда. Правая кнопка, Paste.

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

Для этого скопируем один из методов println. Правая кнопка мыши, Сору. Вставим сюда. Правая кнопка мыши и Paste.

Вместо println, напишем просто print, без перевода строки, и выведем значение номера i. Закроем скобку, точка с запятой.

Далее введем еще один println. Для этого правая кнопка мыши и Paste. И этот println у нас будет без всяких параметров, просто перевод строки. И между этими двумя print как раз и напишем все наши строчки кода.

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

И теперь в качестве переменной вот этого цикла, возьмем не i, а j, поскольку переменная i у нас уже занята для внешнего цикла. Напишем здесь j. Здесь, и там, где у нас увеличивается на единицу.

Теперь же, введем фигурные скобки, внутри которых и проведем наше сравнение. Для этого напишем оператор сравнения if, далее people, с индексом i, точка, наш метод equals. Далее открытие скобки и другой человек people, другой объект.

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

Для этого скопируем метод print. Выделим его. Щелкнем правой кнопкой мыши и Сору. Вставим сюда. Правая кнопка мыши, Paste. И внутри оператора print напишем таким образом. Кавычки, далее пробел, знак равенства, пробел и опять кавычки,

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

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

Метод equals. НаследованиеК оглавлению

В каждой из этих строк присутствует равенство с одинаковыми цифрами. Объект с номером 0, конечно же, равен 0, т.е. объект равен самому себе. Первый равен первому, второй второму, третий третьему, четвертый четвертому и т.д. Кроме таких тождественных равенств есть еще другое равенство,

т.е. объект с номером 1 равен объекту с номером 3. Если посмотреть, то объект с номером 1, это Адамс, равный объекту под номером 3. Они, конечно же, идентичны и равны объекту, с номером 5.

Под номером 5 тоже Адамс, с теми же самыми данными. Кроме этого, объект с номером 4 и 6 тоже идентичны. Можно посмотреть, это Митчелл. И 7 и 8 номера, они тоже абсолютно идентичны. Последние два объекта в нашем массиве, тоже содержат абсолютно одни и те же данные. Закроем теперь наше консольное окно и вернемся в наш текстовый редактор.

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

Например, в классе Children и в классе Student, вот эти несколько строчек абсолютно идентичны, они повторяются. Это свидетельствует о недостатках нашей программы. Дело в том, что мы вполне могли определить вот этот оператор equals прямо в классе Person,

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

Скопируем. Теперь же сдвинемся наверх. И в конце класса Person напишем такие строки. Вставим то, что мы скопировали сначала. Для этого правая кнопка мыши и Paste.

Теперь проанализируем, что из этих строчек кода здесь подходит к классу Person, а что совершенно не подходит. Поскольку мы скопировали это из класса детей, то тут у нас строка сравнивания возрастов age, что является абсолютно лишним элементом в данном классе. Поэтому выделим и удалим. Кроме этого, конечно же, нам надо переделать вот эту строчку. Здесь все надо переделать с учетом того, что у нас классом является Person, а не Children.

Поэтому вместо класса Children, напишем Person, приведение тоже проведем к классу Person. И нужно организовать совсем иным способом сравнение двух имен. Нам просто надо написать конструкции типа name равно name.

И вызов метод getName нам тут совершенно не нужен. Поэтому вместо getName, напишем name. Далее equals, сравнение двух строчек у нас должно происходить с помощью equals, и далее name от объекта е.

Вот в таком виде этот метод equals будет вполне подходящим нашему классу. Теперь перейдем туда, где у нас происходит сравнение в классе Employee, в классе менеджеров и т.д. Попробуем переделать там все с учетом того, что какая-то заготовка для этого метода у нас уже приготовлена внутри метода Person, внутри родителя.

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

нам нужно провести сравнение вот такого типа, равны или нет эти два объекта с помощью родительского метода equals. Поскольку эта строчка у нас уже здесь готова, выделим и скопируем ее. Далее вставим сюда. Правая кнопка мыши, Paste.

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

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

Конечно, это равенство имен надо убрать. Оно здесь уже лишнее и дублирует то же самое в родительском классе. Удалим. Сдвинемся еще ниже. И проделаем ту же самую операцию внутри класса детей. Выделим вот эти три строчки. Удалим. Затем правая кнопка мыши и Paste. Опять вставим сравнение родительского класса.

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

а все остальное, проверяется в методе родителя. Теперь скомпилируем опять нашу программу и попробуем ее выполнить. Для этого Tools, Compile Java.

Компиляция прошла успешно, без ошибок. Поэтому запустим наше приложение. Tools и Run Java Application. Как мы видим, у нас все абсолютно то же самое. Результат идентичный, что в принципе можно было и ожидать.

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

Метод toStringК оглавлению

Попробуем все это реализовать внутри наших классов. Для этого рассмотрим ту заготовку программы, которую мы писали ранее, и в которой у нас есть несколько классов разной иерархии. Она начинается с класса Person, у которого есть несколько подклассов. Это класс Employee, класс сотрудников, у которого есть свой подкласс Manager. Так же классы Student и Children.

И именно, внутри этой структуры попробуем определить и перегрузить метод toString. Для этого сохраним вот этот листинг внутри какого-то файла. Для этого щелкнем на кнопку сохранения. Введем новую папку для нового приложения. Пусть это будет My18. Щелкнем на кнопку Open. Далее введем имя для нашего приложения, которое, как мы знаем, должны совпадать с именем того класса, в котором у нас, и есть метод main. Поэтому назовем его My18. И щелкнем на кнопку Save, сохранить. Чаще всего этот метод toString реализуют, как вывод некой строки, которая состоит из имени подкласса, за которым стоит значение его полей в квадратных скобках.

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

Это может быть и более оправдано, поскольку вывести, например, название нашего "персоналия", его имя, лучше всего именно здесь. Поэтому abstract мы здесь писать не будем, а напишем тип возвращаемого значения String.

И далее название нашего метода toString. Далее скобки, поскольку параметров нет, то внутри скобок мы ничего писать не будем, и далее, внутри фигурных скобок, напишем реализацию этого метода. Напишем return, далее имя нашего класса, который лучше всего организовать при помощи специального метода getClass. GetClass, затем скобки,

точка, getName, чтобы получить имя нашего класса. Далее скобки, знак плюса, кавычки и далее, внутри квадратных скобок, нам нужно описать текущее состояние всех полей, которые есть в нашем классе. В данном случае, это у нас поле name, которое существует в классе Person.

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

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

Введем здесь Enter. Напишем опять название нашего метода. Для этого public, далее тип возвращаемого значения, String, и сам метод toString, скобки, и внутри фигурных скобок реализация этого метода. Теперь напишем return и то, что нужно возвратить. Нужно возвратить строку, которая организована в классе родителя. Для этого напишем вот таким образом, super, далее toString, вызов родительского метода toString и знак плюса.

И теперь нам нужно написать те поля, которые есть у нас в классе Employee и которые отличные от класса Person, вдобавок к нему. Поэтому откроем кавычки, в квадратных скобках напишем название нашего поля salary, зарплата. Далее знак равенства, закроем кавычки, плюс и прибавим само значение.

Salary, затем плюс. Теперь можем закрыть квадратные скобки. Для этого закроем кавычки, квадратную скобку, и точка с запятой. Теперь, что-то аналогичное нам уже надо написать в следующих наших классах. Для того чтобы у нас была заготовка, и мы много не писали, скопируем вот эти три строки. Выделим их. Правая кнопка мыши, Сору. А теперь сдвинемся скроллингом ниже, в класс менеджеров. Встанем сюда. Правая кнопка мыши, Paste. И теперь здесь, вместо зарплаты salary, нам нужно вывести поле bonus.

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

Для класса студентов нам здесь надо написать поле major, специализация. Теперь его значение, major. И то же самое для класса детей. Правая кнопка мыши, Paste, и далее, вместо salary нужно ввести поле age и его значение.

Вот, теперь у нас этот метод присутствует во всех наших классах. Сдвинемся теперь скроллингом вверх, и там, где у нас выводятся все наши данные о всех наших персоналиях, попробуем то же самое сделать еще раз. Вывести, но уже при помощи нашего нового метода toString. Поэтому скопируем эти строчки, для того чтобы не писать все это заново. Далее правая кнопка мыши и Сору. Встанем сюда. Правая кнопка мыши, Paste. И теперь там, где у нас находится println, напишем метод toString.

Пусть номер i остается, а вместо getName напишем метод toString. А все остальное нам уже абсолютно не нужно. Теперь попробуем скомпилировать и выполнить нашу программу. Для этого Tools, Compile Java.

Компиляция в принципе прошла успешно. Вопросов нет у компилятора. Поэтому Tools и Run Java Application. А теперь можно видеть результат выполнения нашей программы. Если в первом блоке у нас выведен массив всех персоналий вот в таком более или менее в свободном виде, то после него выведем тот же самый массив при помощи стандартного метода toString, с учетом того, что выводится название класса и значением всех его полей в квадратных скобках.

Надо отметить, что метод toString достаточно вездесущ. И для этого существует очень веская причина, поскольку данные, которые мы можем вывести при помощи этого метода, незаменимы для отладки наших приложений. Поскольку мы получаем моментальный снимок того, что происходит в нашем классе на данный момент. Закроем теперь это консольное окно. Щелкнем на вот этом крестике

и отметим еще одно обстоятельство, которое еще раз подчеркивает важность метода toString. Дело в том, что при выводе на печать, вот эту аббревиатуру toString можно вообще не писать, а прямо написать имя нашего объекта e.

И компилятор при выводе наше консольное окно, сам сообразит, что если мы хотим получить информацию об объекте, то это имеется в виду метод toString. Попробуем еще раз запустить наше приложение. Сначала скомпилируем. Tools, Compile Java, опять Tools и Run Java Application. Мы получили все то же самое, т.е. таким образом вызывать этот метод toString тоже вполне возможно. Закроем теперь наше консольное окно и вернемся в наш стандартный текстовый редактор.

Списки массивов. СозданиеК оглавлению

Для этого начнем работу с вот этого шаблона приложения, который мы создавали ранее и который на основе класса Person и его подклассов, таких, как класс Employee - класс сотрудников, а также класс Manager, Student и Children, создает некий массив, состоящий из представителей этих классов, и выводит всю эту информацию на печать.

Сначала сохраним эту программу в каком-либо файле. Для этого щелкнем на кнопке сохранения. Создадим для этого приложения отдельную папку. Назовем эту папку my19. Далее щелкнем на кнопке Open. Переименуем наш файл. Назовем его по названию нашего класса. Тоже My19.

И щелкнем на кнопке сохранения, на Save. Теперь рассмотрим вопрос о размере массивов в языке Java. Надо отметить, что во многих языках программирования, размер массива, это величина постоянная, определяемая на стадии разработки, еще на этапе компиляции программы.

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

Самое простое, что реализовано в языке Java, это возможность задания вот этого числа 5, при помощи которого мы задаем размер массива, в процессе выполнения программы. Т.е. можно заранее задать некое число, которое и будет потом являться для задания размера массива.

Ну, например, вот в нашем случае можно написать таким образом, int, далее i1 равняется 5, точка с запятой. И затем можно указать вот эту переменную i1 в качестве размера массива. Впишем сюда i1. Ну, конечно, в принципе эта ситуация уже намного лучше, чем задание массива на этапе компиляции. Поскольку эту переменную i1 можно задавать в некоем интерактивном режиме и задавать его будет конкретный пользователь, который выполняет нашу программу.

Ну, несмотря на эти преимущества, тем не менее, встает вопрос о том, а как же изменить размер массива, который уже один раз задан. Т.е. если мы уже взяли и создали массив, состоящий из 5 элементов, а в дальнейшем, в процессе выполнения работы нам понадобилось элементов больше, 5, 6, 10, то дальнейшие изменения уже сложней.

Именно для этих целей в языке Java, есть специальный механизм, имитирующий массивы и способный автоматический уменьшать или увеличивать свой размер, в зависимости от ситуации. Класс этот называется ArrayList. Надо отметить, что между массивами и вот такими списками массивов ArrayList есть существенная разница, которая заключается в том, что сам массив является встроенным свойством языка Java, в отличие от ArrayList, которое определено в специальном пакете java.util. И поэтому нам в нашей программе придется в начале этого листинга написать специальную директиву import. И при помощи этой директивы, загрузим java.util. Далее точка и звездочка, для того чтобы загрузить все классы этого пакета.

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

И далее зададим массив, состоящий из людей, из people. Для этого здесь напишем немножко по-другому. Вместо задания класса Person и т.д., напишем по-другому. ArrayList, далее пусть будет массив, состоящий из people. Название people оставим и далее new ArrayList.

Вот это слово мы тоже удалим. Напишем ArrayList и далее введем скобки. Вот, мы создали новый шаблон, в который будем загружать объекты типа Employee, Children и т.д. Т.е. тех классов, которые у нас есть в нашем приложении.

Но, вместо вот такого задания, которое мы раньше практиковали, т.е. элемент с номер 0, равняется и создается новый объект, этого типа и т.д., сейчас нам нужно использовать другую директиву, а именно, директиву add. Поэтому напишем таким образом, people - название нашего массива. Точка и далее директива add (добавить).

Далее откроем скобку. И вот, именно теперь, нам нужно создать конкретный объект этого типа. Например, вот такой new Employee. Для этого скопируем вот эту строчку. Щелкнем правой кнопкой мыши, Сору. Вставим ее сюда. Правая кнопка, Paste.

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

Для этого, после создания и заполнения полей менеджера этими двумя строчками, нужно написать следующее. А именно, добавить этот элемент в наш массив. Поэтому напишем people, точка, add. И добавим вот эту информацию, которая хранится в переменной m. Точка с запятой.

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

Теперь то же самое сделаем со следующей строчкой. Для этого введем точку, add. Откроем скобку. Удалим лишние знаки. В конце вставим еще одну закрывающую скобку. Затем то же самое сделаем с последним, 4 объектом. Введем точку, add. Откроем скобку. Далее удалим 4 вместе с квадратными скобками и знаком равенства. И в конце добавим еще одну закрывающую скобку. Вот теперь у нас наш массив полностью сформирован.

Но встает еще один вопрос, не менее интересный, а именно, как же нам все это получить на окне нашего приложения, при его работе. Поскольку тот механизм, который сейчас у нас записан в нашем приложении, это является наследником того времени, когда у нас people был абсолютно обычным массивом, в котором можно было прямо вот так, при помощи квадратных скобок, получить доступ к отдельному его элементу. А сейчас, это у нас массив другого типа - ArrayList. И здесь механизм немножко другой.

Ну, и в принципе, первое, что нам нужно сделать даже до того, как мы как-нибудь организуем доступ к определенному элементу нашего массива, это нам нужно узнать длину этого массива, для того чтобы мы могли правильно организовать цикл. Для этого в этом классе ArrayList существует специальный метод size, и поэтому, здесь вместо метода length, который выделим и удалим, напишем таким образом, size. И далее открывающая и закрывающая скобки.

И теперь, для того чтобы в следующей строке получить элемент типа Person, из нашего массива people, нам нужно написать таким образом. Нам надо воспользоваться специальным методом get, который есть у нашего класса ArrayList. Удалим вот эту квадратную скобку вместе с i. После people напишем точку, при помощи которой мы получаем доступ к методам этого класса. И далее метод get, внутри которого в скобках, напишем тот номер, который мы хотим, а именно i.

При этом, кстати, отметим еще одно обстоятельство, что номер массива так же, как и обычного массива, всегда начинается с 0. И теперь отметить еще одно обстоятельство, что если мы вот таким образом скомпилируем наше приложение, то ничего хорошего мы не получим. Мы получим опять-таки ошибку. Поскольку, после того, как мы воспользовались методом get, нам нужно проделать преобразование типа, чтобы вот этот объект, который в результате у нас вот здесь получился, привести к классу Person.

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

Теперь выберем команду Run Java Application, и мы можем видеть результат выполнения нашей программы, который в принципе, конечно же, ничем не отличается от того, что мы видели ранее. Мы просто-напросто выводим список наших людей на экран. Закроем теперь это консольное окно. И вернемся в наш текстовый редактор, отметив, конечно же, что, несмотря на то, что внешний вид абсолютно такой же, как и ранее, но, тем не менее, внутренний механизм совершенно другой. Мы нигде не задавали заранее размер нашего массива. Он просто-напросто определяется количеством элементов, которые мы вставили при помощи вот этого метода add (добавить).

Списки массивов. Изменение и добавление элементовК оглавлению

Например, после того, как у нас сформирован весь этот массив, изменим какие-либо его элементы. Ну, напишем таким образом, people, точка, далее set. Затем откроем скобку. Теперь нам нужно указать, какой из элементов мы хотим изменить. Например, пусть мы хотим изменить третий элемент. Далее запятая.

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

Затем встанем сюда. Правая кнопка мыши и Paste. А теперь скомпилируем и выполним наше приложение. Для этого развернем меню Tools, Compile Java. А теперь опять выберем команду Run Java Application.

И вот можно видеть результат выполнения нашей программы. Если у нас раньше под индексом 3 был элемент типа Children, со своим возрастом и т.д., то сейчас под номером 3 у нас опять менеджер такой же, как и под номером 1. Закроем теперь наше консольное окно. Щелкнем на вот этом крестике и мы вернулись в наш обычный текстовый редактор.

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

Например, если вместо 3, здесь мы напишем число 33, и далее скомпилирует программу. Давайте сделаем это. На этапе компиляции у нас все прошло нормально, а вот, если мы сейчас попробуем запустить наше приложение, для этого активизируем команду Run Java Application,

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

и отметим, что во избежание ошибки об этом всегда надо помнить. Сейчас же изменим опять цифру 33 обратно на 3. Отметим теперь еще одно обстоятельство, а именно, что класс ArrayList, это тот список массивов, в котором можно хранить не только объекты, так сказать, одного типа, но и совершенно различных типов. Поэтому, в принципе такая возможность, наряду с преимуществами, таит в себе и определенные опасности. Особенно, когда мы начнем приведение типа, при доступе к определенным элементам массива.

Попробуем, например, добавить к нашему массиву еще несколько элементов. Для этого напишем таким образом, people, точка, add. Откроем скобку. И далее, вместо того, чтобы добавить еще один элемент того же типа, что и ранее, т.е. типа Employee, Children и т.д., вставим здесь совершенно другой тип. Например, введем просто-напросто объект типа String, который как мы помним, является объектом. Поэтому напишем таким образом, new String.

Далее откроем скобку и внутри скобок напишем в кавычках, какой-либо текст. Например, It is string и восклицательный знак. Далее закроем кавычки. Закроем скобку. Еще одну скобку и точка с запятой.

Теперь введем еще один элемент, который будет стандартным элементом. Для этого скопируем вот эту строчку, например. Правая кнопка мыши и Сору. Вставим сюда. Правая кнопка мыши и Paste. Теперь же попробуем скомпилировать и выполнить нашу программу. И мы увидим, как компьютер отреагирует на вот эту неправильность. А именно, на ввод объекта совершенно другого типа. Для этого сначала скомпилируем программу. Выберем в меню Tools команду Compile Java. Как мы видим, на этапе компиляции никаких ошибок обнаружено не было. Компиляция прошла успешно.

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

Отметим, что прежде чем мы будем выводить на печать и производить преобразование типа для нашего списка массивов, нам обязательно нужно проводить проверку. Является ли этот объект тем классом, который мы ожидаем. Реализуем теперь эту проверку. Для этого сделаем таким образом. Щелкнем здесь на клавише Enter, а строчкой выше, создадим новый объект, который обозначим типа Object, далее название этого объекта. Пусть будет просто-напросто Obj. Знак равнения.

И получим этот объект из нашего списка. Поэтому напишем people, точка. Теперь get, и номер i. Конечно же, сейчас нам никакого преобразование типа вводить не нужно. Объект это и есть, так сказать, самый верхний уровень наших классов,

и теперь, при помощи оператора if, нам нужно провести проверку. Поэтому напишем таким образом, if, далее откроем скобку. Object. Вот этот наш объект. Далее instanceof.

Далее тот класс, который мы хотим сравнить. Класс Person. Закроем скобку. И вот именно, если эта проверка верна, тогда мы будем проводить дальнейшие действия по выводу на печать всего этого дела. Поэтому щелкнем на клавише Enter. Далее откроем фигурную скобку, внутри которой мы поместим все остальные строчки.

Теперь нам осталось ввести только еще одну закрывающую фигурную скобку, которую напишем вот здесь.

Попробуем теперь скомпилировать и выполнить наше приложение. Для этого в меню Tools выберем команду Compile Java. Далее опять Tools, Run Java Application, поскольку компиляция прошла успешно. И можно видеть, что у нас получилось. А именно, программа выполнилась на этот раз абсолютно корректно. Правда, как мы видим, после номера 4 у нас идет элемент массива с номером 6. Один элемент пропущен. Это именно тот элемент, в который мы поместили так сказать абсолютно инородный объект совершенно другого класса.

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

Для этого, щелкнем здесь на клавише Enter и далее проведем проверку на то, является ли вот этот объект строкой. Поэтому напишем таким образом, if, далее опять объект Object, далее проверка instanceof и далее проверяем, является ли этот объект класса String (строка). Закроем скобку.

И, если это верно, тогда просто-напросто выводим эту строку на печать, получив ее из нашего списка. Поэтому напишем таким образом, String, далее пусть эта переменная будет s, равняется. Приведение типа к типу String. Далее наша переменная, которую мы извлекаем из нашего списка. people.get. В скобках напишем i. Точка с запятой.

Ну, теперь вот эту строку String можно просто-напросто распечатать. Для этого скопируем вот этот метод println вместе с номером. Щелкнем правой кнопкой мыши, Сору. Далее вставим сюда.

Правая кнопка мыши и Paste. Далее, после номера i введем просто-напросто разделительный пробел и плюс содержимое нашей строки s. Закроем скобку. Точка с запятой. Далее закроем фигурную скобку. Теперь же попробуем скомпилировать и выполнить наше приложение. Развернем меню Tools, Compile Java. Компиляция прошла успешно. Поэтому запустим нашу программу.

Выберем команду Run Java Application. И вот, можно видеть результат выполнения нашей программы. Вот в этом втором списке, можно видеть подряд все элементы нашего массива и внутри него, на месте элемента с номером 5 абсолютно другая строка, которая, как мы помним, как раз и является в принципе совершенно другим объектом. Закроем теперь наше консольное окно и мы опять вернулись в наш текстовый редактор.

Списки массивов. Вставка и удаление элементовК оглавлению

Попробуем это сделать. Например, добавим какой-либо элемент в середину нашего списка. Для этого опять напишем people, поставим точку, далее add. Откроем скобку

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

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

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

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

Скопируем их. Затем правая кнопка мыши и Сору. Вставим сюда. Правая кнопка мыши и Paste. И теперь скомпилируем и выполним наше приложение.

Для этого развернем меню Tools, Compile Java. Компиляция прошла успешно. Теперь в меню Tools выберем команды Run Java Application. И вот теперь можно увидеть, опять-таки результат выполнения нашей программы. Вот, под индексом 2 у нас добавился новый элемент. Вот эта такая фамилия Add (добавить).

И как мы видим, этот элемент вставился между двумя соседними, между Адамсом и Тейлором, которые раньше в этом списке были соседями. А теперь вот этот весь список раздвинулся. Тейлор и все последующие элементы сдвинулись вниз, а между ними вставился новый элемент Add.

Далее, мы удалили еще один элемент. Если посмотреть на эти списки внимательно, то можно увидеть, что вот этот элемент с фамилией Морис, у нас удалился. И следующие строчки, это вот эта обычная строка и следующий элемент с фамилией Митчелл, они все сдвинулись чуть повыше. И в результате получился вот такой список. После Адамса сразу же идет эта строка It is String.

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

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

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

например, в конец нашего списка, далее возьмем какое-либо число, например, 2,5. Закроем скобку. Точка с запятой. То вот такая запись на самом деле абсолютно не правильна. При компиляции компьютер выдаст нам ошибку. Дело в том, что добавлять мы можем только объекты, а числа сами по себе объектами не являются.

Правда, именно, для этих целей, в языке Java, существуют специальные интерфейсные классы, которые создаются на основе обычных чисел, типа integer, long, float, и т.д. И отличаются от них только тем, что начинаются они обычно с большой буквы.

Ну, в нашем случае, это у нас, конечно же, действительное число и поэтому конструкция будет вот такая, new, далее класс double, внутри которого мы и поместим наше число 2,5. Закроем скобку.

Попробуем теперь скомпилировать и выполнить нашу программу. Для этого активизируем команду Compile Java. Теперь опять выберем команду Run Java Application. Запустим наше приложение.

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

А проверку на то, является ли этот элемент числом, мы нигде не проводили, и поэтому число 2,5 к нам сюда не попало. Закроем теперь наше консольное окно и попробуем, тем не менее, вот это число получить в нашем списке на экране.

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

Теперь вставим сюда. Правая кнопка мыши и Paste. И теперь немножко переделаем эти строчки. Вместо String нужно вписать сюда double. Т.е. производим проверку, является ли этот объект типа double (действительное число).

Далее проведем преобразование данного типа к типу double. Напишем еще, что это именно число double. Напишем здесь в кавычках слово Double. Скомпилируем и запустим наше приложение.

Для этого развернем меню Tools, Compile Java. Компиляция прошла успешно, поэтому запустим наше приложение. Для этого активизируем команду Run Java Application? и можно видеть результат выполнения нашей программы. Последним, 7-ым элементом в нашем списке распечатывается действительное число 2,5,

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

Интерфейсы. Требуемые методыК оглавлению

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

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

Теперь же сохраним этот класс в файле. Для этого щелкнем на кнопке сохранения. Создадим для этого файла новую папку. Назовем ее таким образом, my20. Щелкнем на кнопке Open.

Далее введем имя для нашего файла. Он, конечно же, должен абсолютно точно совпадать с названием класса, My20, и щелкнем на кнопке сохранения, на кнопке Save.

А теперь же рассмотрим вопрос, как же нам использовать какой-либо интерфейс. Надо отметить, что интерфейс в языке Java, классом сам по себе не является. Он представляет собой лишь множество требований, которые предъявляются к соответствующему классу. Ну, в нашем случае, к классу Employee, к классу сотрудников.

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

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

Ну, посмотрим, как это конкретно реализуется. Для этого мы, после названия класса, класса Employee, должны написать таким образом, implements и далее Comparable, что как раз означает заявку того, что наш класс Employee будет применять вот этот интерфейс Comparable, при помощи которого в дальнейшем мы сможем отсортировать наш список, наш массив.

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

Поэтому щелкнем здесь на клавише Enter и далее напишем таким образом: public, далее int (тип возвращаемого значения). И далее название нашего метода compareTo, т.е. сравним два элемента.

Далее тип передаваемого параметра Object, и введем для него какое-либо имя. Допустим, other, закроем скобку. Далее щелкнем на клавише Enter, введем открывающие и закрывающие фигурные скобки, внутри которых нам и надо написать, по какому принципу мы будем сравнивать двух сотрудников.

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

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

Введем знак равнения, затем приведение типа Employee. Закроем скобку. И далее передаваемый параметр other. Точка с запятой.

Теперь же нам надо провести непосредственно сравнение. Поэтому напишем, оператор if, далее сравним зарплаты salary. Если эта зарплата нашего текущего объекта меньше, чем зарплата объекта, который мы передаем в качестве параметра, т.е. e точка salary,

тогда в этом случае возвращаем return, значение -1. Точка с запятой. Ну, конечно же, если мы напишем обратное сравнение if, текущая зарплата текущего объекта больше, чем зарплата объекта, который мы передаем в качестве параметра, тогда возвращать будем, конечно же, значение 1. Точка с запятой.

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

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

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

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

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

Для этого нам надо написать таким образом, Arrays, точка, затем вызов метода sort. Откроем скобку. И далее, мы должны указать тот массив, который мы хотим отсортировать. Ну, у нас это массив staff, массив сотрудников. Закроем скобку. Точка с запятой.

Теперь же, весь этот список, опять выведем на наш экран. Для этого проще всего скопировать вот эти несколько строчек. Выделим их. Теперь правая кнопка мыши и Сору. Встанем сюда. Правая кнопка мыши и Paste.

Теперь, попробуем скомпилировать наше приложение. Но до этого, для корректности вызова нашего метода sort, которым мы отсортировали наш массив, нам нужно указать и загрузить пакет java.util, в котором и реализована эта возможность. Для этого, конечно же, подойдем к началу нашего листинга и там напишем ключевое слово import. Далее тот пакет, который мы хотим использовать. А именно, java точка util, точка и звездочка. Это означает, что мы хотим рассмотреть все классы этого пакета.

Теперь же скомпилируем программу. Для этого развернем меню Tools, Compile Java. Далее Tools, Run Java Application. И на этот раз мы можем видеть, что у нас получилось. А именно, если сначала мы просто выпечатали весь наш список сотрудников подряд, без разбору, то далее, тот же список у нас выводится так сказать в упорядоченном виде, по возрастанию зарплаты наших сотрудников. Закроем теперь наше консольное окно и вернемся в наш текстовый редактор.

Интерфейсы. ПрименениеК оглавлению

Но, для этого введем в наш класс Employee еще одно поле, в зависимости от которого, мы и будем сортировать наш список. Для этого щелкнем здесь на клавише Enter и далее напишем таким образом, private, далее int, пусть это будет переменная целого типа.

Далее введем для него какое-либо имя. Ну, например, напишем просто-напросто sort. Точка с запятой, и в принципе можем присвоить ему какое-либо значение, во время создания нашего класса Employee.

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

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

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

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

Напишем таким образом, Enter, далее оператор if, теперь sort, сравним его значения с нулем. И если это верно, тогда будут выполняться следующие две строки.

А если же у нас эта переменная равна не нулю, а, например, единице, тогда просто-напросто скопируем вот эти две строки. Выделим их. Правая кнопка мыши. Сору. Вставим их сюда. Правая кнопка мыши и Paste.

И единственное, уберем скобки, поскольку они уже явно не нужны. И лишь изменим возвращаемое значение 1 и -1. Там, где (-1) напишем 1, а там же, где 1, (-1). Теперь же сдвинемся скроллингом выше.

И, как в принципе и понятно по умолчанию, у нас сортировка будет с индексом, когда вот это поле sort равно 0. А теперь же попробуем отсортировать по-другому.

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

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

Поэтому, после private напишем ключевое слово static. И теперь оно будет принадлежать, так сказать, самому классу Employee, ну и, конечно же, статическим нам надо объявить метод setSort, который задает значение этой переменной. Поэтому напишем таким образом, static. И вот, после этих модернизаций, нам можно непосредственно приступить к пересортировке нашего списка.

Для этого напишем вот таким образом, Employee, имя нашего класса, точка. Далее имя метода setSort. В скобках укажем другое значение. Ну, например, 1, то, которое будет отличаться от 0. Сейчас в принципе абсолютно все равно, какое это будет значение. Главное, что оно не равно 0.

Ну и далее, выведем опять весь наш список на печать после сортировки. Для этого выделим вот эти несколько строчек, в которые у нас включена и сортировка и вывод на печать. Поэтому, после того, как мы их выделили, щелкнем на правую кнопку мыши, Сору. Далее встанем вот сюда.

Правая кнопка мыши и Paste. И попробуем теперь скомпилировать и выполнить наше приложение. Для этого развернем меню Tools, Compile Java. После успешной компиляции выберем команду Run Java application.

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

Закроем теперь наше консольное окно и вернемся в наш текстовый редактор.

А теперь же попробуем отсортировать наш список в лексикографическом порядке. Т.е. по алфавиту. Для этого, сдвинемся скроллингом ниже, и там, где у нас описывается метод compareTo, введем новые строчки. Щелкнем здесь на клавише Enter, далее произведем проверку на значение, чему равняется вот эта переменная sort.

Напишем if, далее sort. Пусть на этот раз сравним его со значением 2, поскольку при 0 у нас идет сортировка по зарплате, так же, как и при значении sort равном 1. А при 2, пусть будет сортировка по алфавиту.

А теперь сравним две строки и для этого воспользуемся ключевым словом return и далее сравнением двух строк. Возьмем строку, в которой у нас находится имя, в нашем основном объекте. Далее точка. А теперь тип сравнения compareTo, который есть в классе String, имя из второго объекта, из объекта e. Поэтому напишем e точка name. Закроем скобку. Точка с запятой.

Ну и, заодно можем организовать сортировку в обратном порядке. Для этого выделим вот эту строчку, чтобы много не писать. Далее правая кнопка мыши, Сору. Встанем сюда. Правая кнопка мыши и Paste. И здесь введем некие возможности, которые будут реализованы при значении переменной sort равной 3. И в этом случае, просто-напросто изменим знак, который будем возвращать при помощи retune. Для этого, конечно же, достаточно просто-напросто написать знак минус, вот в этом месте.

Теперь же, сдвинемся скроллингом вверх и скопируем вот эти несколько строчек. Выделим их.

Щелкнем правой кнопкой мыши, Сору. Вставим сюда. Правая кнопка мыши и Paste. Теперь значение, которому мы передаем методу setSort, пусть будет 2. Далее вставим здесь опять скопированные строки. Щелкнем правой кнопкой мыши и Paste. И значение, которое будем передавать в этом параметре setSort, пусть будет на этот раз, 3. Попробуем теперь скомпилировать и выполнить нашу программу. Для этого развернем меню Tools.

Далее Compile Java. Запустим наше приложение, активизировав команду Run Java Application. И вот, можно видеть, что в этих двух последних двух блоках произошла сортировка нашего списка по алфавиту, по возрастанию в одном случае и по убыванию в другом случае.

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

Закроем наше консольное окно и мы вернулись в наш обычный текстовый редактор. Сдвинемся скроллингом выше. Для того чтобы все-таки убедиться, что у нас все сортировки работают правильно, изменим наши зарплаты. Ну, пусть, например, у сотрудника Haug зарплата будет не 50, а 150000.

Теперь скомпилируем нашу программу. Все прошло успешно. Теперь запустим ее на выполнение. И вот, теперь можно видеть, что если вот в этом блоке у нас сортировка идет по возрастанию зарплаты, в следующем блоке идет сортировка по убыванию зарплат, то в следующем блоке идет сортировка по алфавиту, по возрастанию. А в последнем блоке идет та же самая сортировка по алфавиту, но уже по убыванию. Закроем теперь наше консольное окно. Щелкнем вот на этом крестике и вернемся в наш обычный текстовый редактор.

Создание интерфейсаК оглавлению

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

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

Далее тип возвращаемого значения int. И далее название нашего метода compareTo, поскольку мы хотим использовать тот же самый метод для нашего интерфейса. Далее скобки и тип передаваемого параметра. Тип у нас будет Object.

И далее его имя. Пусть будет имя other. Закроем скобку, и далее точка с запятой. Кроме этого, предъявим еще одно требование к нашему классу, для того чтобы наши требования были немножко отличны от требований интерфейса Comparable. В частности потребуем, чтобы у нашего класса был метод getName, для того чтобы мы потом это имя могли вывести на консольное окно.

Поэтому напишем public. Далее тип возвращаемого значения. Если мы хотим getName, то, тип должен быть String, и далее название этого метода getName. Тип передаваемого параметра здесь не должен быть указан, и далее точка с запятой. Мы взяли getName, чтобы новый метод не писать в нашем классе Employee, а так, и getName, и compareTo у нас уже готовы. Теперь создадим непосредственно класс, реализовывающий те действия, которые мы хотим совершить для классов, поддерживающих вот этот интерфейс My. Поэтому щелкнем здесь на кнопку Enter и далее введем новый класс, class и далее имя для этого класса, например, My_class.

Далее Enter, фигурные скобки, внутри которых как раз и напишем наши строчки кода. А именно, для начала создадим метод, при помощи которого можно будет определять максимальный элемент в массиве. Для этого, как всегда напишем public, для того чтобы этот метод был открыт. И далее укажем слово static, для того чтобы этот метод принадлежал именно данному классу, а не какому-либо из его создаваемых объектов. Static,

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

для общности. Далее укажем квадратные скобки, для того чтобы подчеркнуть, что это массив. И имя этого массива, пусть будет ar. Теперь, внутри фигурных скобок нам нужно указать строчки кода, которые и будут определять максимальный элемент массива. Для начала зададим int, переменную целого типа. Пусть это будет i, которую проинициализируем 0, далее точка с запятой. А теперь введем цикл for, при помощи которого переберем все элементы, сравнивания их по одному и выберем максимальный элемент.

Поэтому напишем for, скобка, введем переменную цикла. Она, конечно же, будет целого типа. Назовем ее j, увеличиваться будет от 0 до максимального элемента массива. Мы должны перебрать весь массив. Поэтому j должно быть меньше, чем длина нашего массива. Поэтому ar, точка и длина массива будет ключевое слово length.

Далее точка с запятой и, конечно же, j++, для того чтобы на каждом шагу у нас эта переменная увеличилась на единицу. И теперь нам нужно указать, как мы будем действовать внутри нашего массива. Внутри нашего массива, нам нужно сравнить два объекта, которые у нас есть. А именно, объект с номером i и объект с номером j из массива ar.

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

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

Теперь проведем сравнение этих двух объектов. Поэтому напишем if, скобка. Сравнение у нас должно произойти таким образом. Х1, точка, далее используем вот этот метод compareTo.

Далее скобка и второй объект х2. Закроем скобку, больше 0. И, если это верно, тогда нам нужно поменять местами i и j, т.е. присвоить i значение j. Точка с запятой. Теперь, после того, как мы проведем весь этот цикл, нам нужно возвратить значение i, которое получится после прокрутки этого цикла. Поэтому напишем return и значение i. Точка с запятой.

При помощи вот этого метода мы уже сможем узнать номер максимального элемента. Теперь попробуем использовать этот класс. Сначала нам нужно сдвинуться скроллингом вниз и сделать так, чтобы наш класс Employee поддерживал интерфейс My. Для этого, наряду с интерфейсом Comparable добавим интерфейс My, который можно добавить просто через запятую. Запятая и далее My. Теперь мы объявили, что наш класс Employee обеспечивает интерфейс Comparable и интерфейс My,

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

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

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

И далее напишем так. Имя нашего класса, который мы создали My_class. Далее точка и метод, который у нас есть. А именно метод max. Мах, скобка параметр, который мы передаем. Передавать мы должны массив. А массив у нас staff, сотрудники. Поэтому напишем staff, закроем скобки, точка с запятой.

Использование разных критериев в интерфейсеК оглавлению

Закроем это окно, и наряду с элементом, у которого минимальная зарплата, выведем элемент с максимальной зарплатой. Предварительно напишем внутри кавычек, что мы выводим, а именно, напишем salary min.

И далее, тире. Теперь скопируем вот эти две строчки. Выделим их. Правая кнопка мыши, Сору. Вставим сюда.

Правая кнопка мыши, Paste. Вместо 0 напишем 1, что будет означать сортировку тоже по зарплате, но в другую сторону. И в этом случае мы получим уже не минимальную, а максимальную зарплату. Поэтому напишем здесь max.

Теперь скомпилируем программу и запустим. Для этого Tools, Compile Java. Далее Tools и Run Java Application, и можно увидеть, что у нас получилось. Минимальная зарплата, как мы видим, у объекта с номером 0, 35 000, а максимальная - у объекта с номером 2, 150 000.

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

И теперь, критерий, по которому мы будем сортировать, 2 и 3. А в качестве сопроводительного текста, напишем, не salary_min, а name_min и name_max.

Далее скомпилируем и запустим. Tools, Compile Java. Далее Tools и Run Java Application.

И можно увидеть, что получилось. А именно, самым минимальным по критерию имени, у нас будет объект с номером 3, в нашем случае последний объект Адамс. Он начинается на букву "A". А последним по сортировке имени, у нас будет объект с номером 0, это Тейлор. Буква "T" в конце алфавита. Закроем окно и вернемся в наш текстовый редактор.

Обратим теперь внимание на одно обстоятельство. Тот метод, который мы застолбили в нашем интерфейсе My, а именно метод getName, мы пока еще нигде не использовали. Попробуем исправить этот недостаток. Cделаем так, чтобы мы могли прямо выпечатать то имя, которое есть у нашего максимального, по какому-либо из критериев, элемента.

Для этого, в класс My_class, добавим еще один метод, при помощи которого и будет это делать. Зададим этот метод следующим образом. Public, затем тип возвращаемого значения, до которого укажем его статичность, static, для того чтобы этот метод принадлежал именно данному классу. Теперь тип возвращаемого значения. Поскольку мы хотим прямо вывести на печать имя и сделать это при помощи того же метода, то возвращаемого значения не будет. Поэтому напишем void.

Далее имя нашего метода. Пусть это будет print_max. Затем, в скобках тип и передаваемое значение. Напишем, как в предыдущем случае, Object.

Поскольку это массив, нам нужны квадратные скобки. И далее имя этого массива, ar. Далее фигурные скобки, внутри которых напишем так. Cначала определим номер этого максимального элемента int. Этот номер будет типа int. Далее i, знак равенства, можем воспользоваться методом, который у нас находится рядом, и который это у нас уже высчитывает. Поэтому напишем max.

И далее, внутри скобок передаем этому методу max, массив ar. Закроем скобку, точка с запятой. Теперь у нас i уже есть. Осталось получить наш объект с номером i. Для этого проще всего воспользоваться вот такой строчкой. Скопируем ее. Правая кнопка мыши, Сору.

Встанем сюда. Правая кнопка мыши, Paste. И теперь уже, при помощи метода getName, который у нас есть в интерфейсе My, напишем при помощи метода println следующую строчку. Метода Println лучше всего скопировать. Правая кнопка мыши, Сору. Теперь встанем сюда. Правая кнопка мыши, Paste.

И далее, внутри скобок распечатаем сам номер i. Далее пробел, после которого напечатаем имя нашего объекта. Объект у нас будет х1. Точка. И далее его метод getName, который мы вполне можем использовать.

У getName никаких передаваемых параметров нет, поэтому просто открывающие и закрывающие скобки. Еще одна закрывающая скобка и точка с запятой. Теперь же используем этот метод в нашей программе. Для этого чуть-чуть сдвинемся выше. Встанем сюда. Щелкнем на Enter и далее напишем так.

My_class, далее точка. И на этот раз используем вот этот метод print_ max. В скобках укажем передаваемый массив, который у нас является массивом сотрудников staff. Закроем скобку, точка с запятой.

Теперь, скопируем эту строчку. Выделим ее. Правая кнопка мыши, Сору. Теперь встанем сюда. Правая кнопка мыши, Paste. И, после последнего изменения критерия, тоже правая кнопка мыши и Paste.

Теперь, скомпилируем и запустим наше приложение. Для этого Tools, Compile Java. Компиляция прошла успешно. Поэтому Tools и Run Java Application.

И теперь можно видеть результат выполнения нашей программы. Мы видим не только номер элемента, который является максимальным по каким-либо критериям, но и его фамилию. В частности, минимальная зарплата у сотрудников с индексом 0. Это у нас Тейлор. У него зарплата всего 35 000.

Максимальная зарплата у сотрудника с индексом 2. Это Haug. У него зарплата 150 000, достаточно много по сравнению с остальными сотрудниками. Далее, по алфавиту в начале списка, у нас находится фамилия Адамс, которая начинается на букву "A".

А по алфавиту в конце списка находится у нас фамилия Тейлор, на букву "T", что тоже согласуется с нашими представлениями. Закроем теперь наше консольное окно и вернемся в наш текстовый редактор.

Обратный вызов (callback). Вызов таймераК оглавлению

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

Сохраним этот текст в каком-либо файле. Для этого щелкнем на кнопку сохранения. Выберем для него отдельную папку. Пусть это будет папка mу21.

Щелкнем на кнопку сохранения, Save. Зададим имя для нашего документа. Оно должно совпадать с именем нашего класса. Поэтому пусть будет Му21, и щелкнем на кнопке Save, сохранить.

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

Для этого нам придется использовать класс Timer, который у нас находится в пакете javax.swing. Для начала укажем в нашем приложении те пакеты, которые мы хотим использовать. Для этого используем ключевое слово import,

и далее таким образом, java, точка, awt, точка, звездочка, все классы этого пакета. Далее import, опять java, точка, awt, точка event,

чтобы мы могли использовать события в нашем приложении. Точка, звездочка, точка с запятой. А теперь укажем класс java.util. Import, далее java, точка, util, точка, звездочка, точка с запятой. Теперь еще один класс javax.swing.

Import, javax, точка, swing, точка, звездочка, точка с запятой.

И, напоследок, попробуем указать еще один класс, класс Timer, непосредственным образом, т.е. напишем таким образом. Javax, точка swing, точка и Timer, точка с запятой.

Появляется вопрос, зачем мы вот этот класс указали явно, хотя он подразумевается в предыдущей строке, в пакете javax.swing.? Дело в том, что класс Timer существует и внутри пакета java.util.

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

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

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

В общем, если кратко резюмировать все это, можно сказать, что для этого механизма в таймере есть специальный интерфейс ActionListener, который находится в пакете java.awt.event. Вот, как выглядит этот интерфейс. По истечению заданного интервала времени, таймер будет вызывать вот этот метод actionPerformed, который находится внутри интерфейса ActionListener.

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

И далее нам нужно указать, что этот класс обязательно должен поддерживать вот этот интерфейс. Для этого нужно использовать ключевое слово implements.

И далее укажем вот этот интерфейс ActionListener.

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

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

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

Включим текущую дату. Для этого создадим объект типа Date. Пусть он называется now и равняется текущей дате. Поэтому new Date без параметров. Закроем скобки, далее точка с запятой.

Теперь выведем на консольное окно это текущее значение времени. Для этого воспользуемся println. Скопируем вот этот println. Выделим его. Правая кнопка мыши, Сору. Вставим сюда. Правая кнопка мыши, Paste. Теперь напишем кавычки. И далее Time is, далее пробел и закроем кавычки. Знак плюса и далее выведем текущее время, которое у нас находится в now. Закроем скобку, точка с запятой.

Обратный вызов. Выполнение действий с определенной периодичностьюК оглавлению

далее назовем этот объект как-нибудь. Присвоим ему имя listener, знак равенства, и создадим новый объект этого класса. New, в качестве класса возьмем класс TimePrinter, который у нас поддерживает этот интерфейс.

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

Для этого напишем Timer, создадим конкретный экземпляр этого класса. Пусть это будет t, равное new. Теперь нам нужно вызвать конструктор этого класса. Timer,

в скобках укажем интервал, который мы хотим задавать. Возьмем 5 сек. Поэтому укажем 5 тысяч, поскольку счет идет в милли секундах, составляя тысячную долю секунды, далее запятая. И нужно указать этот объект listener, который мы только что создали.

Listener, закроем скобку, точка с запятой. И, все что нам еще осталось сделать, это запустить наш таймер. Для этого, у таймера есть специальный метод start. Поэтому t, точка Start. Далее скобки, точка с запятой.

Мы можем уже скомпилировать и запустить наше приложение. Для этого Tools, Compile Java. Компиляция прошла успешно. Теперь Tools и Run Java Application. Вот, мы можем видеть результат выполнения нашей программы. Правда, никакого времени на нашем консольном экране нет.

В чем же дело? Дело в том, что наша программа выполняется быстрее, чем пройдут первые 5 сек. с начала старта и поэтому, вызов этого события просто не происходит. Приложение просто прекращает свою работу. Поэтому закроем наше приложение.

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

После этого напишем таким образом. JOptionPane.showMessageDialog.

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

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

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

Именно после этой строчки, компьютер прекратит выполнение нашего приложения. Попробуем теперь опять скомпилировать и запустить наше приложение. Для этого Tools, Compile Java. Компиляция прошла успешно. Поэтому Tools и Run Java Application.

И вот, можно видеть результат выполнения нашей программы.

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

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

Попробуем теперь несколько видоизменить нашу программу, для того чтобы она выводила вот эту надпись с датой, не бесконечное число раз, пока мы не щелкнем на нашем диалоговом окне, на кнопку ОК, а определенное количество раз, например, 5 раз. Для этого введем в наш класс TimePrinter некий счетчик, который должен быть, статическим. Поэтому напишем таким образом, static.

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

И далее, на каждом шагу будем увеличивать его значение. Введем здесь i++, увеличение на единицу. И далее проведем проверку. If, и при i, равное 3, прекратим выполнение нашей программы.

Для этого нам нужно указать вот этот System.exit. И далее код выхода 0. Закроем скобку, точка с запятой. Попробуем теперь опять скомпилировать и выполнить нашу программу. Для этого Tools, Compile Java.

В процессе компиляции компилятор обнаружил у нас ошибку. Вместо знака сравнения, мы написали простое равенство. Поэтому переключимся в редактор и исправим эту ошибку. Поставим здесь второй знак равенства, что будет означать сравнение. Далее Tools, Compile Java. На этот раз все успешно, поэтому Tools и Run Java Application.

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

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

Клонирование простых объектовК оглавлению

Чтобы рассмотреть эти вопросы, рассмотрим вот этот шаблон приложения, в котором у нас создан класс сотрудников, класс Employee, в котором у нас два поля, поле имени и зарплаты. Реализован метод, при помощи которого можно повысить зарплату на какое-то количество процентов, а также реализован метод toString, который выводит текущее состояние этого объекта.

В основном, в классе реализован просто метод main, при помощи которого мы выводим на наше стандартное консольное окно простейшую надпись It is program My, а также создается один экземпляр нашего класса Employee с неким именем и с какой-то зарплатой.

Для того чтобы начать работу, сохраним этот листинг в файл. Для этого щелкнем на значке сохранения, выберем новую папку для этого проекта. Щелкнем на кнопку создания новой папки. Назовем эту новую папку, пусть будет My22. Щелкнем на кнопку Open и введем имя для нашего приложения. Му22, как мы помним, оно должно совпадать с именем нашего класса.

Щелкнем на кнопку Save. Для начала попробуем сделать первое, что может придти в голову, когда мы хотим создать копию какого-либо объекта. Попробуем создать еще один экземпляр этого класса Employee. Назовем этот новый объект просто сору, далее знак равенства. И первое, что приходит в голову то, это присвоить этой копии значение оригинала.

Original, точка с запятой. Попробуем распечатать эти два объекта, объект copy и объект Original, для этого выделим вот эту строчку. Далее правая кнопка мыши, Сору. Вставим сюда. Правая кнопка мыши, Paste. Далее напишем, что это оригинал.

Знак равенства, плюс Original, точка. Воспользуемся методом toString, который у нас есть в нашем классе. Как мы помним, он выводит все поля этого объекта. Далее закроем скобку, точка с запятой.

Теперь, выведем и второй наш объект, объект сору. Для этого выделим эту строчку целиком. Правая кнопка мыши, Сору. Вставим сюда. Правая кнопка мыши, Paste. Теперь изменим, вместо Original, это будет сору, копия. И то же самое вот в этом месте. Это у нас объект сору. Теперь же попробуем скомпилировать и запустить наше приложение.

Для этого Tools, Compile Java. Вроде все в порядке. Далее Tools и Run Java Application. Можно видеть, что эти два объекта идентичны. И именно их зарплаты совпадают. Закроем это окно и попробуем проделать один фокус. Попробуем что-нибудь изменить в каком-либо из объектов. Например, вот в этом объекте сору, увеличим его зарплату. Для этого, как мы помним, мы можем воспользоваться вот этим методом raiseSalary. Поэтому сору,

точка, raiseSalary. И повысим зарплату, например, на 10%. Закроем скобку, точка с запятой. Теперь опять попробуем выполнить это приложение. Tools, Compile Java. Далее Tools, Run Java Application.

Можно видеть, к чему привела работа нашей программы. Как мы видим, и в объекте cору, и в объекте original, в обоих объектах, зарплата повысилась на 10%. Это связано с тем, что это на самом деле, не два различных объекта, а оба переменные, переменная original, и переменная cору, ссылаются на один и тот же объект в памяти нашего компьютера.

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

Возможно, мы просто получим все поля из нашего объекта original, а потом по одному, присвоим их к нашему объекту сору. Создадим его, на основе этих данных.

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

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

Далее скобки. На самом деле это не так, поскольку метода clone у класса Employee, которому принадлежит наш объект original, нет. Он есть только у класса Object. Поэтому тут необходимо провести приведение типа. Поэтому напишем здесь Employee.

Хотя, вот в таком виде, эта строчка тоже не работает. Дело в том, что метод clone хоть и существует у класса Object, он является защищенным методом класса Protected. И поэтому его такое прямое использование не допустимо. Его можно использовать только внутри класса Employee, как наследника класса Object. Поэтому нам придется специально перегружать метод clone в класс Employee. Для этого щелкнем здесь на Enter и далее напишем public.

Этот метод должен быть доступным. Далее тип возвращаемого значения Object, метод, о котором мы говорили, метод clone и затем скобки. Внутри фигурных скобок напишем наш код. Щелкнем на Enter и далее напишем класс Employee, имя этого объекта. Пусть это будет clone, знак равенства, и приведение типа к типу Employee.

Закроем скобку. И далее вызов родительского метода clone. Для этого нам понадобится ключевое слово super. Super, точка clone, далее скобки и точка с запятой. Теперь нам надо возвратить вот это значение cloned, return cloned.

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

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

Теперь нам осталось учесть еще одно обстоятельство. Нам нужно обеспечить перехват исключительной ситуации, которая возникает при использовании этого метода. Дело в том, что метод clone класса Object угрожает возбудить исключительную ситуацию, которая происходит, если этот метод будет вызван из объекта, класс которого не реализует вот этот интерфейс Cloneable.

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

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

Если у нас возникла вот такая исключительная ситуация, тогда возвратим нулевое значение.

Напишем return null. Точка с запятой, закроем фигурные скобки. После того, как мы проделали все эти необходимые операции, попробуем теперь скомпилировать и запустить наше приложение. Для этого Tools, Compile Java.

Далее Tools и Run Java Application. И на этот раз, как мы видим, все у нас прошло достаточно гладко. Мы получили то, что мы хотели, вот эти два объекта. Они разные, поскольку при повышении зарплаты у второго нашего объекта, он изменился и не затронул первый объект. Он остался без изменений. Закроем теперь наше консольное окно и вернемся в наш текстовый редактор.

Клонирование объектов, содержащих ссылки на другие объектыК оглавлению

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

Для этого напишем так, private, String, name, и точка с запятой. Теперь определим конструктор для этого класса, public, далее Friend.

Далее скобка, внутри которой напишем String и переменная n. Закроем скобку. Теперь определим, проведем необходимые действия. Напишем name, равное n, точка с запятой. После того, как мы задали конструктор, зададим еще один метод, при помощи которого сможем изменять это имя. Для этого опять напишем public,

далее setName, в скобках укажем тип передаваемого параметра String n. Закроем скобку. И внутри фигурных скобок, напишем name, и присвоим ему значение n. Теперь, для того чтобы мы могли получить еще и состояние нашего класса Friend и его объектов, нарисуем такой же метод toString, который у нас находится вот в этом месте.

Проще всего скопировать вот эти несколько строчек. Выделим их. Правая кнопка мыши, Сору. Вставим сюда. Правая кнопка мыши и Paste. Здесь, вместо Employee надо написать Friend, и, конечно же, зарплату salary надо убрать. Для этого выделим и удалим.

Теперь, после того, как мы создали вот этот класс друзей, класс Friend, зададим в нашем классе сотрудников, одно поле для друга. Для этого сдвинемся скроллингом выше и напишем таким образом, private и далее тип этого объекта Friend, и имя переменной, в которой будем его хранить. Пусть это будет name1,

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

И с помощью конструктора Friend создадим новый объект, значение которого и присвоим вот этому объекту name1. Поэтому напишем так, name1, знак равенства, new, далее Friend, вызов конструктора, и внутри скобок, в качестве параметра, передадим вот это имя n1.

Закроем скобку, точка с запятой. Теперь, наряду с возможностью изменения зарплаты, попробуем сделать так, чтобы у нашего класса сотрудников можно было изменить и имя его друга. Поэтому напишем тип доступа, public. Возвращаемого значения не будет, поэтому напишем void и далее имя метода, setFriend.

Далее скобка и имя n1, которое будет типа String. Закроем скобку. В фигурных скобках вызовем соответствующий метод из нашего класса Friend. Поэтому напишем так, name1, точка, setName,

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

с инициалами J.L. Закроем кавычки. Теперь, после создания копии, попробуем изменить у копии вот эту фамилию друга. Для этого воспользуемся методом setFriend, который есть у класса Employee. Поэтому напишем сору,

точка, далее setFriend, скобки, внутри кавычек, напишем новую фамилию. Например, пусть это будет Murat, с инициалами T.G. Закроем кавычки, скобку, точка с запятой.

Теперь, для того чтобы мы могли видеть полную информацию о наших объектах, нам нужно изменить наш метод toString из класса Employee, для того чтобы там отображался этот товарищ. Поэтому сдвинемся скроллингом ниже и там, где у нас находится метод toString, добавим вот такой текст. Напишем плюс и далее имя нашей переменной name1, связанной с другом, далее точка и вызов функции String,

которую, как мы помним, мы реализовали в классе Friend. Теперь скомпилируем наше приложение. Для этого Tools, Compile Java. Как мы видим, компилятор выдал нам две ошибки, но на самом деле это одна ошибка. Дело в том, что у нас в определении метода setName, не хватает ключевого слова void, что будет означать, что возвращаемого значения у нас нет. А так, тип возвращаемого значения мы не указали.

Поэтому переключимся на листинг нашей программы, сдвинемся скроллингом вниз и исправим нашу ошибку. Вот между public и именем метода setName, напишем ключевое слово void, что будет означать, что возвращаемого значения у этого метода вообще нет. Далее Tools, Compile Java. Теперь все нормально. Далее Tools и Run Java Application.

И вот, можно видеть результат выполнения нашей программы. Мы задали два объекта, изменили зарплату. Как мы видим, при изменении зарплаты его величина у первого нашего объекта осталась той же самой, а у второго, изменилась. А вот с его другом, ситуация несколько другая. При изменении фамилии друга, эта фамилия изменилась внутри нашего исходного объекта, объекта оригинала. Здесь произошла приблизительно та же самая ситуация, как ранее. А именно, эти два объекта, это на самом деле один и тот же объект, две ссылки на один и тот же экземпляр объекта.

Поэтому нам придется опять что-то изменять в нашей программе. Закроем наше консольное окно. Вернемся в наш текстовый редактор и попробуем на этот раз что-либо придумать. Нам придется сделать класс Friend поддерживающим интерфейс Cloneable. Далее, для создания копии использовать глубокое клонирование нашего класса Employee. Для того чтобы класс Friend поддерживал интерфейс Cloneable, напишем таким образом. Implements,

и далее Cloneable. Далее нам надо написать метод clone. Чтобы много не писать, сдвинемся скроллингом вверх и скопируем этот метод, который есть у класса Employee. Выделим вот эти строчки. Далее правая кнопка мыши, Сору.

Сдвинемся теперь скроллингом вниз и введем здесь Enter. Далее правая кнопка мыши и Paste. Нам придется вместо класса Employee, написать здесь класс Friend. И, конечно же, приведение тоже к классу Friend.

Исправим и имя Cloneable. Тут мы пропустили букву "e" и, в методе clone, который есть в классе Employee, нам нужно добавить такую строку. Щелкнем на кнопку Enter и далее, в объекте clone, нам надо переделать его поле name1. Поэтому напишем cloned, точка, name1, т.е. имя друга, знак равенства и тоже создадим клон объекта типа Friend. Поэтому приведем его к типу Friend.

Закроем скобку. Далее name1, точка и его метод clone. Далее скобки, точка с запятой. Теперь попробуем скомпилировать и запустить наше приложение. Для этого Tools, далее Compile Java.

Компиляция прошла успешно, теперь Tools и Run Java Application. И вот, теперь можно увидеть, что у нас получилось. Мы смогли изменить не только после копирования зарплату нашей копии, но и имя его друга. Причем так, чтобы это все не затронуло основной наш оригинал. Закроем теперь наше консольное окно и вернемся в наш текстовый редактор.

Внутренние классы. СозданиеК оглавлению

Для того чтобы подробнее рассмотреть эти вопросы, рассмотрим шаблон приложения, который, как обычно, содержит всего несколько строк, один метод main, с которого выполняется обычно консольная программа и вывод на это консольное окно стандартной строки "Это моя программа".

Теперь сохраним этот листинг в файле. Для этого щелкнем на кнопке сохранения. Создадим для него отдельную папку. Щелкнем на кнопке создания папки. Пусть она называется my23. Щелкнем на кнопке Open. Далее введем имя для нашего файла. Пусть это будет My23, и щелкнем на кнопке Save.

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

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

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

Ну, первое что в этом классе обязательно должно быть, это поле balance, в котором будем хранить текущее состояние нашего счета. Поэтому напишем следующим образом. Оно, конечно же, должно быть private, для того чтобы оно было видно только внутри нашего класса. Далее тип этого поля, double и далее balance, имя этого поля, этой переменной. Точка с запятой.

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

Далее откроем скобку. Ну, конечно же, в начале, при помощи конструктора мы должны задавать именно наш balance. Поэтому напишем таким образом, double и далее эта переменная. Пусть это будет b. Закроем скобку.

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

Следующий метод, который обязательно должен быть в этом классе, это метод start, который и непосредственно задает начало нашего процесса. Конечно же, он тоже должен быть типа public, открытым. Далее тип возвращаемого значения этим методом, void, поскольку возвращаемого значения тут не должно быть, и имя этого метода. Пусть это будет, конечно же, start.

Далее откроем скобку. И теперь нам нужно указать формальный передаваемый параметр, в качестве которого укажем процентную ставку. Эта величина, конечно же, должна быть типа double. Назовем эту переменную, например, rate. Далее закроем скобку, перевод строки, и введем фигурные скобки.

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

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

Поэтому напишем таким образом, private, для того чтобы доступ к этому классу был только изнутри. Из программы и классов, которые находятся вне этого класса, он не будет виден BankAccount. Далее, конечно же, ключевое слово class. Далее название нашего класса. Пусть будет InterestAdder.

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

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

Поэтому напишем таким образом, private. Конечно же, он должен быть с доступом private, для того чтобы он не был виден извне нашего класса. Далее тип этой переменной. Он, конечно же, должен быть double и далее имя этой переменной rate. Точка с запятой.

Теперь же, первое, что нам нужно сделать, это, конечно же, предусмотреть его конструктор. Поэтому напишем public. Далее имя этого конструктора, которое, конечно же, должно совпадать с именем класса. Поэтому напишем так, InterestAdder.

Далее откроем скобку, внутри которой нужно указать передаваемый параметр. В качестве передаваемого параметра, возьмем, конечно же, процентную вставку rate. Конечно же, она должна быть типа double. Введем для нее имя. Пусть это будет r. Закрыть скобку.

Далее введем фигурные скобки, внутри которых напишем просто-напросто rate равняется r. Т.е. при помощи конструктора, заполним поле rate соответствующим значением.

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

Это, конечно же, должен быть метод public. Далее тип возвращаемого значения, void. И далее имя этого метода. Пусть будет actionPerformed. Поскольку имя этого метода у нас жестко задано вот этим интерфейсом ActionListener. Он требует от нас определенного имени этого метода.

actionPerformed, далее откроем скобку и введем передаваемый параметр, который у нас должен быть типа ActionEvent и далее имя этой переменной event. Закроем скобку.

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

Внутренние классы. Пример реализацииК оглавлению

Равняется, и посчитаем его по такой формуле. balance умножить на rate, поскольку именно rate определяет у нас обновление нашего банковского счета, являясь процентной вставкой.

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

Вот, если сейчас присмотреться, то можно увидеть, что мы обратились к переменной balance, которая не является полем нашего класса InterestAdder, а является полем класса BankAccount, т.е. наружного класса по отношению к нашему внутреннему классу InterestAdder. Вот, эта переменная balance.

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

Теперь же просто-напросто обеспечим вывод на печать нашего текущего баланса. Но, для того чтобы все это у нас выглядело покрасивее, получим текущее форматирование, которое у нас есть на компьютере. Для этого напишем следующее, NumberFormat.

Далее имя этого объекта. Пусть это будет formatter, знак равнения и далее опять NumberFormat. Точка. И получим текущий формат getCurrencyInstance. Далее введем скобки. Точка с запятой.

Теперь, как раз и обеспечим вывод на печать. Для этого можно скопировать вот этот метод println, чтобы не писать его заново. Выделим его. Правая кнопка мыши, Сору. Встанем сюда. Правая кнопка мыши и Paste.

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

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

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

Поэтому напишем таким образом, ActionListener, имя нашего интерфейса. Далее имя этого объекта. Пусть будет adder. Далее равняется, new. Как обычно, нам нужно создать экземпляр этого класса.

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

Теперь создадим таймер. Для этого напишем Timer. Пусть это будет t равняется new и, во-первых, зададим ту частоту, с которой у нас будет изменяться наш банковский счет и вызываться все вот эти методы. Ну, пусть будет одна секунда. Для того чтобы задать одну секунду мы должны задать число 1000, поскольку измерение у нас, как обычно, идет в милли секундах. И далее должны передать вот этот объект adder. Закроем скобку. Точка с запятой.

Ну, и последнее, что нам необходимо, это запустить этот таймер. Для этого напишем t точка start. Далее введем скобки. Точка с запятой. Ну, в принципе у нас уже практически все готово, все наши классы окончательно сформировались. Единственное что нам нужно сделать, это заполнить наш основной метод main, чтобы создать объект класса BankAccount и начать выполнение программы.

Для этого щелкнем на клавише Enter. Далее введем имя нашего класса BankAccount. Далее переменная. Пусть она тоже будет account. Равняется, new. Далее вызов конструктора BankAccount и внутри скобок, нам нужно указать начальный капитал, который находится у нас на балансе.

Ну, пусть это будет, например, 100000. Закроем скобку. Точка с запятой. Теперь нам нужно задать начало нашего процесса. Для этого нам нужно использовать вот этот метод start,

поэтому напишем таким образом. Наш объект account, точка. Далее start. И в скобках, нам нужно указать процентную вставку, которую мы при этом должны использовать. Ну, не будем долго думать, возьмем 10%. Закроем скобку. Точка с запятой. И теперь нам нужно предусмотреть, чтобы наша программа не закрывалась сразу же, иначе, конечно же, у нас ничего не получится.

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

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

Теперь, конечно же, нам нужно предусмотреть выход из нашей программы, с нормальным кодом. Для этого напишем таким образом, System, точка. Далее exit и код выхода 0. Поскольку именно 0, это код выхода, нормальное завершение нашей программы.

Ну, а теперь, для того чтобы наша программа нормально работала, нам нужно при помощи директивы import указать нашему компилятору пакеты, которые мы хотим использовать в нашей программе. Поэтому щелкнем здесь на клавише Enter и в начале нашего листинга напишем так. import, далее класс java.awt.event. Точка звездочка. Точка с запятой. Это пакет, который отвечает за обработку сообщений.

Далее import. Следующий пакет java.text, в котором сконцентрированы все текстовые классы. Точка звездочка. Точка с запятой. И последний пакет, это java.swing. Напишем import java точка swing. Точка звездочка. Точка с запятой. Это последний пакет, который мы используем и который обеспечивает работу с панелями в нашем приложении.

Исправим сейчас те ошибки, которые мы допустили. Вот тут точка, конечно же, не нужна. И, кроме того, awt пишется через w. Кроме этого, пакет swing у нас находится внутри пакета javax, и теперь попробуем скомпилировать и запустить наше приложение.

Для этого развернем меню Tools. Далее Compile Java. Вот компьютер все-таки нам выдал несколько ошибок, первая из которых, это просто-напросто, мы при задании нового таймера забыли указать здесь имя конструктора Timer. Вторая ошибка это то же самое. Повторение предыдущей ошибки. Ну и кроме прочего, вот в этой строчке, мы в конструкторе InterestAdder пропустили букву t.

Поэтому переключимся на наш листинг, и исправим эти ошибки. Вот, там, где задаем таймер, укажем слово Timer. Далее исправим ошибку вот в этой строчке. Вставим недостающую букву t. И теперь попробуем еще раз скомпилировать наше приложение. Для этого в меню Tools вновь выберем команду Compile Java. На этот раз все прошло достаточно гладко. Теперь выберем команду Run Java Application. Запустим наше приложение.

И вот, можно видеть результат выполнения нашей программы. Каждую секунду выводится очередное сообщение об изменении нашего банковского счета на 10%. Щелкнем теперь на кнопку ОК, и закроем наше консольное окно. Вот, при этом работа нашего приложения прекратилась и, щелкнув на крестике, выйдем в наш текстовый редактор.

Локальные и безымянные классыК оглавлению

Именно в таком случае, весь этот класс можно определить прямо внутри этого метода Start, а не внутри класса BankAccount, как здесь сделано. Ну, сдвинемся при помощи ползунка ниже, например, выделим вот этот класс целиком, начиная с первой строчки и начиная до закрывающих фигурных скобок. Теперь правая кнопка мыши и Cut, вырезать.

Теперь же, весь этот блок вставим вот в это место. Внутри метода Start, до начала всех остальных операции. Для этого щелкнем на клавише Enter, чтобы освободить его место. Далее правая кнопка мыши и Paste, вставить. И вот, можно видеть теперь, как выглядит наша программа.

Надо, единственно учесть одно обстоятельство, а именно, что вот такие внутренние классы не требуют модификатора доступа. Вот это ключевое слово private в данном случае лишнее. Поэтому сотрем его. Теперь же попробуем скомпилировать и посмотреть, что у нас получается в этом случае. Для этого щелкнем на пункте Tools. Далее Compile Java. Компиляция прошла успешно. Теперь Tools, Run Java Application. Запустим наше приложение.

И вот, можно увидеть, что у нас получилось. А именно, опять-таки последовательно через одну секунду, появляются наши балансы, с учетом процентной вставки. Щелкнем теперь на кнопку ОК. Вот мы прекратили выполнение нашего приложения. Закроем теперь консольное окно и выйдем в наш стандартный текстовый редактор.

Отметим теперь, что локальные классы имеют очень существенное преимущество. Они полностью скрыты от внешнего мира. Даже от класса BankAccount. Поскольку они в нашем конкретном случае определены внутри вот этого метода Start. И только внутри него их и можно применить.

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

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

Вот они уже удалились. Теперь, конечно же, нам немножко надо переделать вот эту строчку, где создавался новый экземпляр этого класса. Конечно же, здесь процентная ставка rate уже лишняя. Кроме этого, для того чтобы, тем не менее, вот этот класс interest и его внутренние методы имели доступ к вот этой внешней переменной rate, ее здесь нужно объявить, как Final.

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

Правда, конечно же, локальные методы класса, как мы сказали, могут ссылаться только на локальные переменные, которые объявлены вместе с ключевым словом Final, которые являются терминальными. И поэтому они не могут быть, конечно же, модифицированными. Что гарантирует, что такая локальная переменная и ее rate, которая создана внутри локального класса, всегда будут иметь одно и то же значение.

Скомпилируем теперь это приложение. Для этого Tools, Compile Java. Далее Tools? Ran Java Application, поскольку компиляция прошла успешно. И вот можно видеть, результат выполнения нашей программы. В принципе, он абсолютно совпадает с тем, что мы видели ранее. Приостановим наше приложение.

Щелкнем на кнопку ОК. И выйдем в наш текстовый редактор. Закроем для этого вот это консольное окно.

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

Для этого скопируем ее, правая кнопка мыши и Сору. Затем ее удалим. Встанем в начало до описания нашего класса. А теперь правая кнопка мыши и Paste.

И теперь сделаем такую модификацию. После слова new мы вот этот InterestAdder вообще уберем, точно так же как и определение нового класса InterestAdder вместе со ссылкой implements, которой мы ссылаем на интерфейс.

И далее прямо, непосредственным образом, определим этот объект adder, как объект класса ActionListener, чтобы у него было хоть какое-то имя. И затем открывающие и закрывающие скобки.

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

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

Как мы видим, на основе вот этого примера, который мы здесь выписали, синтаксис такого безымянного класса выглядит, как задание имени супертипа. Далее сам объект и при помощи стандартного оператора new и самого определения супертипа, внутри круглых скобок можем вписать все те параметры, которые необходимы для создания объекта.

Далее, внутри фигурных скобок выписывается уже непосредственно все те операторы, которые и должны выполнять работу этого класса.

В принципе, вот этот супертип, который мы использовали ActionListener, может быть интерфейсом, но может быть и каким-либо классом. Тогда, все то, что мы здесь написали, просто-напросто будет расширять этот класс. Будет его подклассом. Попробуем теперь убедиться, что, несмотря на все наши ухищрения, эта программа, тем не менее, работает. Вот такое задание внутреннего класса, без имени, совершенно правомочно. Для этого Tools. Далее Compile Java.

Компиляция, как мы видим, прошла успешно. Теперь Tools, Ran Java Application. И можно видеть, что у нас опять-таки последовательно начинают появляться строки баланса. Т.е. наша программа вполне исправно работает. Закроем теперь наше приложение. Щелкнем на кнопку ОК. Как мы видим, программа приостановила свою работу. Теперь же можем закрыть это консольное окно. Щелкнем вот на этом крестике и выйдем в наш обычный текстовый редактор.

Пример без использования статических внутренних классовК оглавлению

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

Введем новую папку. Для этого щелкнем на значке создания новой папки и введем для этой папки имя My24. Щелкнем на кнопку Open. И введем имя для нашего приложения. Как мы помним, оно должно совпадать с нашим классом, в котором есть метод My. Поэтому напишем так. My24, большие и маленькие буквы, конечно же, имею значение,

и щелкнем на кнопку Save, сохранить.

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

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

Знак равенства, new. И далее создадим этот массив. Для этого double, и далее нам нужно указать количество этих чисел, которые мы хотим использовать. Например, возьмем 25 чисел. Закрыть скобку. Точка с запятой.

Теперь заполним эти числа какими-либо значениями, как мы сказали выше, случайным образом. Для этого напишем оператор цикла for. Далее переменная цикла типа integer. Пусть это будет i, равняется от 0 до i меньше, чем размер нашего массива, который определяется при помощи d точка length. Точка с запятой.

И далее, на каждой итерации увеличим i на единицу, и далее ++. Закрыть скобку. Далее напишем то, что должно происходить внутри этого оператора цикла. А именно, присваивание массиву d под индексом i, i-тому элементу этого массива, присвоим следующее значение.

Пусть это будет 100, умножить, далее math Точка random. Это у нас генератор случайных чисел. Далее скобки. Точка с запятой.

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

Теперь встанем сюда. Правая кнопка мыши и Paste. И далее вставим сюда вот этот println. Выделим. Правая кнопка мыши. Сору. Вставим сюда. Правая кнопка мыши, Paste. И внутри нее напишем таким образом: i распечатаем номер элемента массива. Далее просто-напросто пробел. Далее плюс и само число d с индексом i.

Закрыть скобку. Точка с запятой. Запустим теперь наше приложение и посмотрим, как все это работает, чтобы проконтролировать то, что мы уже создали. Для этого Tools, Compile Java. Пока все нормально. Компиляция прошла успешно. Далее Tools, Run Java Application.

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

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

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

Конечно же, они оба должны быть типа double. Далее, пусть минимальный элемент так и называется min, долго думать не будем. Равняется. И для начала присвоим ему элемент массива с номером 0. Точка с запятой.

Ну и, аналогичную строчку для максимального элемента: double, max. Равняется. И элемент массива d с номером опять 0. Точка с запятой.

Ну, теперь введем оператор IF внутри цикла же IF. Если вот этот min. вот это число больше, чем элемент i в нашем массиве d с индексом i, в этом случае этому элементу min. присвоим значение, которое находится в i-том элементе массива. d с индексом i. Точка с запятой.

Теперь же, практически то же самое нам надо сделать с элементом max. IF, далее max. меньше, чем элемент d с номером i. Закрыть скобку. Если это верно, тогда элементу max. присвоим опять-таки значение d с индексом i. Точка с запятой.

Ну, теперь, конечно же, неплохо было бы этот минимальный и максимальный элементы распечатать. Для этого щелкнем на клавише Enter и далее скопируем вот этот println. Выделим. Правая кнопка мыши. Сору. Встанем сюда. Правая кнопка мыши и Paste. И напишем таким образом. Внутри кавычек напишем min, далее равняется. Закрыть кавычки. Плюс.

И само значение min. Закрыть скобку. Точка с запятой. То же самое нам нужно сделать для максимального элемента. Поэтому правая кнопка мыши и Paste. Вставим println. Он у нас находится в буфере обмена пока. Опять кавычки. Max. Равняется. Далее опять кавычки. Плюс и то число, которое у нас находится в переменной max. Закрыть скобку. Точка с запятой.

Запустим теперь наше приложение. Для этого Tools. Далее Compile Java. Скомпилируем сначала. Теперь наше приложение скомпилировано. Теперь Tools, Run Java Application. Запустим наше приложение. И можно видеть результат выполнения нашей программы. Сначала распечатается весь наш массив, а затем минимальный элемент, который равен 2 целых и т.д. А максимальный элемент равен 95 целых и т.д. Что в принципе согласуется с этим списком, если мы на него внимательно посмотрим.

Закроем теперь наше консольное окно. Для этого щелкнем на вот этом крестике. Мы вернулись в наш текстовый редактор.

Пример с использованием статических внутренних классовК оглавлению

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

Ну, во-первых, как мы и обещали, внутри этого класса, откроем как раз статический внутренний класс. Поэтому напишем таким образом. Во-первых, public. Далее Static, для того чтобы он был статический. И далее слово class, поскольку это класс, и далее имя этого класса.

Ну, пусть это будет, например, слово pair. Далее Enter и теперь фигурные скобки. Теперь внутри них напишем так. Конечно же, как всегда сначала нам нужно предусмотреть его конструктор, который, конечно же, должен быть public.

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

Далее, первое число f, first, затем второе число double и второе число second, s. Закрыть скобку. Теперь мы должны эти передаваемые параметры зафиксировать в соответствующих полях, которые определим в начале нашего класса pair. Поэтому напишем, таким образом: private. Далее тип поля double. Число и имя переменной этого поля first, как мы сказали. Далее точка с запятой.

И то же самое для второго числа second. Поэтому private. Далее double. И second. Точка с запятой.

Ну, теперь, раз у нас теперь эти два поля first и second у нас уже есть, то внутри нашего конструктора, нам вот эти параметры f и s, как раз надо присвоить first и second этим полям. Поэтому напишем совершенно стандартным образом: first равняется f. Точка с запятой. И second равняется s. Точка с запятой.

Ну, теперь, после того, как мы смогли присвоить этим полям first и second значения, нам нужно предусмотреть, каким образом мы получим эти значения извне. Для этого, конечно же, надо написать стандартные методы getfirst и getsecond. Поэтому напишем так. Во-первых, конечно же, эти методы должны быть public.

Далее тип возвращаемого значения double и имя этого метода getfirst. Далее скобка и закрытие этой скобки. И внутри фигурных скобок напишем просто-напросто return и first. Точка с запятой.

Ну, теперь, что-то аналогичное нам нужно написать для возвращения второго нашего значения. Конечно же, он тоже должен быть public. Далее double, тип возвращаемого значения, second. Скобки. Фигурные скобки, внутри которых напишем return, возвратить значение second, второго числа. Точка с запятой.

Вот теперь у нас статический класс pair целиком готов для сохранения двух пар чисел.

Теперь же, внутри вот этого класса MyArray организуем как раз поиск минимального и максимального значения. Для этого сдвинемся чуть ниже и напишем так. Теперь же, как раз нам следует объявить статический внутренний класс. Поэтому напишем так. Конечно же, он должен быть public. Далее Static, как мы и предполагали.

Имя класса: Pair. Ну и название пусть будет, например, minmax, поскольку мы вычисляем в принципе минимальное и максимальное значение. Далее передадим этому внутреннему классу в качестве параметра массив из действительных чисел double. Поскольку массив, запишем вот такие квадратные открывающие и закрывающие скобки. И далее параметр d. Закрыть скобку.

Далее фигурные скобки, внутри которых, во-первых, предусмотрим тот случай, если у нас длина нашего массива просто-напросто равна 0. Тогда возвратим значения 0. Проверим это if d точка length. Длина массива равняется 0. Закрыть скобку.

Если это верно, тогда return, возвращаем значение new pair, пару чисел 0 запятая 0. Закрыть скобку. Точка с запятой.

Теперь же, во-первых, мы можем целиком скопировать вот этот блок, который считает минимальное и максимальное число. Поэтому сдвинемся чуть выше. Скопируем вот эти несколько строчек. Выделим их. Правая кнопка мыши. Сору. А теперь сдвинемся ниже. И вот в этом месте вставим эти строчки. Правая кнопка мыши и Paste.

А теперь нам просто-напросто надо возвратить вот эти значения min и max. Поэтому напишем таким образом: return. Далее опять new, pair, пара чисел. И внутри скобок, напишем, конечно же, min и max. Min запятая Max. Закрыть скобку. Точка с запятой.

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

Теперь же, напишем таким образом. Ну, во-первых, MyArray. Точка. И далее его класс pair, пара. Пусть это будет у нас p.

Далее равно и этот класс MyArray, Мой массив. Точка. И используем его внутренний статический класс minmax, который и вычисляет и минимальные и максимальные значения.

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

Ну и в качестве максимального элемента, конечно же, должно быть p точка getsecond. Далее должно быть, конечно же, скобка, поскольку мы вызываем метод. И то же самое нам нужно сделать для метода getfirst. Написать здесь скобки. А теперь же, попробуем скомпилировать и запустить наше приложение. Для этого Tools. Далее Compile Java.

Вот мы уже все скомпилировали. Все успешно. Поэтому Tools, и Run Java Application. Запустим наше приложение. Ну и в принципе, можно увидеть, что наша программа все выполнили правильно. Минимальный элемент равен 1,7 и далее остальные цифры после запятой. А максимальный элемент 97,45 и т.д., что в принципе согласуется, если внимательно просмотреть эти числа. Ну, закроем теперь наше консольное окно. Поскольку в принципе все выполняется правильно. Вернемся в наш текстовый редактор.

Создание фреймовК оглавлению

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

А поскольку с самого начала язык Java был задуман, как платформа Независимый язык, то вопрос о том, чтобы создать собственный пользовательский интерфейс. Именно поэтому был разработан пакет Swing, который, конечно же, полностью заменить библиотеку awt не может, но зато дает гораздо больше возможности для создания пользовательского интерфейса.

Хотя компоненты пользовательского интерфейса из вот этого пакета awt все еще доступны для языка Java, несмотря на это программист все больше и больше использует те возможности, которые предоставляет пакет Swing.

В принципе, конечно, надо учесть, что элементы пакета Swing появляются на экране немножко медленнее, чем компоненты, которые предусмотрены в библиотеке awt. Но, учитывая, что современные машины достаточно быстро работают, то этот недостаток, в принципе незначителен.

С другой стороны, при использовании библиотеки Swing, мы получаем более богатый и удобный набор элементов пользовательского интерфейса. Также она гораздо меньше зависит от выбора платформы, и если коротко резюмировать, то пакет Swing позволяет выполнить стандартный девиз компании Sun, который разрабатывает Java. Написано однажды, работает везде.

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

Сохраним сначала его в каком-либо файле. Для этого щелкнем на значке сохранения. Выберем для него новую папку. Щелкнем на вот этом значке и выберем для него имя. Ну, пусть это будет Му25. Щелкнем на кнопку Open. И наберем имя для нашего документа. Пусть это будет Му25, по названию класса. Щелкнем на кнопку Save.

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

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

Далее выберем имя для экземпляра этого класса, для этого объекта. Пусть будет так, просто-напросто Frame, чтобы долго не думать. Равняется. Затем стандартным образом нужно его создать, new и вызвать его конструктор, JFrame и далее скобки. Точка с запятой.

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

Для этого чтобы он появился на экране, нам нужно проделать специальный метод show. Поэтому напишем, таким образом, frame Точка show. И далее скобки. Точка с запятой. В принципе, уже после этих слов, мы можем запустить наше приложение и что-то увидеть на нашем экране. Ну, скомпилируем сначала. Для этого Tools. Далее Compile Java. Компиляция прошла успешно. Теперь Tools. Далее Run Java Application.

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

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

А теперь же, попробуем закрыть наше приложение. Если мы щелкнем на вот этом крестике, то в принципе, само окно, конечно же, исчезло, закрылось, но приложение, тем не менее, не прекратило свою работу. Но в принципе, поскольку мы находимся в системе ХР, то, конечно же, мы можем принудительно, это тем не менее, закрыть это консольное окно, если мы щелкнем на этом крестике.

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

Далее точка. И теперь используем стандартный метод SetDefaultCloseOperation.

Далее, внутри скобок укажем, что при завершении работы окна, она должен прекратить свою работу. Для этого надо написать, таким образом, JFrame. Точка. И далее EXIT_ON_CLOSE. Закрыть скобку. Точка с запятой. Теперь, если мы запустим наше приложение Tools, Compile Java.

Компиляция нормально прошла. Теперь Tools, Run Java Application. И опять появилось наше окно. А если мы его расширим, например, можем его сдвинуть. А теперь, если мы попробуем закрыть его и щелкнуть на вот этом крестике, то, как мы видим, наше приложение свою работу прекратило. Появилась вот эта стандартная надпись "Нажать кнопку для закрытия окна". Закроем теперь это консольное окно.

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

Поэтому напишем, таким образом, класс, далее назовем его, как-нибудь по-другому, чем JFrame. Пусть будет, например, MyFrame. Далее укажем, что он создается на основе своего родительского класса JFrame. Ключевое слово extends.

Далее JFrame. И теперь, внутри фигурных скобок, мы должны указать все отличия, которым класс MyFrame будет отличаться от JFrame. Конечно же, основное, что мы хотим сделать, это установить размеры для нашего окна. Поэтому напишем таким образом. Конечно же, если у нас есть класс, мы должны указать конструктор. Поэтому напишем так, MyFrame. Конечно же, имя конструктора должно в точности повторять имя класса.

Конечно же, этот конструктор у нас должен быть public. И далее параметры. Ну, параметров у нас нет. И внутри фигурных скобок напишем то, что мы хотим, чтобы происходило при начальной инициализации нашего диалогового окна. Ну, пусть мы, конечно же, хотим просто-напросто задать его размеры. Поэтому напишем так. Set Size, и далее те размеры, которые мы хотим использовать. Например, возьмем 300х200 единиц. Закрыть скобку. Точка с запятой.

Теперь же, в нашей основной программе, вместо JFrame, который мы использовали для создания нашего окна, нам надо использовать MyFrame. Поэтому переправим, MyFrame. То же самое в этом месте, где у нас запускается конструктор.

Ну, и теперь мы можем скомпилировать и выполнить наше приложение. Компилируем сначала. Для этого Tools. Далее Compile Java. Компиляция прошла успешно. Поэтому запустим наше приложение. Для этого Tools, Run Java Application. И вот можно видеть результат выполнения нашей программы. На нашем экране появилось вот стандартное окно, которое, конечно же, выглядит гораздо более привлекательным.

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

Задание позиции и размеров фреймаК оглавлению

Теперь же, конечно, если мы ограничимся только этой строкой, просто-напросто вот это второе окно не будет видно. Но, попробуем, поэтому вывести его на наше окно приложения. Для этого нам нужно использовать метод show. Напишем так, frame2. Точка show. И далее скобки. Точка с запятой.

Вот эту строчку, которую мы написали, для того чтобы при закрытии нашего первого окна закрывалось все наше приложение, писать не будем. И теперь, попробуем запустить наше приложение. Для этого Tools. Далее Compile Java. Сначала скомпилируем, конечно же.

Далее Tools, Run Java application. И можно видеть, что у нас получилось. В принципе пока видно всего лишь одно окно. Но, если мы его сдвинем в сторону, то можно увидеть, что на самом деле, этих окон два. Ну и, между этими двумя окнами, сейчас на самом деле есть существенное отличие. Если мы закроем вот это второе окно, то оно закрывается, но компьютер не прекращает выполнение нашего приложения, которое заканчивается всего лишь при закрытии вот этого окна.

Сейчас мы уже вышли из нашего приложения. Закроем. И попробуем запустить еще раз это же приложение. Для этого Tools, Run Java application. Опять вот это верхнее окно сдвинем в сторону. И теперь, попробуем сразу закрыть вот это окно, которое осталось в левом верхнем углу. Если мы сейчас нажмем на крестике, то, как мы видим, закрылось и вот это окно и то окно, которое мы сдвинули, и просто-напросто приложение закончило свою работу.

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

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

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

Поэтому зададим его таким образом. Координата Х, далее int, и координата Y. При задании же нашего фрейма, мы как раз и укажем эти координаты. Ну, пусть первое окно, так же как и было, появляется в левом верхнем углу, у которого координата будет 0,0, а у второго окна пусть координаты будут несколько другие. Например, зададим таким образом. 100 запятая 100.

Ну и теперь, если у нас X, Y есть, то мы можем уже закончить написание нашего вызова SetLocation, в котором мы, конечно же, можем написать X, Y. Закрыть скобку. Точка с запятой. Запустим теперь наше приложение. Для этого Tools. Далее Compile Java. После успешной компиляции запустим теперь само приложение Tools. Далее Run Java Application.

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

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

В принципе, вместо использования вот этих двух методов setsize и setlocation, можно использовать всего лишь один метод setbound, который объединяет вот эти два метода. Ну, напишем для этого таким образом: set, далее bound, далее скобка. И теперь, сначала нам нужно указать координаты, где должно появиться это окно, X и Y.

А далее размеры этого окна. Ну, в нашем случае, это 300 и 200. Закрыть скобку. Точка с запятой. Теперь вот эти первые две строки нам уже абсолютно не нужны и если запустим это приложение, то можно увидеть, что его внешний вид, полностью будет совпадать с тем, что мы видели ранее. Попробуем это сделать. Для этого Tools. Далее Compile Java.

Далее Tools, Run Java application. И, как мы видим, мы получили то же самое расположение окон и те же самые его размеры. Закроем. Закроем и консольное окно. И вот мы опять в нашем текстовом редакторе. Такое задание координат X и Y, расположение левого верхнего угла наших окон и его размеров в точках, конечно же, очень сильно привязано к разрешимости нашего экрана.

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

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

Для этого в языке Java, есть специальный инструментарии Toolkit. Определим его сначала. Для этого напишем таким образом. Класс Toolkit. Создадим какой-либо из экземпляров этого класса. Пусть это будет объект kit. Далее равняется. И создадим этот экземпляр. Для этого Toolkit. Точка.

И далее getDefaultToolKit. Далее скобка. Точка с запятой. Теперь же получим непосредственно размеры, которые получаются в объектах типа Dimension. Поэтому так и напишем.

Пусть этот объект у нас будет называться screenSize, поскольку здесь мы как раз получаем размер нашего экрана. Далее равняется. Объект Kit. Точка. И далее его метод getscreenSize. Далее скобки. Точка с запятой.

Теперь получим из этой переменной screenSize непосредственно ширину и высоту нашего экрана. Для этого создадим две переменные типа integer. Пусть это будет LX, которая будет равняться screenSize. Точка и далее его величина по оси Х, т.е. with.Точка с запятой.

Далее размер по второму направлению. Тут, конечно же, тоже будет integer. Далее LY. Равняется. Опять screenSize. Только на этот раз вместо with у нас будет hate. Точка с запятой.

И вот теперь эти числа мы используем в создании нашего окна. Единственное, представим себе, что X и Y у нас теперь уже не просто координаты в точках, а координаты, так сказать, в процентном отношении. Если за 100% взять размер нашего окна, и по ширине и по высоте.

Например, если мы хотим, чтобы левый верхний угол нашего окна был ровно в серединке нашего экрана, зададим здесь 50х50. Ну и, конечно, для задания наших координат, мы напишем несколько уже по-другому. Не просто X и Y, а Х умножить на LX и разделить на 100, поскольку, конечно же, в процентах у нас ровно 100 штук. Ну и по координате Y то же самое, Y умножить на LY и разделить на 100.

Теперь же, для того чтобы наше приложение успешно работало, нам нужно указать еще и директиву Import, при помощи которого нам нужно загрузить тот пакет, который реализует вот этот инструментарии Toolkit. Поэтому введем здесь Enter, далее напишем ключевое слово Import,

далее Java, точка awt, поскольку именно в этом пакете и находятся все необходимые нам средства. А также Import. Опять Java. Точка awt. И далее точка event. И звездочка. Точка с запятой.

Попробуем теперь запустить наше приложение и посмотреть, что у нас получилось. Сначала скомпилируем Tool, Compile Java. И вот мы получили некую ошибку в нашем приложении. Ну, конечно же, можно увидеть, что это просто-напросто чисто грамматическая ошибка. Мы пропустили одну букву "O" в слове Toolkit.

Поэтому перейдем на наше приложение и исправим это дело. Напишем здесь "O". Теперь же скомпилируем опять Для этого Tools. Далее Compile Java. А теперь опять Tools. Далее Run Java application, и можно увидеть результат выполнения нашей программы. Если первое, из этих окон, точно у нас находится в левом верхнем углу нашего экрана, то левый верхний угол нашего второго окна, находится точно по серединке нашего дисплея. Закроем теперь. Как мы помним, закрывать надо вот это окно, которое у нас находится в левом верхнем углу. Приложение закончило свою работу. Закроем и консольное окно. И мы опять попали в наш текстовый редактор.

Задание заголовка, иконки и др. параметров фреймаК оглавлению

Щелкнем поэтому здесь на клавише Enter, и первое, что нам нужно сделать, это определить вот этот инструментарии Toolkit. Поэтому выделим вот эту строчку, далее правая кнопка мыши и Сору. Вставим сюда. Правая кнопка мыши и Paste.

Теперь Enter. И далее, определим новый объект типа Image. Пусть это будет im. равняется, и загрузим его при помощи вот этого инструментария kit, который, как мы помним, является классом Toolkit. При помощи его метода getImage из файла, который у нас находится на жестком диске.

Но, в частности, пусть это будет файл ball, точка gif, поскольку именно такой файл у нас уже находится в нашей корневой директории Му25. Мы его туда скопировали. Теперь скобка. Точка с запятой. Ну и, конечно же, после того, как мы организовали вот эту иконку im, ее нужно связать с нашим окном.

Для этого frame2. Точка. Ну и нам нужно использовать его метод SetIconImage. Далее скобка. И далее иконка im, которую мы только что загрузили на наше изображение. Im, закрыть скобку. Точка с запятой.

Попробуем теперь скомпилировать и запустить наше приложение. И посмотреть, что у нас получилось. Для этого Tools. Далее Compile Java. Мы все успешно скомпилировали. Теперь Tools, Run Java Application. И вот можно теперь увидеть, что у этих окон различные иконки, поскольку во втором из них, мы явно задали изображение, которое загрузили с файла на диске.

Закроем теперь наше приложение. Закроем вот этим крестиком. Теперь закроем и консольное окно и вернемся в наш текстовый редактор.

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

Ну, напишем просто-напросто 'Main frame', чтобы подчеркнуть то обстоятельство, что именно этим окном мы, и управляем нашим приложением. Т.е. ну, при необходимости и его закрываем. Далее закрыть скобку. Точка с запятой.

Кроме этого, попробуем сделать так, чтобы одно из этих окон, в частности опять наше первое окно было неизменяемым по своему размеру. Поэтому напишем опять frame. Далее точка и далее надо использовать его метод setResizable. Далее скобка, внутри которой укажем параметр False. Что как раз должно означать, что мы не хотим, чтобы оно было изменяемым.

Теперь же запустим наше приложение. Посмотрим, как теперь оно будет выглядеть. Для этого Tools. Далее Compile Java. Мы все успешно скомпилировали. Теперь Tools, Run Java Application. Запустим наше приложение. Как мы видим, появилось оба наших окна, на первом из которых появилась теперь надпись Main frame, а на втором никакой надписи нет.

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

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

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

Вставим сюда. Правая кнопка мыши и Paste. Вместо frame2 напишем frame3, и его положение пусть будет 30 и 30%. Ну и далее, нам теперь нужно указать frameShow. Для этого опять выделим вот эту строчку. Правая кнопка мыши и Сору. Встанем сюда и правая кнопка, Paste.

Конечно, предварительно нам фрейм тоже здесь надо указать, frame3Show, а не frame2Show. И теперь в этом третьем окне попробуем сделать так, чтобы, так сказать, выводилось чистое окно без титульной линейки наверху, без системных кнопок и т.д. И без рамки.

Но для этого есть специальный метод setUndecorated, который удаляет все украшения из нашего фрейма. Поэтому напишем, таким образом, frame3 и точка. Далее setUndecorated. Далее скобка. И укажем параметр True. Закрыть скобку. Точка с запятой.

Теперь запустим наше приложение. Для этого Tools. Далее Compile Java. Компиляция прошла успешно. Теперь Tools, Run Java Application. Запустим наше приложение. И вот, можно увидеть результат выполнения нашей программы. Между первым и вторым нашим окном появилось вот это третье окно, у которого, как мы видим, наверху нет ни титульного заголовка, ни рамки и вообще ничего. Так сказать, вот такое пустое окно, на которое в принципе в дальнейшем можно вывести какие-то надписи, рисунки и т.д. Но пока оно абсолютно пустое.

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

Попробуем теперь запустить наше приложение так, чтобы какое-либо из наших окон принимало свой максимальный размер. Ну, например, вот это окно frame2. Для этого щелкнем здесь на клавише Enter и напишем, таким образом, frame2. Точка. И далее используем метод setExtendedstate.

Далее скобка и теперь надо указать, каким образом мы хотим вывести наше окно. А здесь у нас есть несколько возможностей. А именно, указать frameNormal, frame, затем точка и Normal. В этом случае у нас окно будет отображаться в своем нормальном виде, т.е., то, которое у нас сейчас есть 300 и 200.

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

Ну, вместо этого мы можем написать MAXIMIZED_BOTH, по обоим направлениям и в этом случае, у нас тогда наше окно будет максимальным по обоим направлениям, что означает, что оно будет занимать всю площадь нашего экрана. Попробуем запустить и выполнить наше приложение. Для этого Tools. Далее Compile Java. Компиляция прошла успешно. Теперь Tools, Run Java Application.

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

И обратим внимание на то, что мы сначала задавали максималь