Язык Java

Размещено на http://www.allbest.ru

1. Цель. Структура

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

Имеется проект языка Java, в нём содержится единственный пакет (язык Java обладает пакетным уровнем доступа), структура его такова:

Первоначальный класс - Person

Абстрактный класс - Worker

Производные классы - Worker_Level1, Worker_Level2, Director

Класс, содержащий основные методы - Company

Класс №5 отвечает за показ работы программы - Go

Структура разработки

Начнём с того, что любой рабочий - это, прежде всего человек. Именно поэтому сначала создан Person. Worker является основой для всех рабочих фирмы, т.е. является классом, в котором будут методы, которые могут быть применены для всех объектов, унаследованных от него, в нашем случае это Worker_Level1, Worker_Level2, Director. Поскольку классы все предыдущие классы описывают лишь один объект, то нам нужен класс, в котором можно будет работать с множеством объектов и эти объекты нужно обрабатывать, для этих целей был создан Company. Программа должна давать результат, иначе она не имеет смысла, класс Go показывает работоспособность проекта на примере методов классов, которые используют различные входные данные.

2. Person

Итак, рассмотрим класс №1.

Почти каждый класс имеет поля. Это специальные секции, где хранится информация (в основном, различных типов). Уровень доступа к ним бывает 3-ёх типов:

private - содержимое этой секции недоступно из клиентской программы.

public - содержимое этой секции открыто из клиентской программы.

protected - доступен для потомка класса, для остальных поле трактуется как private.

В нашем случае есть 3 поля: firstName(имя) типа String, secondName(фамилия) типа String, age(возраст) типа int. Для их инициализации существуют конструкторы. Он начинается с ключевого слова public <Имя класса>(<Список формальных параметров>), затем в теле мы при помощи ключевого слова this создаём объекты.

