Зачем инстанцируешь объект

Инстанцирование объектов в Java: цель, смысл и практика

Что такое инстанцирование

Инстанцирование — это процесс создания конкретного объекта (экземпляра) класса в памяти программы. Класс — это шаблон (blueprint), а объект — это конкретная реализация этого шаблона.

// Класс — шаблон
public class User {
    private String name;
    private int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// Инстанцирование — создание конкретного объекта
User user1 = new User("Иван", 25);  // Объект 1
User user2 = new User("Мария", 30); // Объект 2

// user1 и user2 — разные объекты, хотя одного класса

Зачем нужно инстанцирование

1. Создание состояния (state)

Класс определяет структуру, но не имеет данных. Объект хранит конкретные значения:

// Класс — просто определение
public class Car {
    private String model;
    private String color;
    private int speed;
}

// Объекты — конкретные машины с данными
Car car1 = new Car();  // Машина 1: модель BMW, красная, скорость 0
Car car2 = new Car();  // Машина 2: модель Tesla, чёрная, скорость 0

car1.setModel("BMW");
car1.setColor("Red");
car2.setModel("Tesla");
car2.setColor("Black");

// Разные объекты хранят разные состояния

2. Использование методов в контексте

Методы класса работают с состоянием конкретного объекта:

public class BankAccount {
    private double balance;
    
    public void deposit(double amount) {
        this.balance += amount;  // "this" — текущий объект
    }
    
    public double getBalance() {
        return this.balance;
    }
}

BankAccount acc1 = new BankAccount();
BankAccount acc2 = new BankAccount();

acc1.deposit(1000);  // Пополнить счёт 1
acc2.deposit(500);   // Пополнить счёт 2

System.out.println(acc1.getBalance()); // 1000
System.out.println(acc2.getBalance()); // 500

3. Разделение данных

Каждый объект имеет свою память и не влияет на другие объекты:

public class Counter {
    private int count = 0;
    
    public void increment() {
        count++;
    }
    
    public int getCount() {
        return count;
    }
}

Counter c1 = new Counter();
Counter c2 = new Counter();

c1.increment();  // c1.count = 1
c1.increment();  // c1.count = 2
c2.increment();  // c2.count = 1 (независимо от c1)

System.out.println(c1.getCount()); // 2
System.out.println(c2.getCount()); // 1

Без инстанцирования (статические члены)

Есть исключение — статические поля и методы, которые НЕ требуют инстанцирования:

public class Math {
    public static final double PI = 3.14159;
    
    public static double sqrt(double x) {
        // общая логика для всех
    }
}

// Используем БЕЗ создания объекта
double pi = Math.PI;           // Прямой доступ
double root = Math.sqrt(16);   // 4.0

// Инстанцирование НЕ требуется

Процесс инстанцирования изнутри

Когда выполняется new User("Иван", 25):

1. Выделяется память в heap для нового объекта
2. Вызывается конструктор класса
3. Инициализируются поля объекта
4. Возвращается ссылка на объект
5. Ссылка присваивается переменной

User user = new User("Иван", 25);
           ↓
   new User(...) — создание объекта в heap (адрес в памяти)
           ↓
   Конструктор инициализирует поля
           ↓
   user — ссылка на объект (переменная в stack)

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

public class Employee {
    private String name;
    private String department;
    private double salary;
    
    public Employee(String name, String department, double salary) {
        this.name = name;
        this.department = department;
        this.salary = salary;
    }
    
    public void giveRaise(double percent) {
        this.salary *= (1 + percent / 100);
    }
    
    public String getInfo() {
        return String.format("%s, %s, %.2f", name, department, salary);
    }
}

// Инстанцирование для разных сотрудников
Employee emp1 = new Employee("Анна", "IT", 150000);
Employee emp2 = new Employee("Борис", "Sales", 120000);
Employee emp3 = new Employee("Валентина", "HR", 100000);

// Каждый объект имеет независимое состояние
emp1.giveRaise(10);  // Анна получила +10%
emp2.giveRaise(5);   // Борис получил +5%

System.out.println(emp1.getInfo()); // Анна, IT, 165000.00
System.out.println(emp2.getInfo()); // Борис, Sales, 126000.00
System.out.println(emp3.getInfo()); // Валентина, HR, 100000.00

Антипаттерны: когда инстанцирование не нужно

// ❌ Плохо: создаёшь объект, но не используешь
public class Config {
    public static final String VERSION = "1.0";
}
Config cfg = new Config();  // Зачем? Используй Config.VERSION

// ✅ Хорошо: используешь статические члены
String version = Config.VERSION;  // Прямой доступ

// ❌ Плохо: инстанцируешь для вызова static метода
List<String> list = new ArrayList<>();
Collections.sort(list);  // OK

Collections utils = new Collections();  // Зачем? Collections — утилита
utils.sort(list);  // Неправильно

Вывод

Зачем инстанцируешь объект:

1. Создаёшь состояние — конкретные значения полей
2. Вызываешь методы в контексте конкретного объекта
3. Разделяешь данные между разными экземплярами
4. Реализуешь паттерны (Builder, Factory, Singleton)
5. Работаешь с коллекциями объектов одного типа

Без инстанцирования Java — это просто набор определений классов. Объекты — это душа программы, они хранят данные и взаимодействуют друг с другом.