Java Silver Leave the knowledge gained in receiving Java SE 8 Programmer I. The book used for study is "Thorough capture Java SE 8 Silver problem collection [1Z0-808] compatible" https://www.amazon.co.jp/dp/B01ASGJYIE/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1 Since it was, I will write it with the composition according to it.

1. Java basics

Classes always belong to some package. If the package is not declared, it belongs to the "anonymous package".
The import declaration of the java.lang package can be omitted.
There is something called static import. Originally static fields and methods are called with class name.field or class name.method. If you perform static import, you can treat it as if it were a field or method defined in the class. ** Will this be used in actual development ?? ** As a note of writing, not static import, but ʻimport static`.

package tryAny;

public class staticImport {
    public static int num = 0;

    public static void print() {
	System.out.println(num);
    }
}

package tryAny.test;

import static tryAny.staticImport.*;

public class Main {
    public static void main(String[] args) {
	num = 13;
	print();
    }
}

If a field or method with the same name exists, its import will be ignored.

2. Java data type manipulation

When representing a number as a binary, octal, or hexadecimal literal, start with the beginning, 0b, 0, 0x, respectively.
Notes on the integer literal notation _ are as follows.
Cannot be written at the beginning and end of a literal
Cannot be written before or after the symbol ** It seems that the leading 0 in octal is not a symbol. .. ** **
Null cannot be assigned to a variable of primitive type. Because null is data that indicates that the variable does not refer to anything.
The symbols that can be used for identifiers (to uniquely identify methods, classes, etc.) are _ and currency symbol. Also, the identifier must not start with a number.

3. Use of operators and judgment structures

An explicit cast is required when assigning a large range of values to a small variable.
byte:8bit：-128~127
char:16bit：0~65535
short:16bit:-32768~32767
int:32bit:-2147483648~2147483647
long:64bit:-9223372036854775808~9223372036854775807
I tried the digit overflow below.

package tryAny;

import java.nio.ByteBuffer;

public class Cast {
    public static void main(String[] args) {
	//short digit overflow
	long a = 32768;
	int b = (int) a;
	short c = (short) b;
	byte[] byteShort = ByteBuffer.allocate(2).putShort(c).array();
	System.out.println("Overflow of short digits");
	for (byte b1 : byteShort) {
	    System.out.printf("%x ", b1);
	}
	System.out.println();
	System.out.println("Int at 32768" + b);
	System.out.println("Short at 32768" + c);

	//int overflow
	long aa = 2147483648L;
	int bb = (int) aa;
	short cc = (short) bb;
	byte[] byteInt = ByteBuffer.allocate(4).putInt(bb).array();
	System.out.println("int,Overflow of short digits");
	for (byte b2 : byteInt) {
	    System.out.printf("%x ", b2);
	}
	System.out.println();
	System.out.println("Int at the time of 2147483648" + bb);
	System.out.println("Short at 2147483648" + cc);
    }
}

Standard output

Overflow of short digits
80 0 
Int at the time of 32768 32768
Short at 32768-32768
int,Overflow of short digits
80 0 0 0 
Int at the time of 2147483648-2147483648
Short 0 at the time of 2147483648

ʻInt a = 1 + (int) 1L; and cast is required even if it does not exceed the range that can be expressed by int, such as ʻint a = 1 + 1L;.
Relational operators < <= > > = can only be compared numerically. I think I can do something like true <false, but I can't.
The value that can be returned to the conditional expression of the switch statement is
Integer type less than int type and its wrapper class
Characters and strings
Enum
The condition of the case value of the switch statement is
The conditional expression must be of the same type as or compatible with the value returned.
Constant or compile-time value can be determined (that is, with final)
Must not be null
If there is an area called a constant pool in memory and a is declared as String a =" const ";, the string literal "const" is kept in the constant pool. Next, if there is a code like String b =" const ";, it scans the constant pool and since "const" exists, b will hold the memory address. ..

package tryAny;

public class ConstantPool {
    public static void main(String[] args) {
	String a1 = "constpool1";
	String b1 = "constpool1";
	System.out.println(a1 == b1);

	String a2 = new String("constpool2");
	String b2 = "constpool2";
	System.out.println(a2 == b2);
    }
}

https://qiita.com/liguofeng29/items/16d6dbec471bc5269f0e Was easy to understand.

Hey, I want to read this area too (but it seems difficult). https://dev.classmethod.jp/server-side/java/classfile-reading/

There was also a problem with if statements that do not use curly braces ({}), does this make sense to ask?

4. Creating and using arrays

Regarding the array initialization method, the following pattern will result in a compile error. ** Is there a way to remember the details of what the IDE teaches? ** **
If you specify the number of elements in the array and use the initialization operator {}, a compile error will occur.

int[] array = new int[2]{ 2, 3}; //Compile error

If the number of dimensions of the variable in the multidimensional array and the number of dimensions of the reference destination do not match, a compile error will occur.

int[][] array = new int[]{}; //Compile error

A compile error will occur if the initialization operator is used except when declaring a variable.

int[] d;
d = {2,3}; //Compile error

5. Use of loop structure

The initialization statement of the for statement can declare multiple variables, but it must be of the same type.
Multiple conditional statements of for statement cannot be described.

package tryAny;

public class For {
    public static void main(String[] args) {
	//Multiple initialization statements
	for (int i = 0, j = 1; i < j; i++) {
	    System.out.println(i);
	}
	
	//Multiple update statements
	for (int i = 0; i < 4; i++, tmp(), tmp2()) {
	    System.out.println(i);
	}
    }

    private static void tmp() {
	System.out.println("tmp");
    }

    private static void tmp2() {
	System.out.println("tmp2");
    }
}

Labels are attached below. (** I can't think of how to use it other than code blocks and loop branches ... **)
Code block
Loop, branch
Expression
Substitution
return statement
try block
throw statement

6. Method encapsulation operations

Static methods can only be accessed by statically qualified methods. This is because something that is not static may not exist in the heap area at that time.
The only condition for overloading is the difference in arguments, ** the difference in return value and access modifier is irrelevant **.

package tryAny;

public class Overload {
    public static void main(String[] args) {
	System.out.println(ret(1, 2)); // 3
	System.out.println(ret(1.0, 2));// 0
	System.out.println(ret(1, 2.0));// 2

    }

    private static String ret(int a, int b) {
	return Integer.toString(a + b);
    }

    public static int ret(int a, double b) {
	return a * (int) b;
    }

    protected static int ret(double a, int b) {
	return (int) a / b;
    }
}

Instructions to be executed before processing in the constructor can be written in ** initialization block **.

package tryAny;

public class InitializeBlock {
    public static void main(String[] args) {
	InitTest i1 = new InitTest(); // JavaSilver
	InitTest i2 = new InitTest(" is dead");// JavaSilver is dead
	InitTest i3 = new InitTest(100, new String[] { "dummy", "point" });// JavaSilver100point
    }

}

class InitTest {
    {
	System.out.print("JavaSilver");
    }

    InitTest() {
	System.out.println();
    }

    InitTest(String str) {
	System.out.println(str);
    }

    InitTest(int a, String... str) {
	System.out.println(a + str[1]);
    }
}

If you want to call another overloaded constructor using this in a constructor, ** must be written first **.
A description of access modifiers is below. Protected, none, it's easy to forget about it.

Modifier	Description
public	Accessable from all classes
protected	Only accessible from subclasses that belong to or inherit from the same package
None	Only accessible from classes belonging to the same package
private	Only accessible from within the class

7. Inheritance operation

All methods specified in the interface are interpreted as public.
For overrides, the return value may be the same as the original or a subclass of it (co-edge return value).

package tryAny;

public class Extends {
    public static void main(String[] args) {
	Tmp tmp = new Tmp2();
	System.out.println(tmp.ret(1));
    }
}

abstract class Tmp {
    abstract Object ret(int i);
}

class Tmp2 extends Tmp {
    @Override
    Integer ret(int i) {
	return i;
    }

}

The table that defines which method is used when the method of the instance is called is called ** method dispatch table **. It is created when the instance is created and is managed by the JVM.
Overridden methods can loosen access control, but not tightly.
If you explicitly downcast the variables of the superclass, you can compile it regardless of the actual instance.

package tryAny;

public class Cast2 {
    public static void main(String[] args) {
	A a = new A();
	B b = (B) a; //Compiles, but Run-time ClassCastException occurs
    }

}

class A {

}

class B extends A {

}

8. Handling exceptions

If there is a return statement in both the catch clause and the finally clause, finally takes precedence.

package tryAny;

public class Exception {
    public static void main(String[] args) {
	int ret = test();
	System.out.println(ret); // 20
    }

    private static int test() {
	try {
	    int[] tmp = {};
	    int a = tmp[0];
	} catch (RuntimeException e) {
	    return 10;
	} finally {
	    return 20;
	}
    }

}

If an exception occurs in the static initializer, the JVM raises an ExceptionInitializerError.

9. Manipulating major Java API classes

How to define an immutable object
Qualify all fields with private
Do not provide a method that can change the internal state of an object
Declare the class as final to prevent the method from being overridden (prevent changes from subclasses)
If you have a variable object inside, don't provide that object to the outside
The space removed by the string trim method is "\ u0000 ~ \ u0020" in the character code.
In the append method of StringBuilder, you can also take a char array as an argument.

package tryAny;

public class StringTest {
    public static void main(String[] args) {
	String tmp = null;
	System.out.println(tmp + "a"); // nulla
	try {
	    System.out.println(tmp.concat("a"));//Nullpo comes out
	} catch (NullPointerException e) {
	    System.out.println("Nullpo outbreak");
	}

	StringBuilder sb = new StringBuilder();
	System.out.println(sb.capacity());// 16

	char[] char1 = { 'a', 'b', 'c', 'd' };
	System.out.println(sb.append(char1));// abcd
    }
}

An interface with only one method is called a functional interface.
If there is only one process in the lambda expression and the curly braces are omitted, return is not applied.

package tryAny;

public class Lambda2 {
    public static void main(String[] args) {
	Algo plus = (int x, int y) -> {
	    return x + y;
	};

	//If there is only one lambda expression process and you omit the curly braces, you must omit return.
	Algo minus = (int x, int y) -> x - y;

	System.out.println(execCalc(plus, 2, 1));
	System.out.println(execCalc(minus, 2, 1));
    }

    static int execCalc(Algo algo, int x, int y) {
	return algo.calc(x, y);
    }

    @FunctionalInterface
    interface Algo {
	int calc(int x, int y);
    }
}

You can refer to local variables in lambda expressions, but you can't rewrite them.
The LocalDate class is an immutable object.
Date differences can be calculated using the Period class, and time differences can be calculated using the Duration class.
If you want to handle thread-safe lists, use the Vector class.

All you have to do is take the exam. .. ..

What I learned with Java Silver