Основы ООП в Java

Глава 7. Принципы проектирования и хорошего кода

DRY, KISS, YAGNI

DRY: Не повторяйся

DRY (Don't Repeat Yourself — Не повторяйся) — это принцип, который требует избегать дублирования кода, логики или данных в программе. Если один и тот же фрагмент повторяется в нескольких местах, его нужно вынести в общий элемент, чтобы изменения в одном месте автоматически отражались везде.

Почему важно: Дублирование приводит к ошибкам — если нужно исправить логику, вы рискуете забыть обновить все копии. Это усложняет поддержку кода и увеличивает его объем.
Как применять в Java: Выносите общую логику в методы, классы или утилиты. Используйте наследование, композицию или библиотеки.

Пример нарушения DRY:
Два метода в классе Calculator, которые дублируют расчет площади:

public class Calculator {
    // Нарушение: Дублирование
    public double circleArea(double radius) {
        return 3.14159 * radius * radius;
    }

    public double circleVolume(double radius, double height) {
        return 3.14159 * radius * radius * height;  // Тот же расчет площади
    }
}

Исправление: Выносите общую часть в метод:

public class Calculator {
    // Правильно: Общий метод
    private double calculateCircleBase(double radius) {
        final double PI = 3.14159;
        return PI * radius * radius;
    }

    public double circleArea(double radius) {
        return calculateCircleBase(radius);
    }

    public double circleVolume(double radius, double height) {
        return calculateCircleBase(radius) * height;
    }
}

Нюансы:
Не путайте с WET (We Enjoy Typing — Мы любим печатать) — саркастический термин для дублирующего кода.
В ООП: Используйте абстрактные классы или интерфейсы для общих шаблонов.
В Java: Константы в enum или static final для общих значений.
Ловушка: Избыточная абстракция — не выносите, если код используется редко (связано с YAGNI).


KISS: Делай просто

KISS (Keep It Simple, Stupid — Делай просто, глупец) — принцип, который призывает к простоте в дизайне кода, алгоритмах и архитектуре. Вместо сложных конструкций выбирайте простые решения, которые легко понять и поддерживать.

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

Пример нарушения KISS:
Сложный расчет с лишними классами:

// Нарушение: Избыточная сложность
public class ComplexCalculator {
    public double calculate(double a, double b) {
        AdvancedMathUtils utils = new AdvancedMathUtils();
        return utils.performAdvancedOps(new OperationContext(a, b)).getResult();
    }
}

// Куча лишних классов...
Исправление: Простой метод:
javapublic class SimpleCalculator {
    public double calculate(double a, double b) {
        return Math.sqrt(a * a + b * b);  // Прямо и ясно
    }
}

Нюансы:
"Глупец" в аббревиатуре — напоминание, что простота побеждает "умные" хаки.
В ООП: Предпочитайте композицию над глубоким наследованием.
В Java: Используйте Stream API для простых операций, но не для всего.
Ловушка: Простота не значит примитивность — балансируйте с читаемостью.


#Java #для_новичков #beginner #OOP #DRY #KISS #YAGNI

YAGNI: Тебе это не понадобится

YAGNI (You Ain't Gonna Need It — Тебе это не понадобится) — принцип, который предупреждает против добавления функциональности заранее, на основе предположений о будущем. Реализуйте только то, что нужно сейчас, чтобы избежать переусложнения.

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

Пример нарушения YAGNI:
Класс с "будущими" методами:

// Нарушение: Лишние методы "на всякий случай"
public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public void sendEmail() { /* Пока пусто */ }
    public void sendSMS() { /* Пока пусто */ }
    public void integrateWithAPI() { /* Пока пусто */ }
}
Исправление: Только необходимое:
javapublic class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    // Только базовая функциональность
    public String getName() {
        return name;
    }
}

Нюансы:
Связано с принципом "You Are Not Gonna Need It" — фокус на MVP (минимально жизнеспособном продукте).
В ООП: Не создавайте абстрактные классы "на будущее" — реализуйте, когда нужно.
В Java: Избегайте over-engineering в дизайне (например, Factory для простых объектов).
Ловушка: YAGNI не значит игнорировать планирование — используйте TDD (тест-драйвен разработку) для роста.


