ABG

Advanced Bounding with Generics (in Java)

Let’s say we have the following method in Java:

public String generateNickname(? name) { /* */ }

We want this method to take in a name and return a nickname as a String. We could use a String as the name.

public String generateNickname(String name) { /* */ }

This could work, but we might want more information. We might want an object with a method for setting the nickname to the new nickname or a method for checking to see if the object already has a nickname. We could create a Nameable interface.

public interface Nameable {

  public String getName();
  public String getNickname();
  public String setNickname(String nickname);
  public default boolean hasNickname() {
    return !getName().equals(getNickname());
  }
}

Now, we can write the method to use the Nameable interface.

public String generateNickname(Nameable name) { /* */ }

However, this does not work with any class that we don’t define. Any class in the Java API or any third party API will not use the Nameable interface we just created. What we need is a way to get any object of any class that has the methods we need. We can use a type parameter with the brand new advanced bounding feature to accomplish this.

public <O containsMethod String getName()> String generateNickname(O name) { /* */ }

What this does is say that the type parameter O must contain a method that is called getName, takes no parameters, returns a String, and is accessible. The name object would now have access to all of the Object methods as well as the getName() method.

Let’s try to extend this idea. The Nameable interface also has a setNickname() method. Let’s change this code to call the method instead of returning a String.

public <O containsMethod String getName() && containsMethod void setName(String)> void generateNickname(O name) { /* */ }

The O type parameter for this method now must define a String getName() and a void setName() that takes a String parameter. We can now call name.setNickname() within the method because we are bounding O such that it must contain this method.

These are basic examples of this idea. More bounds could be added, like containsField or containsAnnotation.