Very complicated Java HelloWorld app This program attempts to shows the basic concepts of inheritance and polymorphism.  In what ways could the code be modified to better demonstrate those concepts? The interface, abstract class and the class are all in separate files.

Greeting Interface

interface Greeting {
    void sayHello(String greeting, String name);
}


Abstract Hello Class

abstract class Hello {
    String name;
    String greeting;
    public abstract void setName(String name);
    public abstract void setGreeting(String greeting);
    public abstract String getName();
    public abstract String getGreeting();
}


Class that says "Hello"

public class Test extends Hello implements Greeting {
    private String name;
    private String greeting;

    public void setName(String name) {
    this.name = name;
    }
    public void setGreeting(String greeting) {
    this.greeting = greeting;
    }
    public String getName() {
    return name;
    }
    public String getGreeting() {
    return greeting;
    }
    public void sayHello(String g, String n) {
    System.out.print(g + " " + n);
    }
    public static void main(String[] args) {
    Test t = new Test();
    t.setGreeting("Hello");
    t.setName("World!");
    String h = t.getGreeting();
    String w = t.getName();
    t.sayHello(h,w);

    }
}
Your example implementation is not good enough. It's not very complicated at all, as you suggest with the title; rather, it is really simple.

The Hello abstract class is not needed. There is no reason why a class (like a WelcomeEmailContentBuilder or something of the sort) should want to extend Hello - something like a WelcomeEmailContentBuilder might already be extending a ContentBuilder or a EmailContentBuilder. You are abusing the is-a relationship. 

Consider this rewrite of your code:

interface Greeting {
    void sayHello(String greeting, String name);
}


public class Test implements Greeting {

    public void sayHello(String greeting, String name) {
        System.out.print(greeting + " " + name);
    }

    public static void main(String[] args) {
        Greeting g = new Test();
        g.sayHello("Hello", "World!");
    }

}


This code is just as functional as your original code. But it's both way shorter and doesn't muck about with an abstract class that you don't need. It also makes use of the Greeting interface for a variable - showing off that you can call functions on objects if you only have an interface.

As for making your code actually show off the use of inheritance and polymorphism, that's up to you to figure out.