Полезные советы для новичков

DRY: Ищите дубли — рефакторьте в методы или утилиты.
KISS: Читайте код через день — если не понятно, упростите.
YAGNI: Задавайте: "Нужно ли это прямо сейчас?"
В Java: Используйте IDE для рефакторинга (Extract Method для DRY).
Ресурсы: Книга "Чистый код" Роберта Мартина — классика по этим принципам.


#Java #для_новичков #beginner #OOP #DRY #KISS #YAGNI

Основы ООП в Java

Глава 7. Принципы проектирования и хорошего кода

Композиция vs Наследование

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

Наследование:
Механизм, при котором класс (подкласс) наследует поля, методы и поведение от другого класса (суперкласса) с помощью ключевого слова extends. Это воплощает отношение "является" (is-a). Например, Dog является Animal.

Композиция:
Механизм, при котором класс содержит объекты других классов как поля, используя их функциональность. Это воплощает отношение "имеет" (has-a). Например, Car имеет Engine.

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


Наследование: Когда использовать и проблемы

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

Пример наследования:

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void makeSound() {
        System.out.println(name + " издает звук.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " лает: Гав!");
    }
}

Когда использовать:
Есть четкое is-a отношение: Dog — это Animal.
Нужно переопределить или расширить поведение (через override).
Полиморфизм: Работа с подклассами через ссылку на суперкласс (Animal[] animals).

Преимущества:
Простота: Код автоматически наследуется.
Полиморфизм: Легко реализовать через override.
Иерархия: Удобно для моделирования реальных сущностей (например, Животное → Млекопитающее → Собака).

Недостатки:
Жесткая связь: Подкласс привязан к суперклассу — изменения в суперклассе могут сломать подклассы.
Хрупкий базовый класс: Изменение метода в суперклассе может неожиданно повлиять на подклассы.
Ограничение Java: Только одиночное наследование (один extends).
Сложность в глубоких иерархиях: Много уровней наследования трудно поддерживать.
Нарушение инкапсуляции: Подклассы могут зависеть от внутренней реализации.
Пример проблемы: Если добавить метод в Animal, который не подходит для всех подклассов (например, fly()), подклассы вроде Dog окажутся в неудобном положении.


Композиция: Когда использовать и преимущества

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

Пример композиции:

public class Engine {
    private int horsepower;

    public Engine(int horsepower) {
        this.horsepower = horsepower;
    }

    public void start() {
        System.out.println("Двигатель с " + horsepower + " л.с. запущен.");
    }
}

public class Car {
    private String model;
    private Engine engine;  // Композиция: Car "имеет" Engine

    public Car(String model, Engine engine) {
        this.model = model;
        this.engine = engine;
    }

    public void drive() {
        engine.start();
        System.out.println(model + " едет.");
    }
}

Использование:

public class Main {
    public static void main(String[] args) {
        Engine engine = new Engine(200);
        Car car = new Car("Toyota", engine);
        car.drive();  // Двигатель с 200 л.с. запущен. Toyota едет.
    }
}

Когда использовать:
Отношения: Car имеет Engine, а не является им.
Нужно гибкое сочетание функциональности без жесткой связи.
Требуется заменяемость компонентов (например, разные двигатели).

Преимущества:
Гибкость: Легко заменить компонент (например, Engine на ElectricEngine).
Слабая связь: Изменения в Engine не ломают Car, если интерфейс сохранен.
Инкапсуляция: Car скрывает детали Engine, управляя доступом.
Модульность: Компоненты можно использовать в других классах.
Тестирование: Легче подменять компоненты (mocking) для тестов.

#Java #для_новичков #beginner #OOP #Composition #Extends

Недостатки:
Больше кода: Нужно явно создавать и передавать компоненты.
Сложнее полиморфизм: Требуются интерфейсы для единообразия.


Композиция vs Наследование: Как выбирать

