Java Keywords (Part XVII): The default keyword
This article summarize the use of the keyword default.
I suggest you review Java Keywords (Part V): Classes vs Interfaces and Java Keywords (Part IX): Switch Statements before proceeding.
Basically, in this context, the
You may ask, what is so special about this? Well, up until Java 8, interfaces could not contain concrete methods. Concrete methods are methods with a body. In contrast, as you might recall, an abstract method does not have a method body and classes implementing an interface must implement all of its methods. According to Oracle
Java keyword list
abstract | continue | for | new | switch |
assert | default | goto* | package | synchronized |
boolean | do | if | private | this |
break | double | implements | protected | throw |
byte | else | import | public | throws |
case | enum | instanceof | return | transient |
catch | extends | int | short | try |
char | final | interface | static | void |
class | finally | long | strictfp | volatile |
const* | float | native | super | while |
Keyword marked with an asterisk (*) are keywords that, although valid, are not used by programmers.
Up until Java 8 (released in March, 2014), the default
keyword had a single purpose, which was to indicate the default case in a switch statement. To illustrate quickly
String color = "red";
switch(color) {
case "red":
case "white":
case "blue":
System.out.println(color + " is a supported color.");
break;
default:
System.err.println(color + " is not supported.");
break;
}
default
keyword is akin to the else
block in an if/else flow-control structure. Please understand that the code inside the default case does not have to handle exceptional cases, just like the else block. It is simply to tell the program "do these things for all other cases" whatever "these things" are. It could be error handling.
The second use of the default
keyword for default methods in interfaces; introduced in Java 8. At the time I wrote that article, I wanted to cover this topic. After much deliveration, I decided to wait and write another article (this one) where I could wrap up the use and cover both cases. The reason was to keep it short. Covering both cases would have made the article too long and probably too "all over the place."
Here is an example of a default method in a Java interface:
public interface Pet {
void learnTrick(String trickName);
void doTrick(String trickName);
void giveName(String name);
void respondByName(String trickName);
void dressUp();
default void identify() {
System.out.println("I am simply a pet.")
}
}
Default methods enable you to add new functionality to the interfaces of your libraries and ensure binary compatibility with code written for older versions of those interfaces.You may ask, what does this mean exactly?
- It means that code written for Java 7 or earlier will continue to work if adopting classes implemeting interfaces written for Java 8 containing default methods.
- It means that code that was written for any Java version will not break if an existing interface is updated to include default methods.
- Keep in mind is that a default method can be overridden by an implementing class, but it does not have to.
Comments
Post a Comment