Java8 Gold exam memorandum

Overwriting

Java class design

Immutable class

Class: Final declaration not to be inherited
Field: Private final declaration to prevent external access and modification
Accessor method: Only getter method is provided

static initializer

public class Test {
    static int x;
    static { x = 1; }

Enum

Since it is automatically compiled as a final class, you cannot specify final or absolute as a modifier.
Static is automatically qualified, but you may explicitly add static
Cannot extend, but implements
Cannot be declared in a method
Always declare the constructor private
When describing fields and methods, a semicolon is required at the end of the enumeration constant. If not stated, the semicolon may or may not be added

Method	Description
static E valueOf(String name)	Returns an enumeration constant with the specified name
static E[] values()	Return an array of enums
String name()	Return the enumeration constant name as a character string
int ordinal()	Returns the ordinal of an enumeration constant starting from 0

Additional elements in Java 8

interface A {
    static void test1() {
        System.out.println("static");
    }

    default void test2() {
        System.out.println("default");
    }
}

class B implements A { }

class test {
    public static void main(String[] args) {
        A.test1(); // 「static」
        A.test2(); //Compile error
        B b = new B();
        b.test1(); //Compile error
        b.test2();  // 「default」
    }
}

If you inherit multiple interfaces with the same signature default method, a compile error will occur. Therefore, it is necessary to override it.
Multiple inheritance is possible when the distance of the type hierarchy of the interface that has the default method of the same signature is different. At that time, the default method with the shortest distance is called.

Design pattern

Singleton

public class Singleton {
    private static Singleton s = new Singleton(); // 1

    private Singleton() {} // 2

    public static Singleton getInstance(){ // 3
        return singleton;
    }
}

(1) Declare a private static field so that only one instance is always created. (2) Declare the constructor as private so that an instance cannot be created from the outside. (3) Declare a public static method that returns an instance so that the instance reference can be obtained from the outside.