default-method

Consider below class hierarchy. class ClassA { private void hello() { System.out.println("Hello from A"); } } interface Myinterface { default void hello() { System.out.println("Hello from Interface"); } } class ClassB extends ClassA implements Myinterface { } public class Test { public static void main(String[] args) { ClassB b = new ClassB(); b.hello(); } } Running the program will give following error : Exception in thread "main" java.lang.IllegalAccessError: tried to access method com.testing.ClassA.hello()V from class com.testing.Test at com.testing.Test.main(Test.java:23) This is all

Cloneable in Java is inherently broken. Specifically, my biggest problem with the interface is it expects a method behavior that doesn't define the method itself. So if traversing through a Cloneable list you must use reflection to access its defined behavior. However, in Java 8, we now have default methods and now I ask why there isn't a default clone() method in Cloneable . I understand why interfaces cannot default Object methods , however, this was an explicit design decision and so exceptions can be made. I sort of envision deprecating Object.clone() and changing its interior code to

Let's take an example: public interface Testerface { default public String example() { return "Hello"; } } public class Tester implements Testerface { @Override public String example() { return Testerface.super.example() + " world!"; } } public class Internet { public static void main(String[] args) { System.out.println(new Tester().example()); } } Simply enough, this would print Hello world! . But say I was doing something else with the return value of Testerface#example , for instance initializing a data file and returning a sensitive internal value that shouldn't leave the implementing

Java 8 interface default methods vs. non-abstract methods in abstract classes - are there any differences between the two (besides the differences of iface - class, visibility etc.) Isn't a default method a step back in Java, meaning it's against the essence that Java has advertised for years?! non-abstract methods in abstract classes will be called when it's concrete subclass calls super() if it is overridden. So there are multiple possibilities. If method is not overridden then the super class method will be executed. if we use super() in the concrete subclass method then the overridden

Since Java 8 interfaces could have default methods. I know how to invoke the method explicitly from the implementing method, i.e. (see Explicitly calling a default method in Java ) But how do I explicitly invoke the default method using reflection for example on a proxy? Example: interface ExampleMixin { String getText(); default void printInfo(){ System.out.println(getText()); } } class Example { public static void main(String... args) throws Exception { Object target = new Object(); Map<String, BiFunction<Object, Object[], Object>> behavior = new HashMap<>(); ExampleMixin dynamic =