Выбирайте композицию, если:
Нет четкого is-a отношения, а скорее has-a.
Нужна гибкость: Компоненты могут меняться (например, разные реализации Engine).
Хотите избежать жесткой связи или хрупкого базового класса.
Нужно реализовать поведение, которое не должно быть частью иерархии.

Выбирайте наследование, если:
Есть четкое is-a отношение, и подкласс логично расширяет суперкласс.
Нужен полиморфизм через ссылки на суперкласс.
Иерархия простая (1-2 уровня).

Пример: Композиция вместо наследования:

Наследование (проблема):

public class Vehicle {
    public void move() {
        System.out.println("Движется с помощью двигателя.");
    }
}

public class Car extends Vehicle {
    // Проблема: А если электромобиль или велосипед?
}

Композиция (решение):
public interface Movable {
    void move();
}

public class EngineMovable implements Movable {
    @Override
    public void move() {
        System.out.println("Движется с помощью двигателя.");
    }
}

public class Car {
    private Movable movement;

    public Car(Movable movement) {
        this.movement = movement;
    }

    public void drive() {
        movement.move();
    }
}

Теперь Car может использовать любой Movable (двигатель, электромотор), без привязки к иерархии.

Все нюансы

Наследование:
Жесткая связь: Подкласс зависит от реализации суперкласса.
Проблема ромба: В Java избежана (одиночное наследование), но множественное через интерфейсы.
Нюанс: Переопределение может нарушить контракт (Liskov Substitution Principle).

Композиция:
Требует интерфейсов для полиморфизма (например, Movable).
Нюанс: Больше кода для передачи компонентов (конструктор, сеттеры).
Делегирование: Car вызывает методы Engine — это нормально.

Когда комбинировать:
Используйте наследование для базовой структуры, композицию для поведения.
Пример: extends AbstractVehicle, но Engine как поле.

Ошибки:
Наследование вместо композиции: Глубокие иерархии или неподходящие is-a.
Композиция без интерфейсов: Теряется полиморфизм.

Дизайн:
Композиция соответствует принципу KISS (меньше связей).
Наследование — YAGNI: Не создавайте иерархии "на будущее".
DRY: Оба подхода помогают повторно использовать код.

Java-специфика:
Интерфейсы + default методы часто заменяют наследование.
Dependency Injection (Spring) — пример композиции.


Как создать это в IntelliJ IDEA

Композиция: Создайте интерфейс (New → Interface), класс с полем и методами.
Наследование: New → Class, укажите extends, IDE поможет override.
Рефакторинг: Extract Interface для перехода от наследования к композиции.


Полезные советы для новичков

Композиция по умолчанию: Если сомневаетесь, начните с has-a.
Проверяйте is-a: Dog is-an Animal? Да. Car is-an Engine? Нет.
Интерфейсы для гибкости: Комбинируйте композицию с интерфейсами.
Избегайте глубоких иерархий: Не больше 2-3 уровней.


#Java #для_новичков #beginner #OOP #Composition #Extends

Коллекции в Java

Глава 1. Введение в коллекции

Обзор Java Collections Framework. Интерфейсы Collection и Map. Иерархия коллекций. Отличия коллекций от массивов

Java Collections Framework (JCF) — это набор интерфейсов, классов и алгоритмов в пакете java.util, предназначенный для работы с коллекциями данных. JCF предоставляет унифицированный способ хранения и манипуляции объектами, делая код более гибким и эффективным.

- Компоненты JCF:
- Интерфейсы: Определяют контракт (что можно делать с коллекцией).
- Реализации: Конкретные классы, реализующие интерфейсы (например, ArrayList для List).
- Алгоритмы: Встроенные методы для сортировки, поиска и т.д. (в классе Collections).

JCF введен в Java 1.2 и значительно улучшен в Java 5 с generics (обобщениями), которые обеспечивают типобезопасность.

- Преимущества JCF:
- Гибкость: Динамический размер, в отличие от массивов.
- Типобезопасность: С generics — компилятор проверяет типы.
- Эффективность: Разные реализации для разных сценариев (быстрый доступ, уникальность элементов и т.д.).
- Полиморфизм: Работа через интерфейсы, легко менять реализации.


