Приветствую!

Данный проект написан на JAVA CORE без использования дополнительных инструментов, в нём я старался отточить навыки применения принципов SOLID.

Как у меня получилось, оставлю оценку за вами. 😄👌

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

Все результаты работы кода выводятся в консоль.

Что именно и как происходит в коде я опишу ниже.

---

Разберём все классы по отдельности и их связи между собой.

---

interface Vehicle

Код в interface Vehicle (Транспортное средство), который определяет некоторые методы, связанные с характеристиками транспортного средства.
Вот описание каждого метода:

• getMaxSpeed(): Этот метод возвращает максимальную скорость транспортного средства в виде целого числа.
• getAcceleration(): Этот метод возвращает ускорение транспортного средства в виде числа с плавающей запятой (double).
• getNitroLevel(): Этот метод возвращает уровень нитро транспортного средства в виде целого числа.

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

Вот какому принципу соответствует interface Vehicle:

• Принципу интерфейсов (Interface Segregation Principle - ISP):
  ISP гласит, что клиенты не должны зависеть от интерфейсов, которые они не используют. В данном случае, interface Vehicle определяет только методы, связанные с характеристиками транспортного средства. Это позволяет клиентам, которым не нужны все эти характеристики, не реализовывать их.

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

---

Class Car

Class Car является реализацией interface Vehicle и представляет собой модель автомобиля.
Описание полей класса:

• maxSpeed - максимальная скорость автомобиля (целочисленное значение).
• acceleration - ускорение автомобиля (вещественное значение).
• score - текущий счет автомобиля (целочисленное значение).
• kilometersTravelled - пройденное расстояние в километрах (целочисленное значение).
• nitroLevel - уровень нитро автомобиля (целочисленное значение).

Constructor class Car принимает параметры maxSpeed, acceleration, score и nitroLevel и инициализирует соответствующие поля объекта.
Методы класса:\

• getMaxSpeed() - возвращает максимальную скорость автомобиля.
• getAcceleration() - возвращает ускорение автомобиля.
• getScore() - возвращает текущий счет автомобиля.
• setScore(int score) - устанавливает новое значение для счета автомобиля.
• getKilometersTravelled() - возвращает пройденное расстояние в километрах.
• setKilometersTravelled(int kilometersTravelled) - устанавливает новое значение для пройденного расстояния.
• getNitroLevel() - возвращает уровень нитро автомобиля.

Class Car реализует interface Vehicle, что означает, что он должен предоставлять реализацию всех методов, определенных в интерфейсе. В данном случае, class Car реализует методы getMaxSpeed(), getAcceleration() и getNitroLevel(). Этот класс предоставляет информацию о характеристиках автомобиля, таких как максимальная скорость, ускорение и уровень нитро. Он также содержит дополнительные поля, такие как счет и пройденное расстояние, а также методы для работы с этими полями.

Class Car соответствует принципам SOLID, а именно:

• Принцип единственной ответственности (Single Responsibility Principle - SRP):
  Class Car имеет только одну ответственность - представлять автомобиль. Он содержит только методы и поля, связанные с автомобилем, такие как максимальная скорость, ускорение, очки, пройденные километры и уровень нитро. Он не содержит логики, связанной с другими аспектами системы.

• Принцип открытости/закрытости (Open/Closed Principle - OCP):
  Class Car открыт для расширения (путем реализации interface Vehicle), но закрыт для модификации. Если мы хотим добавить новый тип транспортного средства, мы можем создать новый класс, реализующий interface Vehicle, без изменения class Car.

• Принцип подстановки Барбары Лисков (Liskov Substitution Principle - LSP):
  Class Car является подтипом interface Vehicle и может быть использован везде, где ожидается объект типа Vehicle. Это означает, что код, который работает с Vehicle, будет работать и с объектами типа Car без необходимости внесения изменений.

• Принцип инверсии зависимостей (Dependency Inversion Principle - DIP):
  Class Car зависит от абстракции, представленной interface Vehicle, а не от конкретной реализации. Это позволяет легко заменить class Car другой реализацией interface Vehicle, если потребуется.

• Принцип разделения интерфейса (Interface Segregation Principle - ISP):
  Class Car реализует только методы, которые ему необходимы из interface Vehicle. Он не имплементирует ненужные методы, что позволяет избежать ненужной зависимости от функциональности, которая не используется.

В целом, class Car соответствует принципам SOLID, что делает его гибким, расширяемым и легко поддерживаемым компонентом системы.

---

Class Constants

Class Constants является финальным (final) и содержит только static поля и constants. Он предназначен для хранения различных констант, используемых в приложении.
Данный файл Constants.java соответствует принципу SOLID:

