Как Object отражает ООП

# Как Object отражает ООП (Object-Oriented Programming)

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

Object как вершина иерархии

┌─────────────────────────────────────┐
│          java.lang.Object           │
│  (корень всей иерархии)             │
├─────────────────────────────────────┤
│ Methods:                            │
│ + clone()                           │
│ + equals()                          │
│ + hashCode()                        │
│ + toString()                        │
│ + getClass()                        │
│ + notify() / notifyAll() / wait()   │
└─────────────────────────────────────┘
         ▲
         │ extends
         │
┌────────┴──────────┬───────────────┐
│                   │               │
String         HashMap          Thread

Все классы наследуют от Object:

public class User {  // Неявно extends Object
    private String name;
}

// Эквивалентно
public class User extends Object {
    private String name;
}

// Object есть везде
Object obj = new User();  // User IS-A Object

Object методы и ООП принципы

1. equals() - Инкапсуляция и переопределение

// В Object
public class Object {
    public boolean equals(Object obj) {
        return (this == obj);  // По умолчанию - сравнение по ссылке
    }
}

// Переопределение в User - переопределение (Overriding)
public class User {
    private String email;
    private String name;
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        
        User user = (User) obj;  // Полиморфизм
        return email.equals(user.email);  // Сравнение по содержанию
    }
}

// Использование
User user1 = new User("john@example.com", "John");
User user2 = new User("john@example.com", "John");

user1 == user2;              // false - разные объекты
user1.equals(user2);         // true - одинаковый email (переопределённый equals)

ООП принципы:

• Инкапсуляция - скрываем реализацию equals
• Наследование - наследуем от Object
• Полиморфизм - переопределяем equals для своей логики
• Абстракция - Object определяет contract, User реализует

2. hashCode() - Контракт и правила

public class Product {
    private String sku;
    private String name;
    
    @Override
    public int hashCode() {
        return Objects.hash(sku, name);  // Консистентно с equals
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Product product = (Product) obj;
        return sku.equals(product.sku) && name.equals(product.name);
    }
}

// ООП контракт: если a.equals(b) → a.hashCode() == b.hashCode()
Product p1 = new Product("SKU123", "Laptop");
Product p2 = new Product("SKU123", "Laptop");

p1.equals(p2);           // true
p1.hashCode() == p2.hashCode();  // ДОЛЖНО быть true!

// Для HashMap, HashSet
Set<Product> products = new HashSet<>();
products.add(p1);
products.add(p2);
products.size();  // 1 - только один! (одинаковый hashCode и equals)

ООП принципы:

• Абстракция - Object определяет контракт hashCode()
• Полиморфизм - каждый класс реализует по-своему
• Инкапсуляция - скрываем алгоритм вычисления хеша

3. toString() - Представление объекта

// В Object
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
    // Пример: com.example.User@a378f47
}

// Переопределение
public class Order {
    private Long id;
    private BigDecimal total;
    private OrderStatus status;
    
    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", total=" + total +
                ", status=" + status +
                '}';
    }
}

// Использование
Order order = new Order(1L, BigDecimal.valueOf(100), OrderStatus.PAID);
System.out.println(order);  // Order{id=1, total=100, status=PAID}

ООП принципы:

• Полиморфизм - println может работать с любым Object
• Абстракция - скрываем детали представления
• Переопределение - каждый класс показывает себя по-своему

4. clone() - Копирование объектов

public class Configuration implements Cloneable {
    private String name;
    private Map<String, String> settings;
    
    @Override
    public Configuration clone() throws CloneNotSupportedException {
        Configuration cloned = (Configuration) super.clone();
        // Глубокое копирование для коллекций
        cloned.settings = new HashMap<>(this.settings);
        return cloned;
    }
}

// Использование
Configuration original = new Configuration("prod");
original.getSetting().put("timeout", "30");

Configuration backup = original.clone();
original.getSetting().put("timeout", "60");

original.getSetting().get("timeout");  // "60"
backup.getSetting().get("timeout");    // "30" - отдельная копия

ООП принципы:

• Инкапсуляция - скрываем процесс клонирования
• Полиморфизм - каждый класс клонируется по-своему

5. getClass() - Reflection и Type информация

// Object предоставляет информацию о классе
public void printClassInfo(Object obj) {
    Class<?> clazz = obj.getClass();
    
    System.out.println("Класс: " + clazz.getName());
    System.out.println("Простое имя: " + clazz.getSimpleName());
    System.out.println("Простой ли класс: " + clazz.isInterface());
    
    // Получить все методы
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        System.out.println("  Метод: " + method.getName());
    }
    
    // Получить аннотации
    Annotation[] annotations = clazz.getAnnotations();
}

// Использование
User user = new User("John");
printClassInfo(user);  // Выведет информацию о User

ООП принципы:

• Рефлексия - Object даёт доступ к метаинформации
• Полиморфизм - один метод работает с любым Object

6. wait() / notify() / notifyAll() - Синхронизация

// Object предоставляет потокобезопасность
public class Producer implements Runnable {
    private List<Item> queue;
    
    public void produce(Item item) throws InterruptedException {
        synchronized (queue) {
            if (queue.size() >= MAX_SIZE) {
                queue.wait();  // Ожидаем пока потребитель заберёт
            }
            queue.add(item);
            queue.notifyAll();  // Уведомляем потребителя
        }
    }
}

public class Consumer implements Runnable {
    private List<Item> queue;
    
    public Item consume() throws InterruptedException {
        synchronized (queue) {
            while (queue.isEmpty()) {
                queue.wait();  // Ожидаем предмета
            }
            Item item = queue.remove(0);
            queue.notifyAll();  // Уведомляем производителя
            return item;
        }
    }
}

ООП принципы:

• Инкапсуляция - Object скрывает механизм синхронизации
• Полиморфизм - любой объект может быть монитором

Object и Полиморфизм

Object — отличный пример полиморфизма:

public void processAny(Object obj) {
    // Один метод работает со всеми типами!
    System.out.println(obj);       // toString()
    System.out.println(obj.hashCode());  // hashCode()
    
    if (obj instanceof String) {
        String str = (String) obj;
        System.out.println(str.toUpperCase());
    } else if (obj instanceof Number) {
        Number num = (Number) obj;
        System.out.println(num.doubleValue());
    }
}

// Вызовы
processAny("Hello");           // Работает
processAny(42);                // Работает
processAny(3.14);              // Работает
processAny(new User("John"));  // Работает

Object и Коллекции

Благодаря Object все коллекции универсальны:

// Списки могут содержать ЧТО УГОДНО
List<Object> items = new ArrayList<>();
items.add("String");
items.add(42);
items.add(new User("John"));
items.add(true);

// Но для типизации используем generics
List<String> names = new ArrayList<>();  // Безопаснее
List<User> users = new ArrayList<>();    // Типизировано

Иерархия методов Object

object.equals(obj)
   ↓ должен быть
object.hashCode()
   ↓
object.toString()  - представление для пользователя
   ↓
object.getClass() - информация о классе
   ↓
object.clone()    - копирование (если нужно)
   ↓
object.wait()/notify() - синхронизация (если нужно)

Заключение

Object отражает ООП следующим образом:

1. Наследование - все классы наследуют от Object
2. Полиморфизм - один код работает с любыми типами
3. Инкапсуляция - скрываем детали реализации (equals, hashCode, toString)
4. Абстракция - Object определяет контракт методов
5. Переопределение - каждый класс может переопределить методы Object

Object — это стержень Java как объектно-ориентированного языка.