Классы и объекты
Класс — это шаблон для создания объектов. В классе определяются свойства (поля) и поведение (методы) объектов.

Класс объявляется с помощью ключевого слова class:

public class Person {
    String name;
    int age;

    void greet() {
        System.out.println("Hello, my name is " + name);
    }
}

Здесь Person — это класс, который имеет два поля (name и age) и один метод (greet).

Создание объекта

Объект создается с помощью ключевого слова new:

Person person1 = new Person();

Это создаст новый объект person1 класса Person.

Инициализация полей объекта

Поля объекта можно инициализировать после его создания:

person1.name = "John";
person1.age = 30;

Вызов методов объекта

Методы объекта вызываются через точку:

person1.greet(); // Выведет "Hello, my name is John"

Конструкторы

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

Объявление конструктора

Конструкторы имеют то же имя, что и класс, и не возвращают значение (даже void):

public class Person {
    String name;
    int age;

    // Конструктор
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void greet() {
        System.out.println("Hello, my name is " + name);
    }
}

Создание объекта с использованием конструктора:

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("John", 30);
        person1.greet(); // Выведет "Hello, my name is John"
    }
}

Перегрузка конструкторов

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

public class Person {
    String name;
    int age;

    // Конструктор по умолчанию
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // Конструктор с параметрами
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void greet() {
        System.out.println("Hello, my name is " + name);
    }
}

Использование перегруженных конструкторов:

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person("Alice", 25);
        person1.greet(); // Выведет "Hello, my name is Unknown"
        person2.greet(); // Выведет "Hello, my name is Alice"
    }
}

Методы в классе

Методы в классе определяют поведение объектов и могут манипулировать их состоянием (полями).

Объявление метода

Метод объявляется с указанием возвращаемого типа, имени и параметров (если есть):

public class Person {
    String name;
    int age;

    void greet() {
        System.out.println("Hello, my name is " + name);
    }

    // Метод с параметрами
    void setAge(int newAge) {
        age = newAge;
    }

    // Метод с возвращаемым значением
    int getAge() {
        return age;
    }
}

Вызов методов объекта

Методы вызываются через точку, указывая объект, имя метода и параметры (если есть):

public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 30);
        person.greet(); // Выведет "Hello, my name is John"
        person.setAge(35);
        System.out.println("Age: " + person.getAge()); // Выведет "Age: 35"
    }
}

Примеры классов и объектов

Класс Car:

public class Car {
    String model;
    int year;

    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    void displayInfo() {
        System.out.println("Model: " + model + ", Year: " + year);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car("Toyota", 2020);
        Car car2 = new Car("Honda", 2018);
        car1.displayInfo(); // Выведет "Model: Toyota, Year: 2020"
        car2.displayInfo(); // Выведет "Model: Honda, Year: 2018"
    }
}

#Java #Training #Class #Method #ООП

Ссылки на методы (Method References)

Ссылки на методы (Method References) — это способ сослаться на метод, не вызывая его. Они были добавлены в Java 8 как часть поддержки лямбда-выражений. Ссылки на методы позволяют сделать код более компактным и читаемым, особенно когда лямбда-выражение просто вызывает уже существующий метод.

Синтаксис ссылки на метод:

ClassName::methodName

Типы ссылок на методы

В Java существует четыре типа ссылок на методы:

Ссылка на статический метод
Используется для ссылки на статический метод класса.

Пример:

interface MathOperation {
    int operate(int a, int b);
}

public class Main {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        // Ссылка на статический метод
        MathOperation operation = Main::add;
        System.out.println(operation.operate(5, 3)); // Вывод: 8
    }
}

Ссылка на метод экземпляра
Используется для ссылки на метод конкретного объекта.

Пример:

interface Printer {
    void print(String message);
}

public class Main {
    public void printMessage(String message) {
        System.out.println(message);
    }

    public static void main(String[] args) {
        Main main = new Main();
        // Ссылка на метод экземпляра
        Printer printer = main::printMessage;
        printer.print("Hello, World!"); // Вывод: Hello, World!
    }
}

Ссылка на метод произвольного объекта
Используется для ссылки на метод объекта, который будет передан в качестве аргумента.