• Принципу единственной ответственности (Single Responsibility Principle):
  Принцип единственной ответственности гласит, что каждый класс должен иметь только одну причину для изменения. В данном случае, class Constants отвечает только за хранение констант, которые используются в других частях программы. Он не содержит логики или функциональности, а только определения констант. Это соответствие принципу SOLID обеспечивает легкость поддержки и изменения кода. Если потребуется изменить значение какой-либо константы, это можно сделать только в одном месте - в class Constants. Это уменьшает вероятность ошибок и облегчает понимание кода другим разработчикам.

Таким образом, class Constants соответствует принципу единственной ответственности, так как его единственная ответственность - хранение констант.

---

Class Menu

Class Menu является перечислением (enum) и представляет меню с опциями для игры.
Он содержит следующие элементы:

• Константы:
  • START_RACE: Представляет опцию "Устроить заезд" с соответствующим текстом и кодом.
  • SHOW_STATISTICS: Представляет опцию "Показать статистику" с соответствующим текстом и кодом.
  • STOP_GAME: Представляет опцию "Закончить игру" с соответствующим текстом и кодом.
  • DEFAULT: Представляет опцию по умолчанию с текстом "Сделайте ввод соответствующий пунктам меню" и кодом "-1".
• Приватные статические поля:
  • WHAT_YOU_CHOOSE: Строка с текстом "Что выберете?".
• Приватные поля:
  • title: Строка с заголовком опции меню.
  • code: Строка с кодом опции меню.
• Конструктор:
  • Menu(String title, String code): Конструктор, который принимает заголовок и код опции меню и инициализирует соответствующие поля.
• Методы:
  • printTitle(): Выводит заголовок опции меню.
  • print(): Выводит все опции меню.
  • getMenuByCode(String code): Возвращает опцию меню по заданному коду.
  • getTitle(): Возвращает заголовок опции меню.

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

Class Menu соответствует принципам SOLID следующим образом:

• Принцип единственной ответственности (Single Responsibility Principle - SRP):
  Class Menu имеет только одну ответственность - представлять меню с определенными пунктами и их кодами. Он определяет пункты меню, их заголовки и коды, а также предоставляет методы для получения заголовка и печати меню. Это соответствует принципу SRP, так как класс имеет только одну причину для изменения - изменение самого меню.

• Принцип открытости/закрытости (Open/Closed Principle - OCP):
  Class Menu закрыт для изменений, так как он является перечислением (enum) и не предоставляет возможности для наследования или изменения своего поведения. Однако, новые пункты меню могут быть добавлены путем создания новых экземпляров перечисления Menu. Это соответствует принципу OCP, так как класс открыт для расширения (добавления новых пунктов меню), но закрыт для изменений (не требует изменения существующего кода).

• Принцип подстановки Барбары Лисков (Liskov Substitution Principle - LSP):
  В данном случае, принцип LSP не применим, так как class Menu не является базовым классом и не имеет наследников.

• Принцип разделения интерфейса (Interface Segregation Principle - ISP):
  В данном случае, принцип ISP не применим, так как class Menu не реализует интерфейсы.

• Принцип инверсии зависимостей (Dependency Inversion Principle - DIP):
  В данном случае, принцип DIP не применим, так как class Menu не зависит от абстракций или интерфейсов.

Таким образом, class Menu соответствует принципам SOLID, особенно принципу единственной ответственности и принципу открытости/закрытости.

---

Class Race

Class Race представляет гоночное соревнование между двумя автомобилями. Он содержит поля для вашего автомобиля yourCar, автомобиля оппонента opponentCar и расстояния distance.
Class Race имеет следующие методы:

• getYourCar(): Возвращает ваш автомобиль.
• setYourCar(Car yourCar): Устанавливает ваш автомобиль.
• getOpponentCar(): Возвращает автомобиль оппонента.
• setOpponentCar(Car opponentCar): Устанавливает автомобиль оппонента.
• getDistance(): Возвращает расстояние гонки.
• setDistance(int distance): Устанавливает расстояние гонки.
• printRaceResults(): Выводит результаты гонки, включая количество очков вашего автомобиля и пройденное расстояние.
• logicOfTheRace(): Определяет логику гонки и возвращает количество очков, набранных вашим автомобилем. Если ваш автомобиль выигрывает короткую гонку или длинную гонку, возвращается максимальная скорость автомобиля. Если скорости автомобилей равны, возвращается 0 очков. Если ваш автомобиль проигрывает, но сохраняет очки, возвращается 0 очков. Если ваш автомобиль проигрывает и теряет очки, возвращается отрицательное количество очков.
• printFlag(): Выводит флаг гонки. Class Race использует class Race, который должен быть определен в отдельном файле.

