Java 8 lambda expression with an abstract class having only one method [duplicate]

Answer 1

No, you cannot achieve this because ClassA must be a functional interface. A functional interface is an interface that contains exactly one abstract method. It may contain zero or more default methods and/or static methods in addition to the abstract method. Because a functional interface contains exactly one abstract method, you can omit the name of that method when you implement it using a lambda expression. For example, consider the following interface:

interface Predicate<T> {
    boolean test(T t);
}

The purpose of this interface is to provide a method that operates on an object of class T and return a boolean. You could have a method that takes an instance of class that implements this interface defined like this:

public void printImportantData(ArrayList<Data> dataList, Predicate<Data> p) {
    for (Data d : dataList) {
        if (p.test(d)) {
            System.out.println(d);
        }
    }
}

where Data class could be as simple as:

public class Data {
    public int value;
}

Now, you can call the above method as follows:

 printImportantData(al, (Data d) -> { return d.value > 1; }); 

Notice the method does not have a name here. This is possible because the interface has only one abstract method so the compiler can figure out the name. This can be shortened to:

printImportantData(al, (Data d) -> d.value > 1);

Notice that here are no curly brackets and no return keyword. This is possible because the method returns a boolean and the expression d.value > 1 also returns a boolean. The compiler is therefore able to figure out that the value of this expression is to be returned from the method. This can be shortened even more to:

printImportantData(al, d -> d.value > 1);

Notice that there is no type declaration of d! The compiler can figure out all information it needs because the interface has only one abstract method and that method has only one parameter. So you don't need to write all those things in your code.
Compare the above approach to the old Java 7 style using an inner class that does effectively the same thing:

printImportantData(al, new Predicate<Data>() {
    public boolean test(Data d) {
        return d.value > 1;
    }
});

Answer 2

Well, you could change your classes to be able to write something along these lines:

public static void main(String[] args) {
    ClassB b = new ClassB("Example", new ClassA(() -> System.out.println("Hello")) {

        @Override
        public void action() {

        }
    });
}

But for this you would need to change the constructor of ClassA to accept some implementation of a functional interface, like java.lang.Runnable:

public abstract class ClassA {

    public ClassA(Runnable runnable) {
        runnable.run();
    }

    public abstract void action();

}

class ClassB {
    public ClassB(String text, ClassA a) {
        //Do stuff
    }
}

Of course you still need to implement the abstract method in ClassA, see the example above.

Answer 3

You can only instantiate a functional interface with a lambda expression.

For example:

If you change ClassA to be an interface (you'd probably want to rename it):

public interface ClassA {
    public abstract void action();
}

and keep ClassB as is:

public class ClassB {
   public ClassB(String text, ClassA a){
      //Do stuff
    }
}

You can pass an instance of (the interface) ClassA to the ClassB constructor with:

ClassB b = new ClassB("Example", () -> System.out.println("Hello"));    

On the other hand, your

ClassB b = new ClassB("Example", new ClassA(() -> System.out.println("Hello")));

attempt fails due to several reasons:

1. You can't instantiate an abstract class (you can only instantiate sub-classes of that class).
2. Even if you could instantiate class ClassA (if it wasn't abstract), your ClassA has no constructor that takes some functional interface as an argument, so you can't pass () -> System.out.println("Hello") as an argument to ClassA's constructor.