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

Question

Я делаю задание для школы, но у меня проблемы с конвертированием обертки, наверное. Мне нужно вернуть результат от сложения переменных a и b в длинном методе с таким заголовком:

public Long addIntegers(Integer a, Integer b) {
    …your code here…
} 

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

public class Wrapper {

public Integer x;
public Integer y;

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


}

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

    return sum;
}

}

Я ожидал, что это сработает, так как думал, что переменная create и Integer сможет добавить две переменные типа int, но я ошибся. Я пробовал много других способов, и самая распространенная ошибка в том, что я не могу преобразовать «x» в Long. В приведенном выше случае ошибка говорит о том, что она не может преобразовать целочисленные значения в длинные.

Answer 1

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 s в примитивные int s и складывает их вместе, в результате получается 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.

Answer 2

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

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();
    }
}

Answer 3

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

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

   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;
   }
   

---

Также:

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

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;
    }
}

Answer 4

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

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

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

Answer 5

Вот самый простой способ:

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 из-за типа возвращаемого метода.