Данный class Race соответствует принципам SOLID:\

• Принцип единственной ответственности (Single Responsibility Principle - SRP):
  Class Race имеет только одну ответственность - управление гонкой. Он содержит методы для установки автомобилей, установки расстояния, вывода результатов гонки и логики гонки. Каждый метод выполняет только одну задачу, что соответствует SRP.

• Принцип открытости/закрытости (Open/Closed Principle - OCP):
  Class Race открыт для расширения, так как можно добавить новые методы или функциональность для улучшения гонки, но он закрыт для изменений, так как существующий код не требует изменений при добавлении новых функций.

• Принцип подстановки Барбары Лисков (Liskov Substitution Principle - LSP):
  Class Race использует абстракцию Car для работы с объектами автомобилей. Это позволяет подставлять любой подкласс Car без изменения кода class Race. Например, если бы был создан подкласс ElectricCar, его можно было бы использовать вместо Car без изменения кода class Race.

• Принцип разделения интерфейса (Interface Segregation Principle - ISP):
  Class Race не реализует интерфейсы, поэтому этот принцип не применяется непосредственно к данному классу.

• Принцип инверсии зависимостей (Dependency Inversion Principle - DIP):
  Class Race зависит от абстракции Car, а не от конкретной реализации. Это позволяет легко заменять различные типы автомобилей без изменения кода class Race.

В целом, класс Race соответствует принципам SOLID, что способствует его гибкости, расширяемости и поддерживаемости.

---

Class RaceInformationManager

Class RaceInformationManager находится в пакете com.zzerrgg. Он импортирует статические константы из class Constants.
Class RaceInformationManager содержит два метода: carInformation и displayRaceInformation.

Метод carInformation принимает два параметра: объект типа Race и строку типа String. Он проверяет, равна ли данная строка константе YOUR_CAR. Если равно, то выводит строку "Your Car" и максимальную скорость, ускорение и уровень нитро автомобиля из объекта Race. Если строка не равна YOUR_CAR, то выводит строку "Opponent Car" и соответствующую информацию об автомобиле из объекта Race.

Метод displayRaceInformation принимает объект типа Race в качестве параметра. Он выводит строку "Race Information" и дистанцию гонки из объекта Race. Затем он вызывает метод carInformation дважды: один раз с константой YOUR_CAR и один раз с константой OPPONENT_CAR, чтобы отобразить информацию об автомобилях как игрока, так и оппонента. В целом, class RaceInformationManager отвечает за отображение информации о гонке, включая информацию об автомобилях как игрока, так и оппонента.

Данный class RaceInformationManager соответствует принципу SOLID - Single Responsibility Principle (Принцип единственной ответственности). Он отвечает только за управление информацией о гонке и несет ответственность за две основные функции: отображение информации о машине и отображение информации о гонке. Метод carInformation отображает информацию о машине, принимая объект гонки и строку, указывающую, какую машину отобразить. Это отдельная ответственность, которая может быть выделена в отдельный класс или интерфейс, если потребуется расширение функциональности. Метод displayRaceInformation отображает информацию о гонке, включая информацию о расстоянии и информацию о машинах. Опять же, это отдельная ответственность, которая может быть выделена в отдельный класс или интерфейс.

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

---

Class RaceManager

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

• startRace(Race race): Этот метод запускает гонку. Он вызывает метод preparingForTheRace для подготовки к гонке, выводит сообщение о начале гонки, вызывает метод logicOfTheRace у объекта race для выполнения логики гонки, вызывает метод changePointAndDistance для изменения очков и расстояния автомобиля, выводит сообщение о завершении гонки и вызывает метод print у объекта Menu.

• preparingForTheRace(Race race): Этот метод подготавливает гонку. Он генерирует случайный автомобиль с помощью метода generateCar, устанавливает расстояние гонки с помощью метода generateInt, и отображает информацию о гонке с помощью объекта informationManager.

• changePointAndDistance(Car car, int points, int distance): Этот метод изменяет очки и расстояние автомобиля. Он увеличивает очки автомобиля на значение points и увеличивает пройденное расстояние автомобиля на значение distance.

• generateCar(): Этот метод генерирует случайный автомобиль. Он генерирует случайные значения для максимальной скорости, ускорения и уровня нитро с помощью метода generateInt, и создает новый объект Car с этими значениями.

• generateInt(int from, int to): Этот метод генерирует случайное целое число в заданном диапазоне. Он вычисляет разницу между to и from, генерирует случайное число в этом диапазоне с помощью объекта random, и возвращает результат.

Class RaceManager соответствует принципам SOLID, а именно:

