Что нужно реализовать для добавления 3 объектов разных классов в массив?

Что нужно реализовать для добавления 3 объектов разных классов в массив

Чтобы добавить объекты разных классов в один массив, нужно использовать полиморфизм в Java. Есть несколько подходов.

Способ 1: Общий базовый класс (рекомендуется)

// 1. Создаём базовый класс
public abstract class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    // Абстрактный метод
    public abstract void makeSound();
    
    public String getName() {
        return name;
    }
}

// 2. Создаём подклассы
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " лает: Гав! Гав!");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " мяукает: Мяу!");
    }
}

public class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " поёт: Чирик-чирик!");
    }
}

// 3. Добавляем в массив базового типа
public class Main {
    public static void main(String[] args) {
        // Массив базового типа Animal
        Animal[] animals = new Animal[3];
        
        // Добавляем 3 разных типа объектов
        animals[0] = new Dog("Шарик");
        animals[1] = new Cat("Мурзик");
        animals[2] = new Bird("Чик");
        
        // Полиморфно вызываем метод
        for (Animal animal : animals) {
            animal.makeSound();  // Каждый издаёт свой звук
        }
        
        // Вывод:
        // Шарик лает: Гав! Гав!
        // Мурзик мяукает: Мяу!
        // Чик поёт: Чирик-чирик!
    }
}

Способ 2: Общий интерфейс

// 1. Создаём интерфейс
public interface Vehicle {
    void start();
    void stop();
    String getType();
}

// 2. Реализуем интерфейс
public class Car implements Vehicle {
    private String model;
    
    public Car(String model) {
        this.model = model;
    }
    
    @Override
    public void start() {
        System.out.println("Car " + model + " завелась");
    }
    
    @Override
    public void stop() {
        System.out.println("Car " + model + " остановилась");
    }
    
    @Override
    public String getType() {
        return "Car";
    }
}

public class Bike implements Vehicle {
    private String brand;
    
    public Bike(String brand) {
        this.brand = brand;
    }
    
    @Override
    public void start() {
        System.out.println("Bike " + brand + " готов к поездке");
    }
    
    @Override
    public void stop() {
        System.out.println("Bike " + brand + " припаркован");
    }
    
    @Override
    public String getType() {
        return "Bike";
    }
}

public class Truck implements Vehicle {
    private int capacity;
    
    public Truck(int capacity) {
        this.capacity = capacity;
    }
    
    @Override
    public void start() {
        System.out.println("Truck грузоподъёмностью " + capacity + " тонн начал работу");
    }
    
    @Override
    public void stop() {
        System.out.println("Truck паркуется");
    }
    
    @Override
    public String getType() {
        return "Truck";
    }
}

// 3. Используем интерфейс для массива
public class VehicleGarage {
    public static void main(String[] args) {
        // Массив интерфейса
        Vehicle[] vehicles = new Vehicle[3];
        
        // Добавляем разные типы
        vehicles[0] = new Car("BMW");
        vehicles[1] = new Bike("Yamaha");
        vehicles[2] = new Truck(20);
        
        // Полиморфный вызов
        for (Vehicle vehicle : vehicles) {
            vehicle.start();
            System.out.println("Тип: " + vehicle.getType());
            vehicle.stop();
            System.out.println();
        }
    }
}

Способ 3: Object (базовый класс всех классов)

// Можно использовать Object — базовый класс всех типов
public class ObjectArrayExample {
    public static void main(String[] args) {
        Object[] objects = new Object[3];
        
        // Добавляем разные типы
        objects[0] = new String("Hello");
        objects[1] = new Integer(42);
        objects[2] = new Double(3.14);
        
        // Нужна проверка типа
        for (Object obj : objects) {
            if (obj instanceof String) {
                System.out.println("String: " + obj);
            } else if (obj instanceof Integer) {
                System.out.println("Integer: " + obj);
            } else if (obj instanceof Double) {
                System.out.println("Double: " + obj);
            }
        }
    }
}

Способ 4: Использование List (более гибко)