Пример:

interface StringOperation {
    String operate(String str);
}

public class Main {
    public static void main(String[] args) {
        // Ссылка на метод произвольного объекта
        StringOperation operation = String::toUpperCase;
        System.out.println(operation.operate("hello")); // Вывод: HELLO
    }
}

Ссылка на конструктор
Используется для ссылки на конструктор класса.

Пример:

interface Factory {
    Object create();
}

public class Main {
    public static void main(String[] args) {
        // Ссылка на конструктор
        Factory factory = String::new;
        String str = (String) factory.create();
        System.out.println(str.isEmpty()); // Вывод: true
    }
}

Как это работает под капотом?

Ссылки на методы компилируются в объекты функциональных интерфейсов. Например, ссылка String::toUpperCase компилируется в реализацию функционального интерфейса, который вызывает метод toUpperCase на переданном объекте.

Пример:

Function<String, String> toUpperCase = String::toUpperCase;
System.out.println(toUpperCase.apply("hello")); // Вывод: HELLO
Здесь String::toUpperCase преобразуется в реализацию интерфейса Function, который принимает строку и возвращает её в верхнем регистре.

Плюсы и минусы ссылок на методы

Плюсы:
Упрощение кода: Ссылки на методы делают код более компактным и читаемым.
Повторное использование: Позволяют повторно использовать существующие методы.
Интеграция с лямбда-выражениями: Отлично сочетаются с лямбда-выражениями и Stream API.

Минусы:
Ограниченная гибкость: Ссылки на методы подходят только для случаев, когда лямбда-выражение просто вызывает существующий метод.
Сложность отладки: Могут усложнить отладку, так как код становится менее явным.
Пример использования ссылок на методов в Stream API

Ссылки на методы часто используются в Stream API для упрощения кода.

Пример:

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // Использование ссылки на метод для вывода элементов
        names.forEach(System.out::println);

        // Использование ссылки на метод для преобразования строк
        names.stream()
             .map(String::toUpperCase)
             .forEach(System.out::println);
    }
}

#Java #Training #Medium #Functional_programming #Method_References

Получение информации о методах.

Класс Method в Java является частью Reflection API и представляет собой метаинформацию о методах класса. С помощью этого класса можно получить информацию о методах, их параметрах, возвращаемых типах и аннотациях.

Что такое метод класса и как его получить

Метод класса — это блок кода, который выполняет определенную задачу.

В Java методы могут быть:
Публичными (public): доступны из любого класса.
Приватными (private): доступны только внутри класса.
Защищенными (protected): доступны внутри класса и его подклассов.
По умолчанию (без модификатора): доступны внутри пакета.

Для получения методов класса используются методы:

getMethods()
Возвращает массив всех публичных методов класса, включая унаследованные от суперклассов и интерфейсов.

Пример:

Class<?> clazz = String.class;
Method[] methods = clazz.getMethods();
for (Method method : methods) {
    System.out.println(method.getName());
}

getDeclaredMethods()
Возвращает массив всех методов, объявленных в классе (включая приватные и защищенные), но не включает унаследованные методы.

Пример:

Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method method : declaredMethods) {
    System.out.println(method.getName());
}

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

import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) {
        Class<?> clazz = String.class;
        
        // Получение всех публичных методов
        System.out.println("Public Methods:");
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method.getName());
        }
        
        // Получение всех объявленных методов
        System.out.println("\nDeclared Methods:");
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method method : declaredMethods) {
            System.out.println(method.getName());
        }
    }
}

#Java #Training #Medium #Reflection_API #Method

Получение информации о методах.

Работа с параметрами методов

getParameterTypes()
Возвращает массив Class объектов, представляющих типы параметров метода.

Пример:

Class<?> clazz = String.class;
Method method = clazz.getMethod("substring", int.class, int.class);
Class<?>[] parameterTypes = method.getParameterTypes();
for (Class<?> paramType : parameterTypes) {
    System.out.println(paramType.getName()); // Вывод: int, int
}

getReturnType()
Возвращает Class объект, представляющий тип возвращаемого значения метода.

Пример:

Class<?> returnType = method.getReturnType();
System.out.println(returnType.getName()); // Вывод: java.lang.String

Пример получения информации о параметрах и возвращаемом типе

import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws NoSuchMethodException {
        Class<?> clazz = String.class;
        
        // Получение метода substring(int, int)
        Method method = clazz.getMethod("substring", int.class, int.class);
        
        // Получение типов параметров
        System.out.println("Parameter Types:");
        Class<?>[] parameterTypes = method.getParameterTypes();
        for (Class<?> paramType : parameterTypes) {
            System.out.println(paramType.getName());
        }
        
        // Получение возвращаемого типа
        System.out.println("\nReturn Type:");
        Class<?> returnType = method.getReturnType();
        System.out.println(returnType.getName());
    }
}

Пример с приватным методом

import java.lang.reflect.Method;

class MyClass {
    private void myPrivateMethod(int a, String b) {
        System.out.println("Private Method: " + a + ", " + b);
    }
}

public class Main {
    public static void main(String[] args) throws NoSuchMethodException {
        Class<?> clazz = MyClass.class;
        
        // Получение приватного метода
        Method method = clazz.getDeclaredMethod("myPrivateMethod", int.class, String.class);
        
        // Получение типов параметров
        System.out.println("Parameter Types:");
        Class<?>[] parameterTypes = method.getParameterTypes();
        for (Class<?> paramType : parameterTypes) {
            System.out.println(paramType.getName()); // Вывод: int, java.lang.String
        }
        
        // Получение возвращаемого типа
        System.out.println("\nReturn Type:");
        Class<?> returnType = method.getReturnType();
        System.out.println(returnType.getName()); // Вывод: void
    }
}

#Java #Training #Medium #Reflection_API #Method

Вызов методов через Reflection

Теперь перейдем к вызову методов через Reflection. Это полезно, когда вы хотите вызвать метод, имя которого неизвестно до момента выполнения программы.

1. Использование Method.invoke() для вызова методов

Метод Method.invoke() позволяет вызывать методы объекта динамически. Вы можете получить объект Method с помощью getDeclaredMethod() или getMethod(), а затем вызвать его.

Как это работает:
Вы получаете объект Class.
С помощью getDeclaredMethod() или getMethod() получаете объект Method.
Вызываете метод invoke(), передавая объект и аргументы.

Пример кода:

public class MyClass {
    public void sayHello(String name) {
        System.out.println("Привет, " + name + "!");
    }
}

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // Получаем объект Class
            Class<?> clazz = Class.forName("MyClass");
            
            // Создаем объект
            Object obj = clazz.getDeclaredConstructor().newInstance();
            
            // Получаем метод sayHello с параметром String
            Method method = clazz.getDeclaredMethod("sayHello", String.class);
            
            // Вызываем метод
            method.invoke(obj, "John");
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException |
                 IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

Плюсы:
Позволяет вызывать методы динамически.
Поддерживает методы с параметрами.

Минусы:
Медленнее, чем прямой вызов метода.
Может выбросить исключения, если метод недоступен или параметры не совпадают.

Под капотом:
Метод invoke() использует нативные вызовы для выполнения метода. Это требует дополнительных проверок и может привести к снижению производительности.

2. Обработка исключений при вызове методов

При работе с Reflection важно правильно обрабатывать исключения.

Основные исключения, которые могут возникнуть:
IllegalAccessException: если метод недоступен (например, он private).
InvocationTargetException: если метод выбросил исключение.
NoSuchMethodException: если метод не найден.

Пример обработки исключений:

try {
    Method method = clazz.getDeclaredMethod("sayHello", String.class);
    method.setAccessible(true); // Разрешаем доступ к private методам
    method.invoke(obj, "John");
} catch (NoSuchMethodException e) {
    System.out.println("Метод не найден: " + e.getMessage());
} catch (IllegalAccessException e) {
    System.out.println("Нет доступа к методу: " + e.getMessage());
} catch (InvocationTargetException e) {
    System.out.println("Метод выбросил исключение: " + e.getCause().getMessage());
}

