25.06.19 в 16:24

Методы в Java

Теги: java, void, main(), программирование на java, методы, метод, параметры, println()

В этой статье мы поговорим про методы в Java и о том, зачем они нужны. Это основы, которые должен знать каждый начинающий программист.

Метод — что это?

Практически любой код на Java включает в себя методы. Говоря простым языком, методы — это строительные блоки, из которых и состоит Java-программа.

Метод в 2-х словах

Видите в программе слово, за которым следуют круглые скобки? Это и есть метод, например:

слово()

А вот сразу названия четырёх методов:

println()
hasNextInt()
        getNumber()
        main()

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

возвращаемый тип — идентификатор метода (параметры)
{
тело метода
}

Зачем нужны методы?

Поясним это на примере упрощённой программы-калькулятора. Допустим, она должна уметь выполнять лишь четыре операции: деление, умножение, сложение и вычитание. При написании такого приложения мы бы попросили пользователя о следующих действиях: 1) ввести два числа; 2) выбрать нужную математическую операцию.

Наш код в Java:

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        double num1 = getNumber();
        double num2 = getNumber();
        char operation = getOperation();
        double result = calc(num1, num2, operation);
        System.out.println("Результат:" + result);
    }
}

Но это не полный код, а лишь его кусочек, включающий главный метод main. Что мы тут видим? То, что метод выполняется в каждой строчке:

Всё подчёркнутое — это методы, включая main. Давайте запишем это схематически:

Что же делают данные методы, и какова логика кода? На самом деле, каждый метод отвечает за определённое действие:

Два типа методов

Обратите внимание, что в нашем коде представлены 2 типа методов: 1) методы, которые уже известны: — main(); — println(); 2) методы, которые мы написали сами: — getNumber(); — getOperation(); — calc().

Итак, методы в Java можно разделить на 2 категории: 1. Стандартные методы. Они написаны в стандартных Java-библиотеках. Мы берём нужный метод и используем его. 2. Пользовательские методы. Это методы, написанные нами.

Как методы размещаются в программе?

Вернёмся к нашим методам, как к «строительным блокам». Как правильно размещать эти кирпичики?

Схематически это можно показать следующим образом:

Теперь давайте напишем нашу программу-калькулятор полностью:

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        double num1 = getNumber();
        double num2 = getNumber();
        char operation = getOperation();
        double result = calc(num1, num2, operation);
        System.out.println("Результат:" + result);
    }

    public static double getNumber() {
        Scanner sc = new Scanner(System.in);
        System.out.println("Введите число:");
        if(sc.hasNextDouble()) {
            return sc.nextDouble();
        } else {
            System.out.println("Ошибка при вводе. Повторите ввод");
            return getNumber();
        }
    }

    public static char getOperation() {
        Scanner sc = new Scanner(System.in);
        System.out.println("Выберите номер операции:\n1 - прибавить\n2 - отнять\n3 - умножить\n4 - разделить");
        int operationNumber = 0;
        if(sc.hasNextInt()) {
            operationNumber = sc.nextInt();
        } else {
            System.out.println("Вы ввели не число! Повторите ввод!");
            return getOperation();
        }
        switch (operationNumber) {
            case 1:
                return '+';
            case 2:
                return '-';
            case 3:
                return '*';
            case 4:
                return '/';
            default:
                System.out.println("Неправильная операция! Повторите ввод!");
                return getOperation();
        }
    }

    public static double add(double num1, double num2) {
        return num1+num2;
    }

    public static double sub(double num1, double num2) {
        return num1-num2;
    }

    public static double mul(double num1, double num2) {
        return num1*num2;
    }

    public static double div(double num1, double num2) {
        if(num2 != 0.0) {
            return num1/num2;
        } else {
            System.out.println("На 0 делить нельзя!");
            return Double.NaN;
        }
    }

    public static double calc(double num1, double num2, char operation) {
        switch (operation) {
            case '+':
                return add(num1, num2);
            case '-':
                return sub(num1, num2);
            case '*':
                return mul(num1, num2);
            case '/':
                return div(num1, num2);
            default:
                return Double.NaN;
        }
    }
}

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

А теперь давайте на минуту забудем о нашем примере и ещё раз поговорим о том, как строится каждый метод.

Как строится метод?

Вот наиболее простой метод:

Что тут у нас? Правильно, снова знакомые слова: метод println(), а также int. Возможно, вы до сих пор не знаете, что такое void, но мы сейчас всё разжуём)):

Очевидно, что myMethod не что иное, как название метода.

Оно должно быть уникальным, это важно. Когда название метода включает в себя несколько слов, их пишут по принципу CamelCase (CamelStyle). Надпись справа в круглых скобках — то, что наш метод принимает, то есть значения (параметры, атрибуты), которые мы можем применять внутри метода.

Чтобы наш метод выполнился, надо в скобках написать число (говоря Java-терминологией, передать значение в метод) типа int. Оно автоматом подставится в переменную х, после чего будет доступно внутри нашего метода. Число, которое метод принимает, называют параметром метода.