// Вместо массива используем List — более удобно
public class AnimalShelter {
    public static void main(String[] args) {
        // List базового типа
        List<Animal> animals = new ArrayList<>();
        
        // Легко добавляем
        animals.add(new Dog("Рекс"));
        animals.add(new Cat("Гарфилд"));
        animals.add(new Bird("Попугай"));
        
        // Легко расширяем
        animals.add(new Dog("Бобик"));
        
        // Полиморфный вызов
        for (Animal animal : animals) {
            animal.makeSound();
        }
        
        // Фильтрация по типу
        List<Dog> dogs = animals.stream()
            .filter(a -> a instanceof Dog)
            .map(a -> (Dog) a)
            .collect(Collectors.toList());
        
        System.out.println("Собак в приюте: " + dogs.size());
    }
}

Способ 5: Generics (типобезопасно)

// Если нужна типобезопасность
public class Container<T> {
    private List<T> items = new ArrayList<>();
    
    public void add(T item) {
        items.add(item);
    }
    
    public List<T> getAll() {
        return items;
    }
}

public class GenericExample {
    public static void main(String[] args) {
        // Контейнер для животных
        Container<Animal> animalContainer = new Container<>();
        animalContainer.add(new Dog("Лайка"));
        animalContainer.add(new Cat("Мурка"));
        animalContainer.add(new Bird("Чик"));
        
        for (Animal animal : animalContainer.getAll()) {
            animal.makeSound();
        }
    }
}

Практический пример: система обработки платежей

// Интерфейс платежа
public interface Payment {
    void process(double amount);
    String getPaymentMethod();
}

// Реализации
public class CreditCard implements Payment {
    private String cardNumber;
    
    public CreditCard(String cardNumber) {
        this.cardNumber = cardNumber;
    }
    
    @Override
    public void process(double amount) {
        System.out.println("Обработка платежа по кредитной карте: " + amount);
    }
    
    @Override
    public String getPaymentMethod() {
        return "Credit Card";
    }
}

public class PayPal implements Payment {
    private String email;
    
    public PayPal(String email) {
        this.email = email;
    }
    
    @Override
    public void process(double amount) {
        System.out.println("Обработка платежа через PayPal (" + email + "): " + amount);
    }
    
    @Override
    public String getPaymentMethod() {
        return "PayPal";
    }
}

public class Bitcoin implements Payment {
    private String walletAddress;
    
    public Bitcoin(String walletAddress) {
        this.walletAddress = walletAddress;
    }
    
    @Override
    public void process(double amount) {
        System.out.println("Отправка Bitcoin (" + walletAddress + "): " + amount);
    }
    
    @Override
    public String getPaymentMethod() {
        return "Bitcoin";
    }
}

// Использование
public class PaymentProcessor {
    public static void main(String[] args) {
        // Массив различных способов оплаты
        Payment[] payments = new Payment[3];
        
        payments[0] = new CreditCard("1234-5678-9012-3456");
        payments[1] = new PayPal("user@example.com");
        payments[2] = new Bitcoin("1A1z7agoat2...");
        
        double amount = 100.0;
        
        // Обработка всех платежей
        for (Payment payment : payments) {
            System.out.println("Способ: " + payment.getPaymentMethod());
            payment.process(amount);
            System.out.println();
        }
    }
}

Сравнение подходов

┌────────────────────┬──────────────────┬───────────────────┐
│      Подход        │   Преимущества    │     Недостатки     │
├────────────────────┼──────────────────┼───────────────────┤
│ Базовый класс      │ ✅ Понятно        │ ⚠ Иерархия        │
│ Интерфейс          │ ✅ Гибко          │ ✅ Рекомендуется   │
│ Object             │ ⚠ Работает        │ ❌ Нужна проверка  │
│ List               │ ✅ Динамичен      │ ✅ Лучше чем массив│
│ Generics           │ ✅ Типобезопасно  │ ✅ Очень гибко     │
└────────────────────┴──────────────────┴───────────────────┘

Лучшие практики

1. Используй интерфейсы — более гибко и расширяемо
2. Избегай Object — используй полиморфизм
3. List вместо массива — гибче управлять
4. Правильная иерархия — понятная архитектура
5. Типобезопасность — используй Generics

Основная идея: в Java благодаря полиморфизму объекты разных классов могут храниться в массиве/контейнере их общего родителя (базовый класс или интерфейс).