В чем разница между классом, объектом и интерфейсом?

Разница между классом, объектом и интерфейсом

Это фундаментальные концепции объектно-ориентированного программирования в Java, и важно понимать различия между ними.

1. Класс

Определение: Класс — это шаблон или чертёж для создания объектов. Это тип данных, который определяет структуру и поведение объектов.

Характеристики:

• Существует только в исходном коде
• Определяет переменные (состояние) и методы (поведение)
• Не занимает память при объявлении
• Единица абстракции

Пример:

public class Car {
    // Переменные экземпляра (состояние)
    private String brand;
    private String model;
    private int year;
    private boolean isRunning;
    
    // Конструктор
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
        this.isRunning = false;
    }
    
    // Методы (поведение)
    public void start() {
        isRunning = true;
        System.out.println(brand + " " + model + " заведена");
    }
    
    public void stop() {
        isRunning = false;
        System.out.println(brand + " " + model + " выключена");
    }
    
    public String getInfo() {
        return brand + " " + model + " (" + year + ")";  
    }
}

2. Объект

Определение: Объект — это конкретный экземпляр класса, созданный в памяти во время выполнения программы.

Характеристики:

• Существует во время выполнения программы
• Занимает реальную память (heap)
• Имеет собственное состояние (значения переменных)
• Многие объекты могут быть созданы из одного класса
• Уничтожается сборщиком мусора, когда больше не используется

Пример:

public class Main {
    public static void main(String[] args) {
        // Создание объектов из класса Car
        Car car1 = new Car("Toyota", "Camry", 2023);
        Car car2 = new Car("BMW", "X5", 2022);
        Car car3 = new Car("Mercedes", "E-Class", 2023);
        
        // Каждый объект имеет собственное состояние
        car1.start(); // Toyota Camry заведена
        car2.start(); // BMW X5 заведена
        
        System.out.println(car1.getInfo()); // Toyota Camry (2023)
        System.out.println(car2.getInfo()); // BMW X5 (2022)
        System.out.println(car3.getInfo()); // Mercedes E-Class (2023)
        
        car1.stop(); // Toyota Camry выключена
        
        // car1, car2, car3 — это разные объекты с разным состоянием
    }
}

3. Интерфейс

Определение: Интерфейс — это контракт (договор), который определяет, какие методы должна реализовать класс. Это абстракция поведения.

Характеристики:

• Содержит только сигнатуры методов (в Java 8+ может содержать default методы)
• Не может быть инстанцирован (нельзя создать объект интерфейса)
• Класс может реализовать несколько интерфейсов (но только наследовать один класс)
• Определяет контракт без реализации
• Используется для полиморфизма

Пример:

// Интерфейс определяет контракт
public interface Vehicle {
    void start();
    void stop();
    String getInfo();
}

// Класс реализует интерфейс
public class Car implements Vehicle {
    private String brand;
    private String model;
    
    public Car(String brand, String model) {
        this.brand = brand;
        this.model = model;
    }
    
    @Override
    public void start() {
        System.out.println("Машина заведена");
    }
    
    @Override
    public void stop() {
        System.out.println("Машина выключена");
    }
    
    @Override
    public String getInfo() {
        return brand + " " + model;
    }
}

// Другой класс реализует тот же интерфейс
public class Bicycle implements Vehicle {
    @Override
    public void start() {
        System.out.println("Велосипед готов к поездке");
    }
    
    @Override
    public void stop() {
        System.out.println("Велосипед припаркован");
    }
    
    @Override
    public String getInfo() {
        return "Mountain Bike";
    }
}

// Полиморфизм в действии
public class Garage {
    public static void main(String[] args) {
        Vehicle vehicle1 = new Car("Tesla", "Model 3");
        Vehicle vehicle2 = new Bicycle();
        
        // Один и тот же вызов работает для разных типов
        vehicle1.start(); // Машина заведена
        vehicle2.start(); // Велосипед готов к поездке
        
        // Использование интерфейса как типа
        List<Vehicle> vehicles = new ArrayList<>();
        vehicles.add(new Car("Toyota", "Corolla"));
        vehicles.add(new Bicycle());
        vehicles.add(new Car("Honda", "Civic"));
        
        for (Vehicle v : vehicles) {
            v.start();
            System.out.println(v.getInfo());
            v.stop();
        }
    }
}

Сравнительная таблица

Взаимосвязь

// Интерфейс определяет контракт
public interface PaymentProcessor {
    boolean process(double amount);
    void refund(String transactionId);
}

// Класс реализует интерфейс
public class CardPaymentProcessor implements PaymentProcessor {
    @Override
    public boolean process(double amount) {
        // Реальная реализация
        return true;
    }
    
    @Override
    public void refund(String transactionId) {
        // Реальная реализация
    }
}

// Объект используется в коде
public class CheckoutService {
    private PaymentProcessor processor;
    
    public CheckoutService(PaymentProcessor processor) {
        this.processor = processor; // Зависит от интерфейса, не от класса
    }
    
    public boolean checkout(double amount) {
        return processor.process(amount); // Полиморфизм
    }
}

// Использование
public class Main {
    public static void main(String[] args) {
        // Создаём объект класса
        PaymentProcessor processor = new CardPaymentProcessor();
        
        // Используем объект через интерфейс
        CheckoutService checkout = new CheckoutService(processor);
        checkout.checkout(99.99);
    }
}

Практический пример с Real World сценарием

// Интерфейс — контракт
public interface Logger {
    void log(String message);
}

// Класс ConsoleLogger реализует интерфейс
public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

// Класс FileLogger реализует интерфейс
public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // Запись в файл
    }
}

// Класс Application использует интерфейс
public class Application {
    private Logger logger;
    
    public Application(Logger logger) {
        this.logger = logger; // Зависит от интерфейса!
    }
    
    public void run() {
        logger.log("Приложение запущено");
        // Остальной код
        logger.log("Приложение завершено");
    }
}

// Использование
public class Main {
    public static void main(String[] args) {
        // Объект ConsoleLogger
        Logger consoleLogger = new ConsoleLogger();
        Application app1 = new Application(consoleLogger);
        app1.run();
        
        // Объект FileLogger
        Logger fileLogger = new FileLogger();
        Application app2 = new Application(fileLogger);
        app2.run();
        
        // Один код, разная реализация благодаря интерфейсу
    }
}

Ключевые моменты

1. Класс — это как архитектурный план дома
2. Объект — это конкретный построенный дом
3. Интерфейс — это договор о том, какие функции должен иметь дом

Понимание этих различий критично для проектирования гибких и расширяемых систем в Java.