Что такое класс в ООП?

Класс в ООП: Концепция и Практика

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

Определение класса

Класс — это абстрактный тип данных, который инкапсулирует:

1. Состояние — данные, хранящиеся в полях (атрибутах)
2. Поведение — операции, определённые методами
3. Идентичность — уникальный объект в памяти

public class Car {
    // Состояние (поля/свойства)
    private String brand;
    private String model;
    private int year;
    private double speed;
    
    // Поведение (методы)
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
        this.speed = 0;
    }
    
    public void accelerate(double amount) {
        this.speed += amount;
    }
    
    public void brake() {
        this.speed = 0;
    }
    
    public String getInfo() {
        return brand + " " + model + " (" + year + ")";
    }
}

Объект и экземпляр класса

Объект — это экземпляр класса, созданный с помощью оператора new:

// car1 и car2 — объекты (экземпляры) класса Car
Car car1 = new Car("Toyota", "Camry", 2022);
Car car2 = new Car("BMW", "X5", 2023);

// Каждый объект имеет свое состояние
car1.accelerate(50);
car2.accelerate(100);

System.out.println(car1.getSpeed()); // 50
System.out.println(car2.getSpeed()); // 100

Инкапсуляция

Инкапсуляция — скрытие внутренних деталей класса и предоставление контролируемого доступа через методы:

public class BankAccount {
    // Приватные поля — доступны только внутри класса
    private String accountNumber;
    private double balance;
    private String pin;
    
    // Публичные методы — контролируют доступ к данным
    public BankAccount(String accountNumber, String pin) {
        this.accountNumber = accountNumber;
        this.pin = pin;
        this.balance = 0;
    }
    
    // Безопасный доступ к чтению баланса
    public double getBalance() {
        return balance;
    }
    
    // Контролируемое пополнение счёта
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        } else {
            throw new IllegalArgumentException("Amount must be positive");
        }
    }
    
    // Контролируемое снятие денег
    public boolean withdraw(double amount, String pin) throws InvalidPinException {
        if (!this.pin.equals(pin)) {
            throw new InvalidPinException("Invalid PIN");
        }
        
        if (amount > balance) {
            return false; // Недостаточно средств
        }
        
        balance -= amount;
        return true;
    }
}

Члены класса

Поля (Field/Attribute) — переменные, хранящие состояние:

public class Student {
    private String name;        // Экземплярное поле
    private int studentId;
    
    public static int totalStudents = 0;  // Статическое поле (классовое)
}

Методы (Method) — функции, определяющие поведение:

public class Calculator {
    // Экземплярный метод
    public int add(int a, int b) {
        return a + b;
    }
    
    // Статический метод
    public static int multiply(int a, int b) {
        return a * b;
    }
}

Конструктор — специальный метод для инициализации объекта:

public class Person {
    private String name;
    private int age;
    
    // Конструктор с параметрами
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Конструктор без параметров (default)
    public Person() {
        this("Unknown", 0);
    }
}

Модификаторы доступа

public class AccessExample {
    private int privateField;        // Только в этом классе
    int defaultField;                // В классе и пакете
    protected int protectedField;    // В классе, пакете и подклассах
    public int publicField;          // Везде
}

Наследование

Наследование позволяет классу наследовать свойства и методы другого класса:

// Базовый класс (Superclass/Parent)
public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating");
    }
}

// Подкласс (Subclass/Child)
public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name); // Вызов конструктора родителя
        this.breed = breed;
    }
    
    @Override
    public void eat() {
        System.out.println(name + " is eating dog food");
    }
    
    public void bark() {
        System.out.println(name + " barks!");
    }
}

Полиморфизм

Полиморфизм позволяет объектам принимать разные формы и использоваться через общий интерфейс:

public class Zoo {
    public static void feedAnimal(Animal animal) {
        animal.eat(); // Вызовет метод конкретного класса
    }
}

// Использование
Dog dog = new Dog("Rex", "Labrador");
Cat cat = new Cat("Whiskers");

Zoo.feedAnimal(dog); // "Rex is eating dog food"
Zoo.feedAnimal(cat); // "Whiskers is eating cat food"

Абстрактные классы

Абстрактный класс — класс, который не может быть инстанцирован и может содержать абстрактные методы:

public abstract class Vehicle {
    protected String color;
    
    public abstract void start();
    public abstract void stop();
    
    public void repaint(String color) {
        this.color = color;
    }
}

public class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("Car engine started");
    }
    
    @Override
    public void stop() {
        System.out.println("Car engine stopped");
    }
}

Статические члены класса

Статические члены (поля и методы) принадлежат классу, а не экземплярам:

public class Counter {
    private static int count = 0;  // Общее для всех экземпляров
    private int id;
    
    public Counter() {
        count++;
        this.id = count;
    }
    
    public static int getCount() {
        return count; // Можно обращаться без создания объекта
    }
}

// Использование
Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.getCount()); // 2

Интерфейсы

Интерфейс определяет контракт (набор методов), который должны реализовать классы:

public interface Drawable {
    void draw();
    void resize(int size);
}

public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing circle");
    }
    
    @Override
    public void resize(int size) {
        System.out.println("Resizing circle to " + size);
    }
}

Lifecycle класса

1. Загрузка — ClassLoader загружает класс
2. Линкование — проверка и инициализация
3. Инициализация — выполнение статических инициализаторов
4. Создание объекта — вызов конструктора
5. Использование — работа с объектом
6. Удаление — сборка мусора

Лучшие практики при описании класса

1. Единственная ответственность — класс должен иметь одну причину для изменения
2. Инкапсуляция — скрывай внутренние детали
3. Правильное наименование — имя должно отражать назначение
4. Разумный размер — класс не должен быть слишком большим
5. Логическая связь — поля и методы должны быть связаны
6. Документация — описывай назначение класса в JavaDoc

Класс — это мощный инструмент для организации кода в ООП, обеспечивающий модульность, переиспользуемость и легкость поддержки кода.