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

Класс объявляется с помощью ключевого слова 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