Functional Programming in Java 8 - interface

Question

As for as I have understood that functional Programming means to give a different behavor implementations interface. Would that be better than I had to create a new Class and implemented that interface in it?
I am not clear on this
interface worldGreeting {
String processName(String str);
}
public class ReadJson {
public static void main(String[] argv) throws Exception {
worldGreeting morningGreeting = (str) -> "Good Morning " + str + "!";
worldGreeting eveningGreeting = (str) -> "Good Evening " + str + "!";
System.out.println(morningGreeting.processName("Waseem"));
System.out.println(eveningGreeting.processName("Saeed"));
}
}
Second approach would be like this
class Moring implements worldGreeting{
#Override
public String processName(String str) {
return "Good Morning " + str + "!";
}
}
class Evening implements worldGreeting{
#Override
public String processName(String str) {
return "Good Evening " + str + "!";
}
}

Answer 1

The difference between single-abstract-method notation and anonymous interface implementations is immaterial, so in my code examples, I will prefer anonymous interface implementations.
Consider these two different ways to provide similar functionality:
Version 1: Type-level Inheritance
interface Greeter {
abstract String greet(String name);
}
class MorningGreeter implements Greeter {
#Override public String greet(String name) {
return "Good morning, " + name + "!";
}
}
class EveningGreeter implements Greeter {
#Override public String greet(String name) {
return "Good evening, " + name + "!";
}
}
Version 2: Anonymous Implementations
interface Greeter {
abstract String greet(String name);
static Greeter morningGreeter = new Greeter() {
#Override public String greet(String name) {
return "Good morning, " + name + "!";
}
};
static Greeter eveningGreeter = new Greeter() {
#Override public String greet(String name) {
return "Good evening, " + name + "!";
}
};
}
What are some of the differences? Version 1 adds three type-level abstractions, while Version 2 adds only one. Furthermore, Version 1 allows any number of MorningGreeters and EveningGreeters to be instantiated, whereas Version 2 is written so that there is exactly one morningGreeter and exactly one eveningGreeter.
I prefer Version 2 for a few reasons.
For one, there's no reason to ever make more than one instance of MorningGreeter, since any two instances will function indistinguishably from one another: the only difference will be their memory address. I try to only ever make classes for things that I will instantiate many times and with different properties.
Second, I personally don't think that MorningGreeter and EveningGreeter should be their own type-level abstractions, since they do not add any methods or fields to Greeter. I try to limit my type-level abstractions by the methods and fields they support, since the purpose of the type system is to prevent you from calling the wrong methods on objects that might not support it, and Greeter is the type-level abstraction for objects that have a single method with signature String greet(String name). I don't feel there is much value in creating two new type-level abstractions with the exact same methods.
Third, Version 2 presents a clear entry point for users of this (very simple) library. In Version 1, users either need to grep all the project files for "implements Greeter" or use IDE magic to jump to the implementing classes. In Version 2, users simply create a greeter with either of the two static convenience methods.
I hope this answers your question. I think it's a good question, more than just a matter of personal taste.