Как вернуть результат сложения a и b в методе Long?

Попробуйте этот пример

public class Main
{
    public static void main(String[] args) {

        Main main = new Main();
        System.out.println(main.addInteger(5, 5));
    }

    public Long addInteger(Integer a, Integer b) {
        Integer sum = a + b;
        return sum.longValue();
    }
}

Вам необходимо привести сумму к long как:

1. (int + int) = int приведение к [117 ]

   public Long addIntegers(Integer a, Integer b) {
       return (long) (a + b);
   }
   

2. (int приведен к long) + int = long

   public Long addIntegers(Integer a, Integer b) {
       return (long) a + b;
   }
   

   [1117 ]

Также:

• кажется, что вам не нужно attributs
• вам нужна локальная переменная для сохранения результата суммы [ 1119]

class Wrapper {

    public static void main(String[] args) {
        Wrapper aWrapper = new Wrapper();
        Long res = aWrapper.addIntegers(2, 5);
    }

    public Long addIntegers(Integer a, Integer b) {
        return (long) a + b;
    }
}

Вот самый простой метод:

public Long addIntegers(Integer a, Integer b) {
    return (long)a+b; 
}

Что происходит?

a и b неявно преобразуются в int в a+b. Поскольку результат a+b может быть больше максимального значения int (int = 32bit, long = 64bits), мы должны явно привести результат к long. Когда мы возвращаем long, он неявно преобразуется в Long из-за типа возвращаемого метода.

public Long addIntegers(Integer a, Integer b) {
    Integer sum = a + b;

    return sum;
}

Вы почти правы в этом. Я понимаю, почему вы думаете, что это сработает, но вы не можете выйти из Integer -> Long ни косвенно, ни через приведение. Вам нужно пойти Integer -> int -> long -> Long, и Java может сделать только 1 скачок неявно .

Сначала давайте посмотрим, что на самом деле делает a + b. Он распаковывает a и b из Integer в примитивные int с и складывает их вместе, в результате чего получается int. Затем он автоматически упаковывает это в Integer, потому что это тип переменной sum, которую вы определили.

Но, подождите, мы видим выше (Integer -> int -> long -> Long), что Integer на самом деле дальше от того места, где мы хотим быть, а не ближе!

Итак, давайте вернемся к a + b, который возвращает int. Мы хотим Long. Мы могли бы привести результат к long:

public Long addIntegers(Integer a, Integer b) {
    return (long) (a + b);
}

В таком случае у нас есть int - результат нашего выражения суммы - и мы явно приведем к long, и Java делает последний неявный шаг и автоматически помещает его в Long.

Однако, хотя приведение в порядке в нашем случае, это часто признак плохого дизайна, поэтому я стараюсь по возможности избегать его использования. К счастью, в нашем случае мы можем избежать броска. Нам просто нужно переключить неявный шаг и явные шаги (т.е. неявно преобразовать из int -> long и явно преобразовать из long -> Long)

public Long addIntegers(Integer a, Integer b) {
    return Long.valueOf(a + b);
}

В этом примере Long.valueOf принимает примитив long и возвращает Long, но наши вычисления a + b возвращают int, поэтому Java неявно преобразует int в long.

Поскольку a и b относятся к типу Integer, следовательно, вы можете вызвать метод longValue, чтобы получить их как длинные и суммировать их и вернуть значение, которое будет длинным, без необходимости явного приведения. 115]

public static Long addIntegers(Integer a, Integer b) {
    return a.longValue() + b.longValue();
}

Заметьте, что поскольку мы добавляем два длинных значения, мы также гарантируем, что он не столкнется с каким-либо риском переполнения целых чисел, поскольку сложение двух больших целых чисел может столкнуться с ним.