Интерфейсы Collection и Map

JCF построен вокруг двух основных интерфейсов: Collection для последовательностей объектов и Map для пар ключ-значение.

1. Интерфейс Collection<E>:
- Это базовый интерфейс для коллекций, где E — тип элементов (generics).
- Представляет группу объектов, позволяя добавлять, удалять, перебирать.
- Не гарантирует порядок или уникальность — зависит от реализации.

- Основные методы:
- add(E e): Добавляет элемент.
- remove(Object o): Удаляет элемент.
- size(): Возвращает размер.
- isEmpty(): Проверяет пустоту.
- iterator(): Для перебора (Iterator).
- contains(Object o): Проверяет наличие.

- Нюанс: Collection не индексирован (нет get(int index)), для этого — подинтерфейсы как List.

2. Интерфейс Map<K, V>:
- Представляет отображение: пары ключ-значение, где K — тип ключа, V — тип значения.
- Ключи уникальны, значения могут дублироваться.
- Не является подтипом Collection (Map не коллекция элементов, а ассоциация).

- Основные методы:
- put(K key, V value): Добавляет/обновляет пару.
- get(Object key): Возвращает значение по ключу.
- remove(Object key): Удаляет по ключу.
- size(), isEmpty().
- keySet(): Коллекция ключей (Set<K>).
- values(): Коллекция значений (Collection<V>).
- entrySet(): Коллекция пар (Set<Map.Entry<K, V>>).

- Нюанс: Map не упорядочен (кроме SortedMap), ключи не null (в большинстве реализаций).


#Java #для_новичков #beginner #Collections #Map

Иерархия коллекций в JCF

JCF имеет иерархию интерфейсов и реализаций. Вот подробная структура:

1. Иерархия Collection:

- Collection<E> (базовый):
- List<E>: Упорядоченная коллекция, позволяет дубликаты, индексация.
- Реализации: ArrayList (быстрый доступ), LinkedList (быстрые вставки/удаления), Vector (устаревший, synchronized).
- Set<E>: Неупорядоченная коллекция уникальных элементов.
- Реализации: HashSet (быстрый поиск), TreeSet (отсортированный), LinkedHashSet (сохраняет порядок вставки).
- Queue<E>: Для очередей (FIFO), или приоритетных.
- Реализации: LinkedList (как Queue), PriorityQueue (приоритетная), ArrayDeque (deque).
- Deque<E>: Двусторонняя очередь (добавление/удаление с обоих концов).
- Реализации: ArrayDeque, LinkedList.

2. Иерархия Map:

- Map<K, V> (базовый):
- HashMap<K, V>: Быстрый поиск по хэшу, не упорядочен.
- TreeMap<K, V>: Отсортированный по ключам (SortedMap).
- LinkedHashMap<K, V>: Сохраняет порядок вставки.
- Hashtable<K, V>: Устаревший, synchronized.

- Generics: С Java 5: Collection<String> list = new ArrayList<>(); — типобезопасно.

- Нюансы иерархии:
- Все реализации — concrete классы, кроме абстрактных helper-классов (AbstractList).
- Synchronized: Для многопоточности используйте Collections.synchronized*() или Concurrent* классы (ConcurrentHashMap).
- Performance: Выбирайте по нуждам — HashSet O(1) поиск, TreeSet O(log n) с сортировкой.
- Immutability: Collections.unmodifiable*() для read-only коллекций.


Отличия коллекций от массивов

Массивы — базовый тип в Java для хранения элементов фиксированного размера. Коллекции — более гибкий инструмент из JCF.

- Подробное сравнение:
1. Размер:
- Массивы: Фиксированный (int[] arr = new int[10]; — нельзя изменить).
- Коллекции: Динамический (ArrayList.add() расширяет автоматически).

2. Типы элементов:
- Массивы: Могут хранить примитивы (int[]) или объекты.
- Коллекции: Только объекты (Collection<Integer> для примитивов через wrapper).

3. Методы:
- Массивы: Ограничены (длина .length, доступ по индексу).
- Коллекции: Богатый API (add, remove, contains, sort, iterator).