Объект можно взять (например, для печати) или изменить, для этого существуют специальные методы. Чтобы узнать имя Person нужно сделать следующие: после переменной этого типа поставить точку и в появившимся списке выбрать метод getFirstName(). Аналогично, можно изменить имя объекта при помощи метода setFirstName(<Значение типа String>). Далее идёт метод toString(), он выдаёт строковое представление объекта (он не печатает на экран содержимое, для этого стоит выполнить: System.out.print(Объект.toString()).

Ключевое слово @Override означает, что метод переопределен, т.е. он был реализован ранее в другом классе.

Замечу, что внутри тела класса мы обращались к полям(firstName), а не к переменным, в то время как в основной программе мы обращаемся к переменной(Person x.firstName), а после точки используем поле. Программист должен использовать все возможное, чтобы увеличить скорость разработки. Например, можно не писать «вручную» методы get-set(), а также toString(), а сделать их при помощи команды в Eclipse.

Создание методов в Eclipse

3. Worker

В классе Person мы «создали» обычного человека, задав ему имя, фамилию и возраст. Это было необходимостью, потому что в БД нужен поиск по этим показателям. Класс Worker уже содержит поля начала работы в компании (кол-во лет) - StartInCompany типа String, а также поле Data типа Person. Здесь поле Data содержит в себе поля, которые содержит объект типа Person, а именно: firstName, secondName, age. Удобство состоит в том, что не приходится писать снова поля и методы для этих полей - это плюс, мы используем повторно код. Откуда компилятор знает о классе Person? Тут работает та самая пакетная система. Оба наши класса находятся в одном пакете (папке), поэтому они и «знают» о существовании друг друга - это ещё один плюс Java. Здесь не все поля инициализируются, поле StartInCompany будет задаваться в основной программе, а поле Data создаётся, средством создания объекта типа Person прям внутри конструктора: this.Data = new Person(<список фактических параметров>) или Объекту присвоить новый объект определённого типа.

Методы Money() (возвращает зарплату рабочего) и Start() (возвращает количество лет после начала работы) кажутся неверными по двум причинам: первое слово abstract, второе отсутствие тела метода. Разбираемся, первое непосредственно связанно со вторым т.к. это ключевое слово означает, что тело этого метода будет написано в классе потомке текущего класса(Worker), следовательно, вопрос о теле метода отпадает сразу. Замечу, что мы уже сталкивались со словом @Override, которое означало, что мы переопределили абстрактный метод toString() в своём классе (это был класс Person).

4. Worker_Level1, Worker_Level2, Director

Скажу сразу, эти два класса (Worker_Level1, Worker_Level2) являются точной копией друг друга. Это было сделано, чтобы читатель понял, что можно продолжать создавать классы различных типов рабочих, а не останавливаться на 2-ух типах классов как в моей разработке. Для тех, кто захочет это реализовать, поясню, напишите код одного класса, а во втором цифру один замените на два.

Ключевое слово extends означает, что класс Worker_Level1 унаследован от класса Worker. Далее идут стандартно два поля: WL1Money (зарплата рабочего уровня 1) и Start (количество отработанных лет). Затем идёт обычный конструктор, но появляется слово super. Запомните правило: в конструкторе класса потомка (а это наш нынешний класс), сначала вызывается конструктор класса предка(Worker) с этим ключевым словом, а потом уже инициализируйте свои поля. Конструктор предка содержал три параметра, поэтому мы и вызываем super от трёх компонент. Т.е. на самом деле рабочий первого уровня состоит из рабочего. Зачем так сложно? Суть в том, что класс Worker является обобщающим, а мы от него унаследуем несколько типов рабочих. На практике это полезно тем, что вызывая метод который есть в Worker будет выполняться тот же метод, но уже в классе потомке(Worker_Level1 и мы получаем зарплату этого типа рабочих), а иначе мы бы получили зарплату только для этого класса… Это доступно благодаря позднему связыванию в переменных в Java(добавляем ещё один плюс этому языку). Ранее связывание - это если на момент запуска программа имела тип1, то и концу выполнения программы она и будет иметь тип1. А позднее связывание - это когда этот тип1 может быть заменён на тип2, если это является допустимым (например, наследование). Отмечу, что все методы, которые есть в предке, должны быть реализованы в потомке, ну и само собой можно сделать новые. Тут, как и с конструктором, сначала всё для предка, а потом что-то для «себя» (своего класса).

Методы SetStart(int Start)(установить кол-во отработанных лет) и SetWL1Money(double wL1Money)(установить зарплату рабочего уровня1) являются одновременно и сеттером, и инициализаторами полей. Стоп! Раньше сеттеры только меняли поля, а тут они их задают и почему они не в конструкторе - можно было сделать и так, но в данном случае мы их сделали так, чтобы можно было установить зарплату отдельно от создания объекта. Например, сначала создадим рабочего, а только через 3 дня установим его зарплату.

Далее идут два метода переопределённые от класса Worker - это Money() и Start(), которые возвращают значение соответствующих полей класса Worker_Level1. А также вновь переопределённый метод toStrint(). Вот был бы один метод toString() пришлось вручную перед каждым его вызовом писать System.out.println(“Метод toString вызван для такого-то и такого-то класса”)*, а при помощи наследования и переопределения поменяли пару строк в методе и всё. Вновь отмечу, повторное использование кода и отсутствие лишнего кода, такого как *. Для разнообразия создадим не рядового рабочего, а именно главу компании. Это класс Director. Я не стал описывать отдельный пункт для этого класса т.к. он практически совпадает с Worker_Level1(можно было бы для этих классов создать разные поля и методы, но это уже индивидуальные случаи). Но его реализацию всё же покажу (автор счёл, нужным сделать 3-и похожих класса, потому что изначально читатель может сделать много классов типа Worker, а унаследовать мало классов типа W_L1 или 2, Director, что в большинстве случаев неверно).

5. Company

Продолжаем обзор нашей разработки. Следующий класс является самым большим.

Изначально мы подключаем при помощи ключевого слова import некоторые пакеты в Java. Затем идёт класс Company у которого поле класса является динамической структурой (список и.т.п.) т.е. поле инициализирует само себя, как List на базе ArrayList(Индексированный список со своими методами). В Java принято, что переменная типа интерфейс (класс в котором есть названия методов, но нет реализации - принцип сокрытия реализации. Он даёт некоторые преимущества. Например, можно поменять реализацию на новую, а интерфейс оставить старый - в программе устранили ошибки, а пользователь даже об этом и не подозревал) инициализируется объектом этого класса. Я выбрал динамическую структуру не зря. Так как заказчик может иметь 200 человек в фирме, а может и 5, поэтому статистические (размер которых известен заранее) типы данных нам не подходят. Далее идёт метод getWorkers(), который возвращает нашу коллекцию. Затем метод, переопределённый toString() и метод добавляющий рабочего (на вход подаётся объект типа Worker или унаследованный от него), в основе которого метод add() у ArrayList. Затем, метод MoneyOfCompany()(который возвращает среднюю зар.плату в компании), из нюансов отмечу следующее: Workers.size(),тут Workers - это динамическая структура, которая имеет метод size(), который возвращает длину, в то время как в массивах size или length - это поля структуры. Важно понимать, что это поле, а второе метод, хотя бы потому, что впоследствии его можно будет переопределить, ну и само собой синтаксис Java «настаивает» на том, что метод вызывает с двойными скобками, в которых пишут параметры метода, в то время как поле не требует скобок. Второе, перед присвоением, я зачем-то написал (Worker) - это явная инициализация. Например, в Java поделить с остатком при помощи «/» нельзя. Как поделить? 1) Делим как обычно и в конце всё умножаем на 1.0 и число становиться с «запятой». 2) Делаем явную инициализацию. В общем, компилятору лучше сообщать, что вы присваиваете. Алгоритм самой функции тривиален: просуммировали и поделили на кол-во - всё. Метод RemoveWorkers() удаляет работника первого уровня. По факту, it.hasNext() - дословно в цикле, пока существует следующий, делай что-то, _Переменная_ instancecof _Класс_ - если Переменная является объектом Класса, то тогда true, иначе false, it.next() - берём следующий элемент и it.remove() - удалить текущий элемент. Все методы встроенные и вам их не надо реализовывать. Теперь самое важное, Iterator - это такой класс, который позволяет нам пройтись и обработать коллекцию. Как вызвать, Iterator(класс)<Worker>(тип итератора)it(переменная, название выбрано от сокращённого iterator. Не буду говорить о хорошем тоне кода, но отступы и правильное название переменных - это залог успеха. Отмечу также комментарии основных частей программы, спустя пару лет после написания кода вы будете удивляться, как это писали, а комментарии помогут вам это понять. Как говорил один великий программист: «Хороший код сам себе документация») = Workers(структура которую будем смотреть, а её элементы - это тип класса итератора).iterator()(метод нашей динамической структуры, который и просматривает объекты - её мы и присваиваем it). Алгоритм, опять тривиален: цикл по всей структуре, если объект класса, то удаляем. Я специально старался подбирать несложные, но в тоже время обширно применимые алгоритмы, чтобы можно было, и посмотреть, как работает ООП, и в тоже время посмотреть работу проекта «Компания». Иногда нам нужно добавить не один элемент, а сразу много, для этого есть элемент AddCollection(Collection<? extends Worker> ADD) - он добавляют существующую коллекцию Java в нашу коллекцию. Что касается особенностей, а тут они само собой есть, отмечу вот что, слово Collection - это обобщение и оно значит, что это может быть List или ArrayList, почти всегда лучше указывать явно, но в этом случае лучше обобщить, потому что мало-ли, что нужно добавить пользователю. В треугольных скобках следующее: объекты коллекции либо Worker, либо унаследованы от него. Вопрос обязателен - это синтаксис Java, глаз резать не должно, ну а если режет, то придётся не смотреть, потому что данный метод применяется очень часто и используется повсеместно и к этому нужно привыкнуть. Необычно, но алгоритм я решил расписать в программе, чтобы было более наглядно, что делает каждая строка. Опишу сразу два метода. Методы FileIn-Out, являются методами загрузки из файлов ОС. В файлах существует много классов и описывать каждый не стоит, потому что цель - это проект. Приведу лишь иерархию:

