public abstract interface Rollable { ... }       # should use the below declaration as the keyword abstract is
                                                 # redundant, but this is acceptable
interface Rollable { ... }                       # there is no need to specify the abstract or public keywords

public interface Bounceable {
   public abstract void bounce();
   void setBounceFactor();
}

Note: you do not need to specify the public abstract modifiers (now redundant), so both above methods are acceptable, all methods are public and abstract no matter what you see.

interface Bounceable {
    default void defaultMethod() {
        System.out.println("This is an interface default method");    
    }
}

Note: default methods must be implemented and are not abstract but can be overriden, also becareful of implementing multiple default methods (with the same signature) from multiple interfaces, you will get a compiler error

public interface Bounceable {
   public static final int LOW_BOUNCE = 1;
   int HIGH_BOUNCE = 10;                      # HIGH_BOUNCE will be implicity be defined as public final static
}

Note: by putting constants in an interface you are guaranteeing that any class implementing the interface will have access to the same constant. They are also used to associate values with easy names to remember. as with the same with methods you do not need to specify the public final static modifiers (now redundant), so both above declarations are acceptable, all constants are public final static no matter what you see.

public class rubberBall implements Bounceable {
   public void bounce() { ... }               # must supply the code for the implemented interfaces method
}

Note: you are binded by a contract to supply the code for any of the interfaces methods, otherwise the compiler will complain. The signature of the method must be same as in the interface.

Also a abstract class can implement a interface but at somepoint the interface methods code must be implemented to honour the binding contract.

interface Bounceable {
    static String publicStaticMethod() {
        return "Interfaces public static method";
    }
}

Note you can then use the public static method by calling Bounceable.publicStaticMethod();

public class rubberBall implements Bounceable, Serializable, Runnable { ... }

class test implements inter1 {                        // enter into the interfaces contract, abstraction rules now apply

   public void methodA() {                            // method body for abstract methodA
      System.out.println("interface inter1 - methodA");
      count = 50;                                     // illegal - count has been marked public, static and final by the interface
      System.out.println("count" + count);
   }
}

interface inter1 {                                    // 100% abstract class - all methods are abstract
   int count = 20;                                    // implicity marked public, static and final - even if not stated

   public void methodA();                             // implicity marked public and abstract - even if not stated

   public void methodB() {                            // illegal - must be abstract method - no curly braces
      System.out.println("class test - methodB");
   }
}

Note: this program will not compile as there are a number of errors.

ArrayList rawList = new ArrayList(List.of(1, 2, 3, 4, 5));                 # This is a raw type of ArrayList
      
ArrayList <String> stringArray = new ArrayList<String>();                  # Using generics to set the data type
ArrayList <String> stringArray = new ArrayList<String>(10);                # You can set the capacity of the ArrayList, 10 in this example
ArrayList <String> stringArray = new ArrayList<>(10);                      # You can use a blank diamond
ArrayList <Integer> stringArray = new ArrayList<>(List.of(10, 20, 30));    # You can pass values into the ArrayList
ArrayList <String> stringArray = new ArrayList<>();                        # You dont have to specify the capacity

integerArray.add(intNumber);                              # Add to end of the list
integerArray.add(i, intNumber);                           # add element to specific index location
integerArray.addAll(List.of(15,20,25);                    # add a list of int's to the end of a list

stringArray.removeIf(s -> s.contains"_2"));               # you can even use lambda expressions
stringArray.removeAll(List.of("String_1", "String_2"));   # you can pass Lists to ArrayList methods

Argument List         Arrow Token           Body
(int x, int y)            ->                x + y

• A comma-separated list of formal parameters enclosed in parentheses
• You can obmit the data type of the parameters in a lambda expression
• If you include data types you must declare a data type for each parameter
• You can omit the parenthese if there is only one parameter
• If you have no parameters you can represent this with an empty parenthese set ()
• Parenthese are always used when you have multiple parameters

• Can consist of a single expression
• You do not have to enclose a void method invocation in braces
• Can consist of a statement block, a return statement is not an expression, you must enclose statements in braces {}

() -> System.out.println("Hello")             # No parameter syntax, () is required
a -> a + 1                                    # Single parameter syntax, no parenthese required
(a) -> a + 1                                  # Single parameter syntax, parenthese valid but optional
(int a) -> a + 1                              # Single parameter syntax, specifying data type
(var a) -> a + 1                              # Single parameter syntax with local varible type inference

(int a, int b) -> a + b                       # Multiple parameter syntax with declared types, all must have a type
(a, b) -> a + b                               # Multiple parameter syntax with no types, if one has not type all must have no types
(var a, var b) -> a + b                       # Multiple parameter syntax the local variable type, if one has var type then all must
have as well

Note: parenthese are always required for m ultiple parameters

() -> System.out.println("Hello")             # Single line with a statement is valid for methods which have void return type
() -> isTrue && isPlusible                    # Single line expression must be an expression which evaluates to the correct return type or covariant, if method has a return type.
(a) -> {                                      # Using return requires curly braces, all statements must terminate with a semi-colon, you can use local variables
    int count = 1;
    return a + count + 2;
}

Note: You cannot mix var data types with actual data types

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class SuppliedInterfaceTests {

    public static void main(String[] args) {

        // Set up some test data
        String[] dictionary = {"Angry", "Apple", "Art",
                "Ball", "Box", "Bump",
                "Cap", "Car", "Cone",
                "Dart", "Dog", "Duck"};

        // -- Consumer Example
        // Method returns no result, just does something on
        // the parameter passed
        Consumer str = s -> {
            StringBuilder sb = new StringBuilder(s);
            sb.insert(0, "MyApplication: SuppliedInterfaceTests : ");
            sb.insert(0, LocalDateTime.now().toLocalTime() + ": ");
            System.out.println(sb);
        };
        str.accept("I want to log this statement");

        // -- Predicate Example
        // Method returns a boolean, accepts one parameter
        Predicate aWords = p -> p.indexOf("A") == 0;
        ArrayList a = new ArrayList(Arrays.asList(dictionary));
        // demonstrate with ArrayList.removeIf method which accepts a
        // Predicate as a parameter
        a.removeIf(aWords);
        System.out.println(a);

        // Now, we demonstrate test method on Predicate
        String apple = "Apple";
        if (aWords.test(apple)) {
            System.out.println(apple + " starts with an A");
        }

        // -- Supplier Example
        // Method returns an object, accepts no parameter
        Supplier stringSupplier =
                () -> new String("returning a new String Object");
        System.out.println("stringSupplier.get() = " + stringSupplier.get());

        // -- Function Example
        // Method returns a result, and accepts one parameter
        Function funkyFunction = (s) -> {
            s = s.repeat(5);
            return s;
        };

        System.out.println("funkyFunction.apply() = "
                + funkyFunction.apply("oh no "));

    }
}