Что касается void, то это то, что метод возвращает:

Под словом «возвращает» подразумевается, что после выполнения метода мы получим определённое число, строку либо другое значение, которое можно будет использовать в месте, где был вызван метод.

Перед значением, которое надо вернуть, пишут return. Учтите, что значение, возвращающее метод, должно иметь тот же тип, который записан перед его названием. В нашем случае это double. Таким образом, с консоли мы считываем именно nextDouble().

Что касается пресловутого void, то оно переводится как «пустота». Как вы уже догадались, в этом случае метод не должен ничего возвращать после выполнения кода. Пример такого метода — println(), используемый в System.out.println(). Метод просто выводит в консоль значение, и мы ничего ему не присваиваем.

Условно говоря, можно сказать, что есть методы, что-либо возвращающие, и «войдовские» методы.

Вернёмся к нашему примеру структуры:

Мы видим, что метод, называемый myMethod(), принимает на вход число x, которое должно быть integer. При этом метод может принимать и несколько переменных (параметров), но возвращать лишь одну.

Когда мы хотим передать методу несколько параметров, то пишем пишите их через запятую:

Выше, методу myMethod() было передано три параметра, а именно: 1) int x — какое-либо целочисленное число x; 2) String s — какая-то строка (слова либо фраза); 3) long l — какое-либо число l типа long.

Кроме параметров, существует понятие «тело метода» (мы упоминали о нём в самом начале статьи). Здесь всё просто, ведь всё, написанное в фигурных скобках {}, и есть тело метода. И это не что иное, как код, который выполняет метод. В примере ниже тело метода содержит лишь одну строчку кода:

System.out.println("You enterеd number " + x);

Это означает, что метод myMehod() просто выведет в консоль число, введенное пользователем.

Попрактикуемся

Что же, давайте вернёмся к нашей программе-калькулятору и разберём код по частям, чтобы узнать, что именно делает каждый метод. Начнём, разумеется, с метода main(), задающего общую логику:

public class Calculator {
    public static void main(String[] args) {
        double num1 = getNumber();
        double num2 = getNumber();
        char operation = getOperation();
        double result = calc(num1, num2, operation);
        System.out.println("Результат:" + result);
    }

А теперь смотрите на картинку ниже. В зелёной рамке вы увидите, что включает в себя метод getNumber(), то есть его логику. В главном методе main() мы вызываем метод getNumber() дважды для того, чтобы получить от пользователя два введённых числа. 1-е из них мы записываем в переменную num1, 2-е — в переменную num2. Что касается метода getNumber(), то он возвращает число типа double, так как перед названием метода getNumber находится слово double. Кстати, именно поэтому и num1, и num2 тоже относятся к типу double.

Что можно увидеть в данном методе?

public static double getNumber() {
        Scanner sc = new Scanner(System.in);
        System.out.println("Введите число:");
        if(sc.hasNextDouble()) {
            return sc.nextDouble();
        } else {
            System.out.println("Ошибка при вводе. Повторите ввод");
            return getNumber();
        }
}

Ничего сложного нет: мы создаём Scanner, считывая число с консоли. Когда пользователь вводит не число, выведется сообщение об ошибке ввода, после чего мы заново вызовем тот же метод, попросив пользователя снова ввести число.

Идём дальше и вызовем метод getOperation() в главном методе main(). Этот метод ничего не принимает, зато возвращает char, который соответствует операции, необходимой к выполнению. Вы можете ознакомиться с логикой метода getOperation() в рамке:

И здесь мы вызываем Scanner, а потом просим, чтобы пользователь ввёл номер операции (как вы помните, у нас их четыре).

Здесь 2 уровня защиты. В первую очередь, мы проверяем, а ввёл ли пользователь число в принципе:

if(sc.hasNextInt()) {
    operationNumber = sc.nextInt();
} else {
    System.out.println("Вы ввели не число! Повторите ввод!");
    return getOperation();
}

Пусть ввёл. Но он же может набрать не цифру в диапазоне 1-4, а какой-нибудь другой параметр. Поэтому задействуем switch case:

switch (operationNumber) {
            case 1:
                return '+';
            case 2:
                return '-';
            case 3:
                return '*';
            case 4:
                return '/';
            default:
                System.out.println("Неправильная операция! Повторите ввод!");
                return getOperation();
}

Если всё правильно, метод вернёт char. В случае ошибки мы заново вызовем метод getOperation().

Напоследок вызовем метод calc(). Он примет 3 параметра (2 числа double и операцию char), возвратив результат типа double:

Что касается метода calc(), то по сути он очень прост и состоит лишь из оператора switch case, «перенаправляющего» на другие методы:

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

Делаем выводы:

Мы можем писать собственные методы. Они могут быть с параметрами или без параметров, например: — getNumber() — это метод без параметров; — getOperation() — этот метод тоже без параметров; — calc(double num1, double num2, char operation) — а этот с параметрами.
Сначала мы прописываем логику каждого метода отдельно. После этого каждый метод вызываем в главном методе main().

Компьютерное зрение