runCalculation((int number, int otherNumber) -> { return number + otherNumber; }); // A functional interface with a method which has only a single parameter interface StringExtender { String extendString(String input); } // Initializing a variable of this type by using a lambda StringExtender extender = input -> input + " Extended"; Method references It is not necessary to use lambdas when there already is a named method compatible with the interface. This method can be passed instead of a lambda using a method reference. There are several types of method references: The code above which calls runCalculation could be replaced with the following using the method references: runCalculation(Integer::sum); Inheritance Interfaces can inherit from other interfaces just like classes. Unlike classes it is allowed to inherit from multiple interfaces. However, it is possible that several interfaces have a field with the same name, in which case it becomes a single ambiguous member, which cannot be accessed. /* Class implementing this interface must implement methods of both ActionListener and RequestListener */ interface EventListener extends ActionListener, RequestListener { } Default methods Java SE 8 introduced default methods to interfaces which allows developers to add new methods to existing interfaces without breaking compatibility with the classes already implementing the interface. Unlike regular interface methods, default methods have a body which will get called in the case if the implementing class doesn't override it. interface StringManipulator { String extendString(String input); // A method which is optional to implement default String shortenString(String input) { return input.substring(1); } } // This is a valid class despite not implementing all the methods class PartialStringManipulator implements StringManipulator { @Override public String extendString(String input) { return input + " Extended"; } } Static methods Static methods is another language feature introduced in Java SE 8. They behave in exactly the same way as in the classes. interface StringUtils { static String shortenByOneSymbol(String input) { return input.substring(1); } } StringUtils.shortenByOneSymbol("Test"); Private methods Private methods were added in the Java 9 release. An interface can have a method with a body marked as private, in which case it will not be visible to inheriting classes. It can be called from default methods for the purposes of code reuse. interface Logger { default void logError() { log(Level.ERROR); } default void logInfo() { log(Level.INFO); } private void log(Level level) { SystemLogger.log(level.id); } } Annotations Annotations in Java are a way to embed metadata into