4. Generics:
- Массивы: Нет (Object[] может хранить всё, но без проверки).
- Коллекции: С generics — типобезопасно (компилятор проверяет).

5. Performance:
- Массивы: Быстрее для фиксированного размера и примитивов.
- Коллекции: Overhead, но удобнее; ArrayList близок к массиву.

6. Многомерность:
- Массивы: Легко (int[][]).
- Коллекции: Вложенные (List<List<Integer>>).

7. Null и дубликаты:
- Оба позволяют, но Set в коллекциях запрещает дубликаты.

Пример перехода от массива к коллекции:

Массив:

String[] names = new String[3];
names[0] = "Алексей";
// Нет add, нужно вручную управлять размером

Коллекция:

List<String> names = new ArrayList<>();
names.add("Алексей");  // Динамично
names.remove(0);       // Легко удалить

- Нюанс: Коллекции используют массивы внутри (ArrayList — resizable array).


Как работать с JCF в IntelliJ IDEA

1. Импорт: Импортируйте java.util.* или конкретно (IDE подскажет Ctrl+Space).
2. Generics: Напишите List<String> — IDE проверит типы.
3. Коллекции: New → Collection → Выберите реализацию.
4. Методы: Автодополнение для add, remove и т.д.
5. Debug: В отладке смотрите содержимое коллекций.


Полезные советы для новичков

- Выбирайте интерфейс: Кодьте под List, а не ArrayList — легко сменить реализацию.
- Generics всегда: Избегайте raw types (List без <E> — устарело).
- Коллекции vs массивы: Массивы для фиксированных примитивов, коллекции для всего остального.
- Performance: ArrayList для доступа, LinkedList для вставок, HashSet для уникальности.


#Java #для_новичков #beginner #Collections #Map

Коллекции в Java

Глава 1. Введение в коллекции

Основные характеристики коллекций: время доступа (Big O), хранение уникальных элементов, упорядоченность и сортировка

Big O (или O-нотация) — это математическая нотация, которая описывает, как растет время выполнения операции (или использование памяти) в зависимости от размера данных (n — количество элементов). Она оценивает "наихудший случай" и помогает сравнивать эффективность коллекций.

Основные обозначения Big O:
- O(1): Постоянное время — операция не зависит от размера (например, доступ по индексу в массиве).
- O(log n): Логарифмическое время — быстро растет, но эффективно (например, поиск в отсортированном дереве).
- O(n): Линейное время — пропорционально размеру (например, перебор списка).
- O(n log n): Для сортировки (например, TreeSet).
- O(n²): Квадратичное — медленно для больших n (избегайте).

Для коллекций Big O применяется к основным операциям: добавление (add), удаление (remove), поиск (contains/get), вставка.

Почему важно: Выбор коллекции влияет на производительность. Для миллионов элементов O(1) лучше O(n).


Хранение уникальных элементов

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

Коллекции с уникальными элементами:
- Интерфейс Set<E>: Не позволяет дубликаты. Если добавить существующий элемент, он игнорируется (add() возвращает false).
- Пример: HashSet, TreeSet, LinkedHashSet.
- Нюанс: Уникальность определяется методом equals() и hashCode() (для HashSet). Переопределите их для custom классов.

Коллекции с дубликатами:
- Интерфейс List<E>: Позволяет дубликаты и хранит их в порядке вставки.
- Пример: ArrayList, LinkedList.
- Queue<E> и Deque<E>: Могут позволять дубликаты, в зависимости от реализации.

- Map<K, V>: Ключи уникальны (как Set), значения могут дублироваться.

Пример кода для уникальности:

import java.util.HashSet;
import java.util.Set;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Set: Уникальные элементы
        Set<String> uniqueNames = new HashSet<>();
        uniqueNames.add("Алексей");
        uniqueNames.add("Алексей");  // Игнорируется
        System.out.println(uniqueNames.size());  // 1

        // List: Дубликаты разрешены
        List<String> names = new ArrayList<>();
        names.add("Алексей");
        names.add("Алексей");
        System.out.println(names.size());  // 2
    }
}

