null

Double income = null;
if (a>=23) 
{
   income = pay_rate; 
}

Double income = null;
if (a>=23) {income = pay_rate; }

null по умолчанию, так что если неинициализирован

вы можете использовать коробочный тип. Но я рекомендую поискать допустимые значения для ваших данных и выбрать недопустимые значения для пропущенных. В вашем конкретном случае доход, который не может быть отрицательным, поэтому вы можете выбрать -1.

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

Для случаев, когда большинство значений + ve и -ve являются допустимыми значениями, используйте либоInteger.MAX_VALUE или жеInteger.MIN_VALUE как ваше недостающее значение. Вы просто потеряете одно значение из всего доступного диапазона значений.

ПРИМЕЧАНИЕ. Автобокс (неявное преобразование из примитива в штучный тип и наоборот) является хорошей функцией, но может привести к некоторым проблемам с производительностью, которые трудно отладить и найти.

Option Тип в теории типов - это способ указать тип переменной, которая может иметь или не иметь значащее значение. Поддержка некоторых языковOption типа как в Scalascala.Option тип. Для языков, которые не поддерживают тип, вы можете использовать классы-обертки или штучные аналоги для примитивов.

  private int value;
  public Income(int value) {
    this.value = value;
  }
  public int getValue() {
     return value;
  }
  public void setValue(int value) {
    this.value = value;
  }
}

...
Income income = null;
if( a >= 23)
  income = new Income(pay_rate);

или просто

Integer income = null;
if( a >= 23)
  income = pay_rate;

бросает:

if (a>=23)
    income = pay_rate;
else 
    throw new IllegalArgumentException("income is missing");

может быть, просто так, как мне нравится, но на ваше усмотрение: p

if(a >= 23){
    income = payRate;
} else{
    income = null;
}

вместо того, чтобы установить егоnull по умолчанию вы устанавливаетеnull после того, как он проверяет, чтоa является. Кроме того, убедитесь, что доход являетсяInteger или жеDouble

Integer income = null;
if (a >= 23) {
  income = payRate; // underscores are generally considered bad convention in Java
}

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

Integer income = a>=53?pay_rate:null;

valueне дляstatementи это значениеnull, Вы не можете назначитьnull переменнымprimitive data types, такие какint а такжеdouble, но вы можете использовать его со своимиboxed аналоги -Integer, Doubleи так далее.

Когда вы делаете это, вы должны быть осторожны, чтобы проверить свои значения дляnull прежде чем получить к ним доступ. Иначе невинно выглядящийif (pay_rate > 100) может выдать исключение нулевой ссылки.

public abstract class Nullable extends Number {

    protected final boolean isNA;


    protected Nullable(boolean isNA) {
        this.isNA = isNA;
    }

    public boolean isNA() {
        return isNA;
    }
}


public final class NullableInt extends Nullable {

    public static final NullableInt NA = new NullableInt(0, true);

    private final int value;

    public NullableInt(int value, boolean isNA) {
        super(isNA);
        this.value = value;
    }

    public static NullableInt of(int value) {
        return new NullableInt(value, false);
    }

    public int getValue() {
        if (!isNA) {
            return value;
        }
        throw new RuntimeException("Value is NA");
    }

    @Override
    public int intValue() {
        return getValue();
    }

    @Override
    public long longValue() {
        return getValue();
    }

    @Override
    public float floatValue() {
        return getValue();
    }

    @Override
    public double doubleValue() {
        return getValue();
    }
}

public class Test {

    public static void main(String[] args) {
        NullableInt[] nullableInts = new NullableInt[3];
        nullableInts[0] = NullableInt.of(1);
        nullableInts[1] = NullableInt.of(2);
        nullableInts[2] = NullableInt.NA;

        System.out.println(Arrays.toString(nullableInts));
    }
}

почему вы должныnot идти за некоторые из предложенных подходов.

1. Using wrapper types and null

Integer income = null;
if (a >= 23) {
  income = payRate; 
}

У Java есть автоматическая распаковка. Что делать, если вы где-то случайно используетеincome в месте, где Java должна была автоматически распаковать его? Компилятор не может поймать эту ошибку, и ваш код взорвется во время выполнения.

Во-вторых, «обнуляемость» доход не является частьюincomeтип. В результате, программист должен быть осторожен при проверкеnull каждый раз, когда он используется. Если он забудет выполнить эту проверку, компилятор не будет жаловаться, но вы получитеNullPointerExceptionS во время выполнения.

2. Using sentinel values to denote exceptional conditions

int income = Integer.MAX_VALUE;
if (a >= 23) {
  income = payRate;
}

Этот подход имеет второй недостатокnull подход. Еще хуже, в этом случае, вместо выдачи исключения, вычисление будетcontinue даже в ошибочных условиях, так какInteger.MAX_VALUE является действительнымint, что приводит к возможным катастрофическим последствиям.

So how should you deal with this?

Используйте тип данных, который:

Maybe (также известен какOption) отвечает всем требованиям. (@Bahribayli уже предложил это. Я расширяю это.) См. Определение данныхВот.

И вот как вы бы использовали его в вашем случае:

Maybe<Integer> income = Nothing.value();
if (a >= 23) {
  income = Just.of(payRate);
}

Есть библиотека с именемФункциональная Java тотобеспечивает эту абстракцию, Если у вас есть какие-либо дополнительные вопросы относительно использования этого типа данных, я буду рад ответить на них.