6. Файлы Java

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

7. Помощь в исключениях

Алгоритмы: Создание файла. Создаём файл при помощи класса PrintWriter, и делаем цикл по длине нашей динамической структуры и последовательно записываем в файл, в конце закрываем его. В принципе, тут уже не Pascal и в случае если вы не закрыли файл, у вас не будет исключений (хорошо это или плохо, судите сами), а лишь не сохранятся последние данные, которые в буфере обмена. Создание из файла. Создаём переменную(FR), которая отвечает за файл, присваиваем её подобию итератора(Scan), а также, куда будем сохранять данные из файла(array). Пока не конец файла: берём строку при помощи метода nextLine() от нашего «итератора». И присваиваем её для запоминания переменной s, затем создадим массив строк(a) и при помощи метода split()(он добавляет в массив строки разделённые пробелом, но не обязательно им). Затем берём элемент a[0] который отвечает за тип добавляемого рабочего и если он совпадает с кем-нибудь из наших типов, то создаём объект соответствующего класса и добавляем его при помощи метода add(), в итоге присваиваем массив array - который теперь содержит данные с файла. Что может быть интересно: Integer.valueOf(_элемент_), преобразовать строку к int - запомните это как операцию для класса Integer(легко догадаться, что он отвечает за встроенный тип int). В Java есть два способа сравнения строк. 1-ый на ссылку (место в памяти) т.е. вопрос следующий - «Строки указывают на одно место в памяти?». Ему соответствует операция «==». 2-ой тип - это лексеграфический(грубо говоря, по порядку, о первого неравенства), есть таблица кодов и по ней сравнивают. Синтаксис таков: _Строка1_.equals(_Строка2_), где объект _Строка2_ унаследован от класса Object(базовый класс и он начало начал в Java).