• Принцип единственной ответственности (Single Responsibility Principle - SRP):
  Class RaceManager отвечает только за управление гонкой и несет ответственность только за одну обязанность - запуск и управление гонкой. Он содержит методы для подготовки к гонке, изменения очков и расстояния, генерации автомобиля и чисел. Это позволяет классу быть легко понятным, изменяемым и тестируемым.

• Принцип открытости/закрытости (Open/Closed Principle - OCP):
  Class RaceManager открыт для расширения (новые функции могут быть добавлены путем создания новых методов), но закрыт для изменения (существующий код не требует изменений при добавлении новых функций). Например, можно добавить новые методы для управления гонкой, не изменяя существующий код class RaceManager.

• Принцип подстановки Барбары Лисков (Liskov Substitution Principle - LSP):
  Class RaceManager использует абстракцию Race для запуска гонки. Это означает, что любой подкласс, который наследует от Race, может быть использован вместо Race без изменения поведения class RaceManager. Например, если бы был создан подкласс ElectricRace, он мог бы быть использован вместо Race без изменения метода startRace в class RaceManager.

• Принцип разделения интерфейса (Interface Segregation Principle - ISP):
  Class RaceManager не реализует интерфейсы, но он имеет только одну обязанность - управление гонкой. Это позволяет избежать зависимости от ненужных методов или интерфейсов, которые не используются в классе.

• Принцип инверсии зависимостей (Dependency Inversion Principle - DIP):
  Class RaceManager зависит от абстракции RaceInformationManager, а не от конкретной реализации. Это позволяет легко заменить RaceInformationManager на другую реализацию без изменения кода class RaceManager.

В целом, class RaceManager соответствует принципам SOLID, что делает его гибким, расширяемым и легко поддерживаемым.

---

Class Game

Class Game представляет игру и содержит методы для запуска и управления игрой.

В методе start() происходит инициализация игры, выводится приветственное сообщение, создается объект Race и RaceManager, а также выводится информация о машине игрока. Затем вызывается метод Menu.print() для отображения меню игры, и запускается метод loop(), который обрабатывает ввод пользователя и выполняет соответствующие действия в зависимости от выбранного пункта меню.

Метод loop() содержит бесконечный цикл, в котором считывается ввод пользователя с помощью объекта Scanner. Затем с помощью метода Menu.getMenuByCod() определяется выбранный пункт меню. Если выбранный пункт меню не существует, используется пункт меню по умолчанию. Затем с помощью оператора switch выполняются соответствующие действия в зависимости от выбранного пункта меню. Если выбран пункт меню "START_RACE", вызывается метод raceManager.startRace(race), если выбран пункт меню "SHOW_STATISTICS", выводятся результаты гонки с помощью метода race.printRaceResults(), если выбран пункт меню "STOP_GAME", выводится сообщение "SEE_YOU" и цикл завершается. Если выбран пункт меню по умолчанию или выбран несуществующий пункт меню, выводится заголовок пункта меню по умолчанию.

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

Данный class Game соответствует принципам SOLID следующим образом:

• Принцип единственной ответственности (Single Responsibility Principle):
  Class Game отвечает только за управление игрой и несет ответственность только за одну функцию - запуск и управление игрой. Он не занимается непосредственно выполнением гонок или выводом статистики, а делегирует эти задачи другим классам (RaceManager, RaceInformationManager, Menu).

• Принцип открытости/закрытости (Open/Closed Principle):
  Class Game закрыт для изменений, так как его основная функциональность уже реализована. Однако, он открыт для расширения, так как можно добавить новые функции или изменить поведение игры, не изменяя сам class Game.

• Принцип подстановки Барбары Лисков (Liskov Substitution Principle):
  Class Game использует абстракции (Race, RaceManager, RaceInformationManager, Menu) вместо конкретных реализаций. Это позволяет подставлять различные реализации этих абстракций без изменения кода class Game.

• Принцип разделения интерфейса (Interface Segregation Principle):
  Class Game не зависит от конкретных методов или свойств абстракций, которые он использует. Он взаимодействует только с общим интерфейсом, предоставляемым этими абстракциями.

• Принцип инверсии зависимостей (Dependency Inversion Principle):
  Class Game зависит от абстракций (Race, RaceManager, RaceInformationManager, Menu), а не от конкретных реализаций. Это позволяет легко заменять или добавлять новые реализации этих абстракций без изменения class Game.

---

Class CarRaceApp

Class CarRaceApp является точкой входа в приложение гонки автомобилей. Он содержит метод main, который является статическим и принимает массив строк args в качестве параметра. Внутри метода main создается экземпляр class Game с именем game. Затем вызывается метод start на объекте game, чтобы начать игру.