What is more idiomatic: setters taking an Optional<T> or just T?

Question

When using Optional<T> with a nullable field, is it more idiomatic to have the setter take

• an Optional<T>
  or
• just a T and then have it as follows?

public class Bar {
    private Optional<T> foo;

    public void setFoo(T foo) {
        this.foo = Optional.<T>fromNullable(foo);
    }

    public Optional<T> getFoo() {
        return foo;
    }
}

Answer 1

As a general rule, I'd suggest:

public void setFoo(T foo) {
  this.foo = checkNotNull(foo); // don't allow null at all!
}

Then, if a user has a value that they know may be null, they can do:

if (foo != null) {
  bar.setFoo(foo);
}

Answer 2

I'd consider doing neither and store the value internally as just T and only have the Optional at the API level.

public class Bar {
    private T foo;

    public Optional<T> getFoo() {
        return Optional.<T>fromNullable(foo);
    }

    public void setFoo(T foo) {
        this.foo = foo;
    }
}