- Нюанс: Для custom объектов в Set переопределите equals() и hashCode(), иначе дубликаты возможны (сравнение по ссылке).

#Java #для_новичков #beginner #Collections #BigO

Упорядоченность элементов

Упорядоченность — это сохранение порядка элементов (по вставке или сортировке).

Коллекции с порядком вставки:
- List<E>: Всегда упорядочены по индексу (порядок добавления).
- Пример: ArrayList, LinkedList.
- LinkedHashSet<E>: Set с порядком вставки.
- LinkedHashMap<K, V>: Map с порядком вставки.

Коллекции без порядка:
- HashSet<E>: Не гарантирует порядок (зависит от хэша).
- HashMap<K, V>: Не упорядочен.

Отсортированные коллекции: Подробнее в разделе о сортировке.

Пример:

import java.util.HashSet;
import java.util.LinkedHashSet;

public class Main {
    public static void main(String[] args) {
        // HashSet: Без порядка
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Яблоко");
        hashSet.add("Банан");
        hashSet.add("Апельсин");
        System.out.println(hashSet);  // Может быть [Банан, Яблоко, Апельсин] — непредсказуемо

        // LinkedHashSet: Порядок вставки
        Set<String> linkedSet = new LinkedHashSet<>();
        linkedSet.add("Яблоко");
        linkedSet.add("Банан");
        linkedSet.add("Апельсин");
        System.out.println(linkedSet);  // [Яблоко, Банан, Апельсин] — сохраняет порядок
    }
}

- Нюанс: Порядок в HashSet может меняться при ресайзе (rehashing), так что не полагайтесь на него.


Сортировка элементов

Сортировка — это автоматическое упорядочивание элементов по какому-то критерию (натуральный порядок или Comparator).

Отсортированные коллекции:
- SortedSet<E> (подинтерфейс Set): Уникальные, отсортированные элементы.
- Реализация: TreeSet<E> — использует красно-черное дерево.
- SortedMap<K, V> (подинтерфейс Map): Отсортированные ключи.
- Реализация: TreeMap<K, V>.

Как работает сортировка:
- Элементы должны быть Comparable<E> (метод compareTo()) для натурального порядка (числа по возрастанию, строки по алфавиту).
- Или используйте Comparator при создании: new TreeSet<>(comparator).
- Нюанс: Добавление/поиск — O(log n), так как дерево балансировано.

Пример TreeSet:

import java.util.TreeSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<Integer> numbers = new TreeSet<>();
        numbers.add(5);
        numbers.add(1);
        numbers.add(3);
        System.out.println(numbers);  // [1, 3, 5] — отсортировано

        // Custom Comparator для обратного порядка
        Set<Integer> reverseNumbers = new TreeSet<>((a, b) -> b - a);
        reverseNumbers.add(5);
        reverseNumbers.add(1);
        reverseNumbers.add(3);
        System.out.println(reverseNumbers);  // [5, 3, 1]
    }
}

- Нюанс: TreeSet не позволяет null (NullPointerException), так как сравнивает элементы.
Для сортировки существующих коллекций используйте Collections.sort(List list) или List.sort(Comparator).


Полезные советы для новичков

- Big O в практике: Для малого n (сотни элементов) разница мала, но для миллионов — критична (выберите HashSet для быстрого contains).
- Уникальность: Set для словарей, List для списков с повторами.
- Упорядоченность: Linked* для сохранения вставки, Tree* для автосортировки.
- Сортировка: TreeSet/Map для постоянной сортировки; Collections.sort() для разовой.
- Ошибки: Null в TreeSet — NPE; дубли в Set — игнор.
- Ресурсы: Java API docs для java.util.


#Java #для_новичков #beginner #Collections #BigO

Раздел 6. Коллекции в Java

Глава 1. Введение в коллекции

(Практика):
Начать проект «Библиотека».
Создать класс Book с полями title, author, year.
Сделать список книг (пока как массив) и вывести их на экран

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

Запустите IntelliJ IDEA:
Если IDE не открыта, запустите её. Убедитесь, что у вас установлен JDK. Если проект новый, выберите "New Project" на приветственном экране.