Плюсы:
Позволяет безопасно работать с Reflection.
Помогает отлаживать проблемы.

Минусы:
Увеличивает объем кода.
Требует внимательности при обработке исключений.

#Java #Training #Medium #Reflection_API #Method_invoke

Методы в Java — синтаксис и структура

Методы в Java являются ключевым элементом классов, определяющим поведение объектов или самого класса. Они представляют собой именованные блоки кода, которые выполняют определенные действия и могут возвращать результат.


1. Что такое метод в Java?

Метод в Java — это именованный блок кода, который выполняет определенную задачу и может быть вызван из других частей программы. Методы могут принадлежать либо экземпляру класса (экземплярные методы), либо самому классу (статические методы). Они позволяют инкапсулировать логику, повторно использовать код и структурировать поведение программы.

Методы в Java строго типизированы, что означает, что их возвращаемый тип, параметры и исключения должны быть четко определены.


2. Базовая структура метода

Метод объявляется внутри тела класса и состоит из заголовка (сигнатуры) и тела.

Вот общий синтаксис метода:

[модификаторы] тип_возврата имя_метода(параметры) [throws исключения] {
    // Тело метода
}

Пример минимального метода:

class Calculator {
    int calculateSum(int a, int b) {
        return a + b;
    }
}

Компоненты метода:
Модификаторы: Определяют поведение метода (например, static, final).
Тип возврата: Указывает, какой тип данных метод возвращает (или void, если ничего не возвращается).
Имя метода: Уникальное имя, описывающее действие метода.
Параметры: Список входных данных (может быть пустым).
Список исключений (throws): Указывает, какие проверяемые исключения метод может выбросить.
Тело метода: Код, выполняющий логику метода, заключенный в фигурные скобки {}.


3. Типы методов

Методы в Java делятся на два основных типа в зависимости от их принадлежности:

3.1. Экземплярные методы
Экземплярные методы принадлежат объекту класса и работают с его состоянием (полями экземпляра). Для их вызова требуется создание экземпляра класса.

Пример:

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    void printGreeting() {
        System.out.println("Меня зовут " + name);
    }
}

Использование:

Person person = new Person("Алексей");
person.printGreeting(); // Вывод: Меня зовут Алексей

3.2. Статические методы
Статические методы принадлежат классу, а не объекту, и вызываются через имя класса. Они не имеют доступа к полям экземпляра напрямую, только к статическим полям.

Пример:

class MathUtils {
    static double calculateSquare(double x) {
        return x * x;
    }
}

Использование:

double result = MathUtils.calculateSquare(5.0); // Вывод: 25.0

4. Параметры метода

Методы могут принимать параметры (аргументы), которые передаются при вызове. Параметры указываются в скобках в сигнатуре метода.

Синтаксис параметров:

тип_параметра имя_параметра [, тип_параметра имя_параметра ...]

Пример:

class Calculator {
    int calculateProduct(int a, int b) {
        return a * b;
    }
}

Особенности параметров:
Передача по значению: В Java все параметры передаются по значению. Для примитивных типов передается копия значения, для объектов — копия ссылки. Это означает, что изменения объекта внутри метода видны снаружи, но переназначение ссылки не влияет на исходный объект.
Переменное число параметров (varargs): Метод может принимать переменное количество аргументов одного типа с использованием синтаксиса ....

Пример varargs:

class MathUtils {
    int calculateSum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
}

#Java #для_новичков #beginner #java_syntax #Method

5. Возвращаемые значения

Методы могут возвращать значение определенного типа или ничего (void). Тип возврата указывается перед именем метода.

Пример:

class Example {
    String getWelcomeMessage() {
        return "Привет, мир!";
    }

    void printMessage() {
        System.out.println("Сообщение без возврата");
    }
}

Особенности возвращаемых значений:
Если метод имеет возвращаемый тип, он должен содержать оператор return с соответствующим значением.
Для void методов оператор return необязателен, но может использоваться для прерывания выполнения.
Метод может возвращать любой тип данных: примитивы (int, double), объекты, массивы или даже null для ссылочных типов.

Пример возврата массива:

class ArrayUtils {
    int[] generateNumbers() {
        return new int[] {1, 2, 3};
    }
}

