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

Добавление объектов разных классов в массив

Проблема

Обычный массив в Java типизирован на один конкретный класс:

String[] arr = new String[3];
arr[0] = "Hello";
arr[1] = "World";
arr[2] = 123; // Ошибка компиляции! Тип несовместим

Как добавить объекты разных классов в один массив? Нужен общий тип.

Решение 1: Использовать Object (базовый класс)

Все классы в Java наследуют Object, поэтому можно создать массив Object:

Object[] arr = new Object[3];
arr[0] = "Hello";        // String
arr[1] = 42;             // Integer (автоупаковка int)
arr[2] = 3.14;           // Double
arr[3] = new Person("John"); // Custom class

// Использование
for (Object obj : arr) {
    System.out.println(obj.getClass().getSimpleName() + ": " + obj);
}

// Вывод:
// String: Hello
// Integer: 42
// Double: 3.14
// Person: John

Проблемы этого подхода:

• Теряешь информацию о типе при добавлении
• При доступе нужно кастить: String s = (String) arr[0]
• Нет безопасности типов

Решение 2: Интерфейс (правильный подход)

Определи интерфейс, который реализуют все классы:

// Интерфейс
public interface Shape {
    double getArea();
    String getType();
}

// Реализации
public class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public String getType() {
        return "Circle";
    }
}

public class Rectangle implements Shape {
    private double width;
    private double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double getArea() {
        return width * height;
    }
    
    @Override
    public String getType() {
        return "Rectangle";
    }
}

public class Triangle implements Shape {
    private double base;
    private double height;
    
    public Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }
    
    @Override
    public double getArea() {
        return (base * height) / 2;
    }
    
    @Override
    public String getType() {
        return "Triangle";
    }
}

// Использование
public class Main {
    public static void main(String[] args) {
        // Массив объектов разных классов (один интерфейс)
        Shape[] shapes = new Shape[3];
        
        shapes[0] = new Circle(5);
        shapes[1] = new Rectangle(4, 6);
        shapes[2] = new Triangle(3, 4);
        
        // Работа с массивом
        double totalArea = 0;
        for (Shape shape : shapes) {
            System.out.println(
                shape.getType() + " area: " + shape.getArea()
            );
            totalArea += shape.getArea();
        }
        
        System.out.println("Total area: " + totalArea);
    }
}

// Вывод:
// Circle area: 78.53981633974483
// Rectangle area: 24.0
// Triangle area: 6.0
// Total area: 108.53981633974483

Решение 3: Абстрактный класс

Альтернатива интерфейсу:

// Абстрактный базовый класс
public abstract class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public abstract void makeSound();
    
    public abstract String getType();
}

// Конкретные реализации
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
    
    @Override
    public String getType() {
        return "Dog";
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
    
    @Override
    public String getType() {
        return "Cat";
    }
}

public class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println("Tweet!");
    }
    
    @Override
    public String getType() {
        return "Bird";
    }
}

// Использование
public class ZooDemo {
    public static void main(String[] args) {
        // Массив разных животных
        Animal[] animals = new Animal[3];
        
        animals[0] = new Dog("Rex");
        animals[1] = new Cat("Whiskers");
        animals[2] = new Bird("Tweety");
        
        // Полиморфизм в действии
        for (Animal animal : animals) {
            System.out.println(animal.getType() + " " + animal.name);
            animal.makeSound();
        }
    }
}

// Вывод:
// Dog Rex
// Woof!
// Cat Whiskers
// Meow!
// Bird Tweety
// Tweet!

Решение 4: Дженерики (для type-safe коллекций)

Если нужна большая гибкость:

// Параметризованный тип
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 Demo {
    public static void main(String[] args) {
        // Контейнер для Shape
        Container<Shape> shapes = new Container<>();
        shapes.add(new Circle(5));
        shapes.add(new Rectangle(4, 6));
        shapes.add(new Triangle(3, 4));
        
        // Работа с типом
        for (Shape shape : shapes.getAll()) {
            System.out.println(shape.getType());
        }
    }
}

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

Что нужно описать: Шпаргалка

Для добавления 3 объектов разных классов в массив:

1. Определить общий тип (интерфейс или абстрактный класс)

   public interface CommonType { ... }
   

2. Реализовать этот тип в каждом классе

   public class ClassA implements CommonType { ... }
   public class ClassB implements CommonType { ... }
   public class ClassC implements CommonType { ... }
   

3. Создать массив общего типа

   CommonType[] arr = new CommonType[3];
   

4. Добавить объекты

   arr[0] = new ClassA();
   arr[1] = new ClassB();
   arr[2] = new ClassC();
   

5. Использовать полиморфизм

   for (CommonType obj : arr) {
       obj.commonMethod(); // Работает для всех
   }
   

Итог

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