Создайте новый проект:
В окне создания проекта выберите "Java" как тип.
Укажите имя проекта, например, "LibraryProject".
Выберите JDK в поле Project SDK (если не настроено, добавьте путь к JDK).
Оставьте остальные настройки по умолчанию (без Maven или Gradle для простоты) и нажмите "Create".
IDE создаст структуру проекта с папкой src для исходного кода.

Настройте структуру проекта:
В дереве проекта (слева) найдите src.
Если нужно, создайте пакет для организации кода: Правой кнопкой на src → New → Package → Назовите "library" (или другое имя). Это хорошая практика для группировки классов.

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

Создайте класс Book:
В пакете (или прямо в src, если без пакета) щелкните правой кнопкой → New → Java Class.
Назовите класс "Book".
IDE создаст файл Book.java с базовой структурой

public class Book {}

Добавьте поля:
В теле класса объявите три приватных поля:
title типа String (для названия книги).
author типа String (для автора).
year типа int (для года издания).

Используйте модификатор private для инкапсуляции, как мы изучали в ООП.

Добавьте конструктор:
Создайте публичный конструктор, который принимает три параметра (String title, String author, int year) и присваивает их соответствующим полям с помощью this.
Это позволит создавать объекты Book с начальными значениями.

Добавьте метод для вывода:
Создайте публичный метод, например, printDetails(), который выводит информацию о книге на экран с помощью System.out.println.
В нём используйте поля для формирования строки вроде "Название: [title], Автор: [author], Год: [year]".


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

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

Создайте класс Main:
Аналогично создайте новый класс "Main" в том же пакете.
Добавьте статический метод main(String[] args) — точку входа.

Объявите массив:
В методе main объявите массив объектов Book фиксированного размера, например, Book[] books = new Book[3]; (размер выберите небольшой для теста).

Инициализируйте массив:
Создайте несколько объектов Book с помощью new Book(title, author, year) и присвойте их элементам массива (books[0] = new Book(...); и т.д.).
Используйте разные значения для демонстрации (например, книги разных авторов и годов).

Выведите список на экран:
Используйте цикл for (или for-each: for (Book book : books)) для перебора массива.
В цикле вызовите метод printDetails() для каждого элемента, чтобы вывести информацию о книгах.

#Java #для_новичков #beginner #Collections #Практика

Тестирование и отладка проекта

После реализации протестируйте проект, чтобы убедиться, что всё работает.

Запустите проект:
Правой кнопкой на файле Main.java → Run 'Main.main()'.
В консоли IDE вы должны увидеть вывод списка книг с их деталями.

Отладка:
Если ошибки: Проверьте синтаксис (точки с запятой, скобки).
Используйте отладчик: Установите breakpoint (красная точка слева от строки в main), запустите в debug-режиме (Shift+F9) и шагайте по коду (F8).
Общие проблемы: NullPointerException (если массив не инициализирован), IndexOutOfBoundsException (если выход за пределы массива).

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


Полезные советы для новичков

Организация кода: Используйте пакеты для группировки (например, library.models для Book).
Инкапсуляция: Даже в простом проекте делайте поля private и добавьте геттеры/сеттеры, если нужно изменять.
Массивы vs коллекции: Заметьте ограничения массива (фиксированный размер, ручное управление) — в следующих уроках заменим на ArrayList.
Комментарии: Добавляйте // комментарии к шагам, чтобы код был читаемым.
Версионирование: Если используете Git, создайте репозиторий и закоммитьте начальную версию проекта.
Ресурсы: Документация Oracle по классам и массивам для напоминания синтаксиса.


Практическое задание

Задача 1: Расширьте класс Book, добавив приватное поле isbn (String) и обновите конструктор и метод printDetails() для его включения.
Задача 2: Увеличьте массив до 5 элементов, добавьте больше книг и убедитесь, что вывод работает.
Задача 3: Попробуйте вывести только книги после определенного года — используйте if в цикле перебора массива.

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

#Java #для_новичков #beginner #Collections #Практика