Java 11 Developer Certification - Interfaces

package maxCode.online.Interface;

interface InterfaceExample {
	// Define some variables

	// no modifiers at all
	String interfaceName = "InterfaceExample";

	// single modifer
	static String staticInterfaceName = "StaticInterfaceExample";
	public String publicInterfaceName = "PublicInterfaceName";
	final String finalInterfaceName = "FinalInterfaceName";

	// double modifiers
	public final String publicFinalInterfaceName = "PublicFinalInterfaceName";
	static final String staticFinalInterfaceName = "StaticFinalInterfaceName";

	// triple modifiers
	public static final String publicStaticFinalInterfaceName = "PublicStaticFinalInterfaceName";

	// These methods are private because we declared them private.
	private String privateMethod() {
        return "private";
    }

	private static String privateStaticMethod() {
		return "private static";
	}

	// These methods are public implicitly
	default String defaultMethod() {
		// You can call private method from a default method
		return privateMethod() + " then default";
	}

	static String publicStaticMethod() {
		// You can call private static method from public static method
		return InterfaceExample.privateStaticMethod() + " then static";
	}

	// This is the public method that would, in theory, be the method
	// that you want all implementing classes to have in common.
	abstract void theImportantMethod();
}

public class InterfaceTest implements InterfaceExample {
	public static void main(String[] args) {
		// Regardless of how you define it, a variable on an interface is
		// public static final
		System.out.println("All fields on an interface are" + " public static final:");
		System.out.println(InterfaceExample.interfaceName);
		System.out.println(InterfaceExample.staticInterfaceName);
		System.out.println(InterfaceExample.publicInterfaceName);
		System.out.println(InterfaceExample.finalInterfaceName);
		System.out.println(InterfaceExample.publicFinalInterfaceName);
		System.out.println(InterfaceExample.staticFinalInterfaceName);
		System.out.println(InterfaceExample.publicStaticFinalInterfaceName);

		System.out.println("\nExecuting concrete methods on interface");
		// public static method can be accessed from type
		System.out.println(InterfaceExample.publicStaticMethod());

		// default method can be accessed from object which implements type
		InterfaceTest it = new InterfaceTest();
		System.out.println(it.defaultMethod());

		System.out.println("\nExecuting methods using the interface type");
		InterfaceTest anotherIt = new InterfaceTest();
		it.testInterface(anotherIt);

		Object o = anotherIt;
		it.testInterface(o);
	}

	public void theImportantMethod() {
		System.out.println("This is the important method that all objects "
				+ "implementing InterfaceTest must override and implement ");
	}

	// Method that accepts the interface as a parameter
	public void testInterface(InterfaceExample it) {
		System.out.println("Executing testInterface with InterfaceExample");
		it.theImportantMethod();
	}

	// Method that accepts on object as a parameter
	public void testInterface(Object o) {
		System.out.println("Executing testInterface with Object");
		// Using instanceof with an interface
		if (o instanceof InterfaceExample) {

			// Casting using an interface
			InterfaceExample it = (InterfaceExample) o;
			it.theImportantMethod();
		}
	}
}

All fields on an interface are public static final:
InterfaceExample
StaticInterfaceExample
PublicInterfaceName
FinalInterfaceName
PublicFinalInterfaceName
StaticFinalInterfaceName
PublicStaticFinalInterfaceName

Executing concrete methods on interface
private static then static
private then default

Executing methods using the interface type
Executing testInterface with InterfaceExample
This is the important method that all objects implementing InterfaceTest must override and implement
Executing testInterface with Object
This is the important method that all objects implementing InterfaceTest must override and implement

package maxCode.online.Interface;

//Very simple interface with one method
interface Laughable {
	void laugh();
}

// A class that implements the interface
class Joke implements Laughable {
	public void laugh() {
		System.out.println("That joke is laughable");
	}
}

// A class that does not implement the interface
class Story {
	public void read() {
		System.out.println("This story is a good read");
	}
}

// A class that extends Story class above and implements
// interface
class FunnyStory extends Story implements Laughable {
	// implements laugh() method from Laughable
	public void laugh() {
		System.out.println("That story is funny");
	}

	// overrides read() method from Story
	public void read() {
		System.out.println("This story is a good giggle");
	}
}