6. Перегрузка методов

Перегрузка методов (method overloading) позволяет определять несколько методов с одинаковым именем, но разными сигнатурами (списками параметров).

Правила перегрузки:
Методы должны отличаться по количеству, типу или порядку параметров.
Возвращаемый тип не влияет на перегрузку.

Пример:

class Printer {
    void printMessage(String message) {
        System.out.println(message);
    }

    void printNumber(int number) {
        System.out.println("Число: " + number);
    }

    void printRepeatedMessage(String message, int times) {
        for (int i = 0; i < times; i++) {
            System.out.println(message);
        }
    }
}

Использование:

Printer printer = new Printer();
printer.printMessage("Привет"); // Вывод: Привет
printer.printNumber(42); // Вывод: Число: 42
printer.printRepeatedMessage("Повтор", 3); // Вывод: Повтор (3 раза)

7. Исключения в методах

Методы могут выбрасывать исключения, которые указываются в сигнатуре с помощью ключевого слова throws.

Пример:

class FileReader {
    void readFileContent(String path) throws IOException {
        // Код, который может выбросить IOException
    }
}

Особенности:
Проверяемые исключения (checked exceptions): Должны быть объявлены в throws или обработаны в блоке try-catch.
Непроверяемые исключения (unchecked exceptions): Не требуют явного объявления (например, RuntimeException).


8. Рекурсивные методы

Методы могут вызывать сами себя, что называется рекурсией. Рекурсия полезна для задач, которые можно разбить на подзадачи.

Пример:

class Factorial {
    int calculateFactorial(int n) {
        if (n <= 1) {
            return 1;
        }
        return n * calculateFactorial(n - 1);
    }
}

Использование:

Factorial fact = new Factorial();
int result = fact.calculateFactorial(5); // Вывод: 120

Ограничения рекурсии:
Необходимо определить базовый случай, чтобы избежать бесконечной рекурсии.
Глубокая рекурсия может привести к переполнению стека (StackOverflowError).


#Java #для_новичков #beginner #java_syntax #Method

9. Правила именования методов

Именование методов в Java — важный аспект, влияющий на читаемость и поддерживаемость кода. Java следует строгим соглашениям, которые помогают разработчикам понимать назначение метода.

Соглашения об именовании:
Используйте camelCase: Имя метода начинается с маленькой буквы, каждое последующее слово начинается с заглавной (например, calculateSum, printMessage).
Глаголы для действий: Имя метода должно начинаться с глагола, описывающего выполняемое действие (например, get, set, calculate, print, find).
Описательность: Имя должно четко отражать назначение метода (например, calculateTotalPrice вместо calc).
Избегайте сокращений: Используйте полные слова вместо сокращений, чтобы избежать двусмысленности (например, computeAverage вместо compAvg).
Префиксы для геттеров и сеттеров: Для методов, возвращающих или устанавливающих значения полей, используйте префиксы get и set (например, getName, setSalary).
Префикс is для булевых методов: Для методов, возвращающих boolean, используйте префикс is или has (например, isEmpty, hasAccess).

Примеры правильного и неправильного именования:

class Example {
    // Правильно: описывает действие, использует camelCase
    String getUserName() {
        return "Алексей";
    }

    // Неправильно: не описывает действие, использует сокращение
    String user() {
        return "Алексей";
    }

    // Правильно: использует is для булевого значения
    boolean isActive() {
        return true;
    }

    // Неправильно: не соответствует соглашению для булевых методов
    boolean active() {
        return true;
    }
}

Советы по именованию:
Согласованность: Следуйте одному стилю именования во всем проекте.
Избегайте избыточности: Не добавляйте лишние слова, такие как do или perform, если они не уточняют смысл (например, calculateSum вместо doCalculateSum).
Учитывайте контекст: Имя метода должно быть понятно в контексте класса (например, в классе Order метод calculateTotal очевиден без уточнения calculateOrderTotal).


10. Методы и память в Java

Понимание того, как методы работают в памяти, важно для написания эффективного кода и избежания ошибок.

