Типы констант в Java против Swift

Question

Я видел некоторые другие ответы и проконсультировался с моим учителем, но, похоже, не могу получить ответ, который ищу.В swift, если я объявляю переменную, что-то вроде:

var number1 = 1
var number2 = 2
let sum = number1 + number2
number1 = number1 + 1

Последняя строка, в свою очередь, должна увеличить значение суммы на единицу, если я правильно помню.Но в Java, насколько я могу судить, нет способа сделать это.Кто-нибудь знает способ?(суть в том, могу ли я создать переменную, значение которой свободно зависит от других переменных?

Если я ошибся в своем вопросе, дайте мне знать, я могу перефразировать.

Спасибо

Answer 1

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

int number1 = 1;
int number2 = 2;
final int sum = number1 + number2;
number1 = number1 + 1;

Чтобы получить что-то близкое к вашему Вообразив поведение, вы могли бы написать это:

int number1 = 1;
int number2 = 2;

java.util.function.IntSupplier sum = () -> number1 + number2;
number1 = number1 + 1;

... но вы должны использовать sum как sum.getAsInt(), чтобы получить текущее значение.И когда number1 или number2 являются локальными переменными, они должны быть эффективно конечными в точке, где создается лямбда.

Answer 2

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

Вы действительно помните неправильно.

В Swift обновление одного из компонентов let sum = a + b впоследствии не изменит sum.Выполнение продолжается сверху вниз.

Все, что let делает, это объявляет "константу", то есть var, которую вы больше не можете изменить.Это похоже на final int в Java.

Может быть, вы хотели, чтобы sum была функцией / замыканием?Тогда он будет выдавать «текущее» значение всякий раз, когда вы его вызываете.

Answer 3

Как уже говорили другие, это невозможно ни в Java, ни в Swift.

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

import java.util.function.Supplier;

public class Variable<T extends Number> {
    private Supplier<T> value;

    public Variable(final T value) {
        this.value = () -> value;
    }
    public Variable(final Supplier<T> expression) {
        this.value = expression;
    }
    public T value() {
        return this.value.get();
    }
    public void update(T value) {
        this.value = () -> value;
    }
    public void update(final Supplier<T> expression) {
        this.value = expression;
    }
}

Вот как выиспользуйте его:

Variable<Integer> a = new Variable<>(10);
Variable<Integer> b = new Variable<>(20);
Variable<Integer> c = new Variable<>(() -> Integer.sum(a.value(), b.value()));
System.out.println(c.value()); // 30
b.update(10);
System.out.println(c.value()); // 20
b.update(() -> Integer.sum(a.value(), 100));
System.out.println(b.value()); // 110
System.out.println(c.value()); // 120

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

Остерегайтесь того, что эта реализация может выдать StackOverflowErrorесли у вас есть рекурсивные определения, например b.update(() -> Integer.sum(a.value(), c.value()));.

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

Answer 4

Ни Java, ни Swift не работают так.int в Java и Int в Swift не отслеживают, какие другие значения «способствовали» их значениям в прошлом.