// class Farce will be both a Story and Laughable
class Farce extends Story implements Laughable {
	public void laugh() {
		System.out.println("This story is funny in a farcical way");
	}
}

// The main class
public class InterfaceCast {
	public static void main(String[] args) {
		// Story story = new Story();
		Story story = new Farce();
		FunnyStory funnyStory = new FunnyStory();
		Joke joke = new Joke();

		// call pass through method on different types
		// of objects
		testLaughable(joke);
		testLaughable(funnyStory);

		// call pass through method on different types
		// of objects
		testStory(story);
		testStory(funnyStory);

		// Cast objects and pass to our methods
		testLaughable((Laughable) story);
		// testStory((Story) joke);
	}

	// Pass through method to execute laugh method on any
	// object that implements Laughable
	public static void testLaughable(Laughable l) {
		l.laugh();
	}

	// Pass through method to execute read method on any
	// object 'Is A' Story
	public static void testStory(Story s) {
		s.read();
	}
}

That joke is laughable
That story is funny
This story is a good read
This story is a good giggle
This story is funny in a farcical way

Story story = new Story();
testLaughable((Laughable) story);
// testStory((Story) joke);

package maxCode.online.Interface;

//Teachable interface with abstract method teach
//and default method teachTheseLessons
interface Teachable {
	// default method
	default void teachTheseLessons() {
		System.out.println("Everyone should learn art and music");
	}

	void teach();
}

// Trainable interface with abstract method train
// and default method teachTheseLessons
interface Trainable {
	// default method
	default void teachTheseLessons() {
		System.out.println("Train them to do this");
	}

	void train();
}

// Our class implements one of these interfaces for now
public class TestDefaultMethods implements Teachable, Trainable {
	// we implement teach and call the default method
	public void teach() {
		teachTheseLessons();
	}

	// we implement train for later use
	public void train() {
		System.out.println("Everyone can be trained to get up early");
	}

	// default method override
	public void teachTheseLessons() {
		System.out.println("Everyone should learn math and science");
	}

	// main method calls teach and train() methods
	public static void main(String[] args) {
		TestDefaultMethods t = new TestDefaultMethods();
		t.teach();
		t.train();
	}
}

Everyone should learn math and science
Everyone can be trained to get up early

package maxCode.online.Interface;

//Create an interface with a default method and one abstract method
interface Extendable {
	default void defaultMethod() {
		System.out.println("Extendable: Default method called.");
	}

	void extend();
}

// an interface can extend another interface
interface SubExtendable extends Extendable {
	void append();
}

public class ExtendInterfaceExample implements SubExtendable {
	public static void main(String[] args) {
		ExtendInterfaceExample su = new ExtendInterfaceExample();
		su.extend();
	}

	public void extend() {
		// You can call the interface's default method
		// from the concrete method you create.
		defaultMethod();
		append();
	}

	public void append() {
		System.out.println("Appending functionality ");
	}
}

Extendable: Default method called.
Appending functionality 

package maxCode.online.Interface;

//Interface with single abstract method
//remember all non-concrete methods are public and abstract
//implicitly on an interface.
interface Abstractable {
	void makeConcrete();
}

// An abstract class does NOT have to define concrete methods
// for the abstract methods the interface it implements
abstract class AbstractClass implements Abstractable {

	// Create an additional abstract method -
	// Note that this method is NOT public, but package-private
	// and you must declare it abstract.
	abstract void callConcrete();
}

// AbstractableExample extends AbstractClass (which in turn
// implements Abstractable). The AbstractableExample is required
// to implement all abstract methods defined by the interface and
// not implemented by the abstract class as well as any abstract
// methods declared on the abstract class itself.
public class AbstractableExample extends AbstractClass {
	public static void main(String[] args) {
		AbstractableExample e = new AbstractableExample();
		e.callConcrete();
	}

	// Method is required through extension of AbstractClass -
	// defined on the interface AbstractClass implements.
	public void makeConcrete() {
		System.out.println("method declared on Abstractable interface");
	}

	// Method required through extension of AbstractClass
	void callConcrete() {
		System.out.println("method declared on AbstractClass class");
		makeConcrete();
	}
}

method declared on AbstractClass class
method declared on Abstractable interface