У экземпляра или у класса вызываются статические методы

Статические методы вызываются у класса, а не у экземпляра

Основное правило

Статические методы (static methods) в Java вызываются через класс, а не через экземпляр объекта. Это одна из фундаментальных особенностей языка, которая отражает суть статических членов класса.

// Правильно - вызов через класс
Math.abs(-5);
String.format("%d", 42);
System.out.println("Hello");

// Технически работает, но плохая практика - вызов через экземпляр
MyClass obj = new MyClass();
obj.staticMethod();  // компилируется, но IDE выдаёт предупреждение

Почему статические методы принадлежат классу

Статические члены класса - это переменные и методы, которые существуют независимо от конкретного экземпляра:

1. Одна копия на весь класс — статический метод существует один раз для всего класса, а не для каждого объекта
2. Нет привязки к состоянию объекта — статические методы не имеют доступа к полям экземпляра (this)
3. Загружаются при загрузке класса — статические члены инициализируются при загрузке класса ClassLoader-ом

Примеры из практики

Утилит-классы со статическими методами:

public class StringUtils {
    // Статический метод - принадлежит классу
    public static boolean isEmpty(String str) {
        return str == null || str.trim().length() == 0;
    }
    
    // Статический метод - принадлежит классу
    public static String capitalize(String str) {
        if (isEmpty(str)) return str;
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }
}

// Вызов через класс
boolean empty = StringUtils.isEmpty("  ");
String capitalized = StringUtils.capitalize("hello");

Не-статические методы для сравнения:

public class Calculator {
    private int result = 0;
    
    // Нестатический метод - принадлежит экземпляру
    public void add(int value) {
        result += value;  // доступ к полю экземпляра
    }
    
    // Нестатический метод
    public int getResult() {
        return result;
    }
    
    // Статический метод - может работать с параметрами
    public static int add(int a, int b) {
        return a + b;  // не может обращаться к this.result
    }
}

// Использование
Calculator calc = new Calculator();
calc.add(5);           // нестатический метод - вызываем через экземпляр
int sum = Calculator.add(5, 3);  // статический метод - вызываем через класс

Область видимости статических методов

public class Memory {
    
    // Статический блок инициализации - выполняется один раз при загрузке класса
    static {
        System.out.println("Static block - class loaded");
    }
    
    private static String staticField = "shared by all instances";
    private String instanceField = "unique per instance";
    
    // Статический метод - может обращаться только к статическим членам
    public static void staticMethod() {
        System.out.println(staticField);      // OK - статическое поле
        // System.out.println(instanceField); // ERROR - нет доступа
        // System.out.println(this.instanceField); // ERROR - нет this
    }
    
    // Нестатический метод - может обращаться ко всем членам
    public void instanceMethod() {
        System.out.println(staticField);      // OK - статическое поле
        System.out.println(instanceField);    // OK - поле экземпляра
        // staticMethod();                     // OK - можно вызвать статический
    }
}

Когда вызов через экземпляр технически работает

public class Animal {
    public static void sound() {
        System.out.println("Generic animal sound");
    }
}

Animal dog = new Animal();

// Оба варианта работают, но второй - плохая практика
Animal.sound();        // Правильно - явно видно что это статический метод
dog.sound();           // Работает, но вводит в заблуждение

Компилятор разрешает вызов статического метода через экземпляр, но это просто синтаксический сахар. Под капотом Java всё равно вызовет метод класса, игнорируя ссылку на объект. IDE (IntelliJ IDEA, Eclipse) обычно выдают предупреждение: "Static member accessed via instance reference".

Лучшие практики

1. Всегда вызывай через класс:

// Хорошо
Math.abs(-10);
System.currentTimeMillis();
Collections.emptyList();

// Плохо
int value = 5;
int absValue = value.abs();  // если бы abs был статическим в Integer

1. Используй static для утилит и фабрик:

public class DateUtils {
    public static LocalDate today() {
        return LocalDate.now();
    }
    
    public static LocalDate tomorrow() {
        return LocalDate.now().plusDays(1);
    }
}

1. Избегай статических изменяемых состояний:

// Опасно - общее состояние для всех потоков
public class BadExample {
    public static List<String> cache = new ArrayList<>();  // Не потокобезопасно!
}

// Хорошо - иммутабельное состояние
public class GoodExample {
    public static final List<String> EMPTY_LIST = Collections.unmodifiableList(new ArrayList<>());
}

Основные выводы

• Статические методы вызываются через класс, это устоявшаяся convention
• Статические методы не имеют доступа к this и полям экземпляра
• Вызов через экземпляр технически работает, но это плохая практика
• Статические методы идеальны для утилит, фабрик и констант
• Java гарантирует, что статический член существует в одной копии на весь класс