default-method

In my application I run into a problem that when a getter in a class is defaulted in an interface only (Java 8 feature), there is no Java Beans property as a result. I.e. for normal method invocation it works just as a standard method, but for access through "properties" it suddenly behaves differently... Here is a test case: import java.beans.Introspector; import java.util.Arrays; import java.util.stream.Collectors; import org.apache.commons.beanutils.PropertyUtils; public class test { public static void main (String[] arguments) throws Exception { // Normal language-level invocation, works

This question already has an answer here: Explicitly calling a default method in Java 4 answers In java 8 I have something like this: package test; public class SimpleFuncInterfaceTest { public static void carryOutWork(AFunctionalInterface sfi){ sfi.doWork(); } public static void main(String[] args) { carryOutWork(() -> System.out.println("Do work in lambda exp impl...")); AImplementor implementsA = new AImplementor(); //carryOutWork(() -> implementsA.doWork()); BImplementor implementsB = new BImplementor(); carryOutWork(() -> implementsB.doWork()); } } @FunctionalInterface interface

Consider the below example, public class Testing extends SupCls implements Intf { public static void main(String[] args) { new Testing().test(); } } class SupCls { public void test() { System.out.println("From SupCls"); } } interface Intf { public default void test() { System.out.println("From Intf"); } } As you can see, there's no connection between SupCls class and Intf interface. But both are defining a common method. And Testing class is extending SupCls and implementing Intf . So, when I call test() method on Testing the output is, From SupCls Which I think makes sense because extending

In Java 8, I can easily write: interface Interface1 { default void method1() { synchronized (this) { // Something } } static void method2() { synchronized (Interface1.class) { // Something } } } I will get the full synchronisation semantics that I can use also in classes. I cannot, however, use the synchronized modifier on method declarations: interface Interface2 { default synchronized void method1() { // ^^^^^^^^^^^^ Modifier 'synchronized' not allowed here } static synchronized void method2() { // ^^^^^^^^^^^^ Modifier 'synchronized' not allowed here } } Now, one can argue that the two

While searching through the Java Language Specification to answer this question , I learned that Before a class is initialized, its direct superclass must be initialized, but interfaces implemented by the class are not initialized. Similarly, the superinterfaces of an interface are not initialized before the interface is initialized. For my own curiosity, I tried it and, as expected, the interface InterfaceType was not initialized. public class Example { public static void main(String[] args) throws Exception { InterfaceType foo = new InterfaceTypeImpl(); foo.method(); } } class

It has generally been the case the Java source code has been forward compatible. Until Java 8, as far as I know, both compiled classes and source have been forward compatible with later JDK/JVM releases. [Update: this is not correct, see comments re 'enum', etc, below.] However, with the addition of default methods in Java 8 this appears to no longer be the case. For example, a library I have been using has an implementation of java.util.List which includes a List<V> sort() . This method returns a copy of the contents of the list sorted. This library, deployed as a jar file dependency, worked

Is it a safe practice to use default methods as a poor's man version of traits in Java 8? Some claim it may make pandas sad if you use them just for the sake of it, because it's cool, but that's not my intention. It is also often reminded that default methods were introduced to support API evolution and backward compatibility, which is true, but this does not make it wrong or twisted to use them as traits per se. I have the following practical use case in mind: public interface Loggable { default Logger logger() { return LoggerFactory.getLogger(this.getClass()); } } Or perhaps, define a