8. Файлы, которые были в примере

Go

До этого мы работали с объектами в классах, как с полями или как с переменными внутри метода. Настало время для основной программы. Она не сложная т.к. основная реализация в методах класса. А теперь можно смело этим пользоваться за доли секунд - это и есть плюс ООП. По факту, подключаем нужные пакеты. Потом идёт метод main() - это основной метод, компилятор его ищет и не пытайтесь обмануть его, например в С++ для этого связи файлов есть специальные конструкции, например отдельный файл main или заголовочные файлы типа .h. Отступление завершено, вернёмся к Java, далее стандартно создаём объекты классов, предварительно вводя данные с клавиатуры, ну а я в своём тестовом случае ввёл их сразу. И выполняем программу, отмечу лишь длинный кусок обращения к данным в таком случае: W.get(i).Data.getSecondName().1)W(список Worker) берём его элемент при помощи get(i). 2)

После того как взяли элемент типа Worker обращаемся к полю (не через геттер), делать геттеры полезно т.к. не все имеют доступ к полям, а к геттерам имеют доступ все, в этом их разница, хотя функция одна. 3) Т.к. поле Data типа Person, то для неё мы обращаемся к полю через геттер getSecondName() и берём фамилию.

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

Директор: Имя Андрей, Фамилия Иванов, Возраст 65; Оклад = 1000000.0

1-ый этап

Рабочий первого уровня: Имя Сергей, Фамилия Петров, Возраст 35; Оклад = 300000.0

Рабочий второго уровня: Имя Игорь, Фамилия Паршивлюк, Возраст 32; Оклад = 200000.0

2-ой этап

Список:

Рабочий Иванов работает 30 лет

Рабочий Петров работает 12 лет

Рабочий Паршивлюк работает 10 лет

3-ий этап

[Директор: Имя Vlad, Фамилия GG, Возраст 12; Оклад = 0.0, Рабочий первого уровня: Имя Vlas, Фамилия GG, Возраст 42; Оклад = 0.0, Рабочий второго уровня: Имя Vlag, Фамилия GG, Возраст 13; Оклад = 0.0]

4-ий этап

Приложение «Сортировка и количество объектов»

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

Создадим класс WorkerComparator, который реализует Comparator<Worker>. Предварительно сделаем импорт этого класса. Ключевое слово implements означает, что класс полевую сторону от слова реализует класс, который находиться по правую сторону от слова. Создадим метод compare(Worker W1, Worker W2), который сравнивает двух рабочих по определённому показателю, в данном случае - это дата начала работы служащих. Две временные переменные получают значение полей от метода Start(), после чего они сравниваются. Это поможет нам в сортировке, когда создадим объект класса WorkerComparator. Переходим в класс Company. В нём следует создать метод Sort(), который возвращает отсортированный список рабочих. Алгоритм нашего метода следующий:

1) Создаём массив Worker из списка, чтобы позже применить сортировку для массива (только для массива существует специальная сортировка при классе Comparator).

2) Создаём объект класса сортировки (потому что не видно того класса внутри Company) WorkerComparator.

3) Сортируем при помощи специального метода sort(_Массив_, _Критерий сортировки_) и получаем отсортированный массив.

4) Выведем отсортированные данные (вместо метода main[]) для проверки.

5) Переносим наш массив обратно в список т.к. пользователь начинал работу со списком, поэтому нужно вернуть такую же динамическую структуру.

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

Вот и второй обещанный метод. Здесь мы узнаём количество рабочих проработавших определённое количество лет. Например, кол-во людей отработавших 17 лет. В этом нам помогут хэш-таблицы, а также специальные метода и структуры данных. В классе Worker следует переопределить методы equals() и hashCode(), поскольку наша динамическая структура будет нуждаться в них при составлении своих ключей.

Я это сделал при помощи Java. Она позволяет нам создавать эти методы автоматически. Это можно сделать также как и с методом toString(). Сделав все вспомогательные методы можно перейти к реализации основной задачи - метода Hash().

В этом методе есть новая вещь. Это HashMap на основе Map. Достоинства этой структуры состоят в том, что у неё есть много встроенных методов, а также у неё индекс (ключ) может быть разных типов, также как и поле данных. У нас ключ - это количество проработанных лет (т.к. именно по этому критерию удобно искать людей), а поле данных - это количество людей. Суть метода: просматриваем всех рабочих и заносим в «хэш-структуру»: если элемент новый, то мы создаём ключ с нужным количеством проработанных лет и полю данных придаём значение 1 т.к. это первый человек с таким стажем, если же такой элемент существует, то просто увеличиваем поле данных на 1. Поиск за константное время - это огромный плюс хэш-таблицы.

Основной класс Go потерпит следующие изменения:

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

Отсортированные по времени работы рабочие:

Фамилия: Петров Время работы: 12

Фамилия: Быстров Время работы: 14

Фамилия: Иванов Время работы: 30

Фамилия: Паршивлюк Время работы: 30

Фамилия: Сороконюк Время работы: 50

Что касается последних двух строчек, то я покажу результат в памяти, потому что Java позволяет.

В левой части экрана мы видим таблицу «Переменные», которая содержит «M» - это наша хэш-таблица, данные у которой подчёркнуты жёлтым (один человек отработал 50 лет, два отработали по 30 лет…).

сортировка программирование eclipse

Список используемой литературы

1. Брюс Эккель «Философия Java» 2009 г.

2. Ильдар Хабибуллин «Самоучитель Java» 2001 г.

3. Размещено на Allbest.ru