10.1. Стек вызовов (Call Stack)
Каждый раз, когда метод вызывается, JVM создает новый фрейм в стеке вызовов (call stack).

Фрейм стека содержит:
Локальные переменные метода.
Параметры метода.
Возвращаемый адрес (место, куда вернется управление после завершения метода).
При завершении метода его фрейм удаляется из стека, освобождая память.
Рекурсивные методы увеличивают глубину стека, что может привести к StackOverflowError при чрезмерной глубине.

Пример:

class StackExample {
    void methodA() {
        methodB();
    }

    void methodB() {
        System.out.println("В методе B");
    }
}

Вызов methodA создает фрейм в стеке.
Вызов methodB из methodA добавляет новый фрейм поверх фрейма methodA.
После завершения methodB его фрейм удаляется, и управление возвращается к methodA.

10.2. Статические методы и память
Статические методы хранятся в области памяти, называемой Metaspace (в Java 8 и выше), вместе с метаданными класса.
Они не привязаны к объектам, поэтому не требуют создания экземпляра класса и не используют память кучи для хранения состояния объекта.
Статические методы имеют доступ только к статическим полям, которые также хранятся в Metaspace.


#Java #для_новичков #beginner #java_syntax #Method

10.3. Экземплярные методы и память
Экземплярные методы также хранятся в Metaspace, но при вызове они работают с конкретным объектом, который находится в куче (Heap).
Каждый объект в куче содержит ссылку на таблицу методов своего класса, что позволяет вызывать экземплярные методы.
Локальные переменные и параметры метода хранятся в стеке вызовов, а поля объекта — в куче.

10.4. Передача параметров и память
Примитивные типы: Передаются по значению, копия значения сохраняется в стеке вызова метода.
Ссылочные типы: Передается копия ссылки, указывающая на объект в куче. Изменения объекта видны снаружи, но переназначение ссылки внутри метода не влияет на исходную ссылку.

Пример:

class MemoryExample {
    void modifyObject(StringBuilder sb, int value) {
        sb.append("Изменено"); // Изменяет объект в куче
        value = 100; // Изменяет локальную копию, не влияет на исходное значение
    }
}

Использование:

StringBuilder sb = new StringBuilder("Привет");
int value = 42;
MemoryExample example = new MemoryExample();
example.modifyObject(sb, value);
System.out.println(sb); // Вывод: ПриветИзменено
System.out.println(value); // Вывод: 42

10.5. Оптимизация памяти
Избегайте глубоких рекурсий: Используйте итеративные подходы для задач, требующих больших вычислений.
Минимизируйте локальные переменные: Используйте только необходимые переменные, чтобы сократить использование стека.
Осторожно с varargs: Передача большого количества аргументов через varargs создает массив в куче, что может увеличить потребление памяти.


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

Четкие имена методов: Следуйте соглашениям об именовании, чтобы код был читаемым и понятным.
Ограничение длины метода: Методы должны быть короткими и выполнять одну задачу.
Использование перегрузки: Перегружайте методы только тогда, когда это логически оправдано.
Обработка исключений: Обрабатывайте исключения или явно объявляйте их в сигнатуре метода.
Документация: Используйте Javadoc для описания назначения метода, параметров и возвращаемого значения.

Пример Javadoc:

/**
 * Вычисляет сумму двух чисел.
 * @param firstNumber Первое число
 * @param secondNumber Второе число
 * @return Сумма чисел
 */
int calculateSum(int firstNumber, int secondNumber) {
    return firstNumber + secondNumber;
}

12. Ошибки и подводные камни

Неправильная перегрузка: Перегруженные методы с неоднозначными сигнатурами могут вызвать ошибки компиляции.
Игнорирование возвращаемого значения: Если метод возвращает значение, его нужно либо использовать, либо явно игнорировать.
Длинные методы: Слишком длинные методы трудно читать и поддерживать. Разбивайте их на меньшие подзадачи.
Необработанные исключения: Проверяемые исключения должны быть либо обработаны, либо объявлены.
Проблемы с памятью: Глубокая рекурсия или чрезмерное использование varargs может привести к переполнению стека или кучи.


#Java #для_новичков #beginner #java_syntax #Method