Given this interface:
import com.google.common.base.Optional;
public interface Foo<S extends Bar> {
Optional<S> get();
}
Then I've implemented the interface with Foo:
public class Baz implements Foo {
public Optional<Bippie> get { ... }; // Bippie extends Bar
{
Is it necessary to put parameters on class Baz? Why or why not?
It is technically legal to leave Baz as it is, implementing the raw Foo interface. Java will treat all generics as if they don't exist, and that code will compile.
It's generally a bad idea to use raw types, however, and it's easy to implement the generic interface properly, so just do that. You don't have to provide a generic type parameter on the class Baz:
public class Baz implements Foo<Bippie> {
public Optional<Bippie> get() {
But you can if you want to:
public class Baz<S extends Bar> implements Foo<S> {
public Optional<S> get() {
Or you could use Bippie to narrow it further:
public class Baz<S extends Bippie> implements Foo<S> {
public Optional<S> get() {
public class Baz implements Foo<Bippie> {, will Baz#get() return the Bippie type only? Or will Bar be an acceptable return type since public interface Foo<S extends Bar> { Optional<S> get() ... }?
Optional<Bippie>, because Baz is defining the S from Foo to be Bippie.Foo interface, Foo's type parameter must be a sub-type of Bar?Bar or it could be Bar itself.(The use of the keyword extends is slightly misleading: recall from Item 26 that subtype is defined so that every type is a subtype of itself, even though it does not extend itself.) -Effective Java (page 134 in my Kindle)
implements Foo<Bippie>. Follow your IDE's guidance.