long                                           |64-bit integer| -9223372036854775808L〜9223372036854775807L    | 0L                                                
 char                                           | UTF-16 code points| 'a'、'Ah'、'Words'、'\u03b1'Such| '\u0000' (null character)                                 
 float                                          |32-bit floating point number| 1.54f etc.| 0.0f                                              
 double                                         |64-bit floating point number| 2.45d etc.| 0.0d                                              

2.3 Operator

Since the basics are the same operators as in C language, only some bit operators that are rarely used are described.

2.4 Comment

As with C language, comments are described as // one-line comments or / * block comments * /. Basically, comments in Javadoc format are desirable.

2.5 branch

Since conditional branching is basically the same as in C language, details are omitted, but only some notes are described.

• If the value is null in the switch statement, a NullPointerException will be thrown.
• For statements include extended for statements and regular for statements. Since Stream can be used in Java 8, it is often used.

2.6 Exception handling

[About exceptions]

There are three types of exceptions in Java, all of which are represented by classes that inherit from the Throwable class.

• Checked Exception: An exception that must be dealt with in the program. You need to throw the exception further to the caller above, or catch the exception with try-catch syntax.
• RuntimeException: An exception that does not need to be dealt with in the program. It is mainly used to notify an unexpected error when creating a program.
• Error: An exception that the program does not handle. It often shows a fatal error that cannot continue the operation, such as the processing cannot be continued due to lack of resources.

[How to throw an exception]

Raising an exception is often called throwing an exception. In Java, you can throw an exception with "throw new exception class ()". When throwing a checked exception, it is desirable to use @throws in the Javadoc to describe under what circumstances the exception is thrown. Some of the most commonly used run-time exceptions are:

2.7 Resources

When using resource-based processing such as file opening, DB connection, and network connection, use the try-with-resources syntax. The process of closing the resource is automatically executed at the timing of exiting the block, and the process of closing the resource is executed even if an exception occurs in the block. If an exception occurs during the process of closing the resource, you can write a handler for the exception by adding the catch theory at the end.

try  (Class name Variable name=Get resources)  {
Processing using resources
}

2.8 Modifier

The following ** modifiers ** can be specified for classes, interfaces, methods, constructors, and variables.

             [protected](http://www.tohoho-web.com/java/modifier.htm#access)|○|○|○|○|×|○|Accessmodifier|<spanstyle="color:rgb(0,0,0);">Protect access from other files and classes</span>    
              [private](http://www.tohoho-web.com/java/modifier.htm#access)       |   ○   |     ○     |   ○    |      ○      |   ×   |  ○  |Access modifier|Only access from own class
               [static](http://www.tohoho-web.com/java/modifier.htm#access)|○|○|○|×|×|○|staticmodifier|<spanstyle="color:rgb(0,0,0);">Indicates that it can be referenced even if it is not instantiated</span>  
                [final](http://www.tohoho-web.com/java/modifier.htm#final)        |   ○   |     ×     |   ○    |      ×      |   ×   |  ○  |final modifier|Indicates that it will not be overwritten. Prohibition of inheritance, overload, and change
             [abstract](http://www.tohoho-web.com/java/modifier.htm#abstract)|○|○|○|×|×|×|Abstractmodifier|<spanstyle="color:rgb(0,0,0);">It is abstract and indicates that the contents are defined and implemented at the inheritance destination.</span>  
               [native](http://www.tohoho-web.com/java/modifier.htm#native)|×|×|○|×|×|×|nativemodifier|<spanstyle="color:rgb(34,24,21);">Indicates that it is implemented in a language other than Java</span>   
         [synchronized](http://www.tohoho-web.com/java/modifier.htm#synchronized)|×|×|○|×|○|×|Syncmodifier|<spanstyle="color:rgb(0,0,0);">Indicates that exclusive control is performed in the case of multithreading.</span>   
            [transient](http://www.tohoho-web.com/java/modifier.htm#transient)    |   ×   |     ×     |   ×    |      ×      |   ×   |  ○  |Temporary modifier|Indicates that it is not subject to serialization
             [volatile](http://www.tohoho-web.com/java/modifier.htm#volatile)|×|×|×|×|×|○|Volatilemodifier|<spanstyle="color:rgb(34,24,21);">Suppress the cache and show that the values are the same across threads</span>
             [strictfp](http://www.tohoho-web.com/java/modifier.htm#strictfp)|○|○|○|×|×|×|Strictfloatingpointmodifier|<spanstyle="color:rgb(0,0,0);">Floating point arithmetic is platform independent and works strictly</span> |

2.9 Annotation

[About annotation]

Annotation means "annotation" and is a function to enter additional information for classes, methods, and packages. Added in Java SE 5 and used in the format "@ + annotation name".

The following annotations exist in the annotation.

• Marker annotation: Annotation with no data and only name (@Override, @Duplicate, etc.)
• Single-value annotation: Annotation with only one data (@SuppressWarnings, etc.)
• Full annotation: Annotation with multiple data
• Meta annotation: Annotation given to annotation

The annotations provided as standard are explained below with examples.

• @Deprecated: Annotation that explicitly states that the method specification is deprecated. Warning messages will now be displayed at compile time.
• @Override: Annotation used when overriding a method defined in a superclass. A compile error occurs when the arguments are different.
• @SuppressWarnings: Annotations that suppress warnings issued by the compiler. You can hide compile-time errors with the argument message.
• @SafeVararg: Annotation that suppresses warnings when compiling methods with variable length arguments. A warning is issued because there is a possibility of throwing a ClassCastException in generics, but it is used when there is no possibility.
• @FunctionalInterface: Annotations used for classes, interfaces, and enums that define functional interfaces. ..

[How to create annotation]

import java.lang.annotation.*;
  
//Specify how much information of the defined annotation is saved (retain information even at runtime with RUNTIME)
@Retention(RetentionPolicy.RUNTIME)
//Specify where to attach the defined annotation in the code field. It will be possible to describe in class, interface and enum with TYPE.
@Target(ElementType.TYPE)
//The information of the defined annotation will be described in Javadoc as well.
@Documented
public @interface Beta {
    String from();    //It can take a string type argument named from.@Beta(from = "1.0");And so on. If the argument name is value and it is the only argument, the description of value can be omitted.
}

2.10 Functional interface and lambda expression

[Functional interface]

A method that only declares the method name, signature, and return type is called an abstract method, and is described in the following format.

abstract [Return type] <Method name>(Signature);

Those that can have this abstract method, constant, default method, and static method as members are called an interface, and are described in the following format.

[Modifier] interface <Interface name> {
Data type variable name=value;
Qualifier Return data type Method name(Argument type declaration);
}

A functional interface is an interface that has only one defined abstract method. Even if the default method and static method are included, if there is only one abstract method, it is included in the functional interface.

[Lambda type]

Lambda expressions are a syntax introduced in Java SE 8 that allows you to concisely describe the implementation of a functional interface. In a method call that takes a functional interface as an argument, a lambda expression can be used in the argument part of the corresponding functional interface, and is described as follows.

(Lambda expression argument) -> {processing}

Reference URL: http://www.ne.jp/asahi/hishidama/home/tech/java/lambda.html

2.11 Method reference

Method reference is a syntax introduced in Java SE 8 that puts the method itself in a variable of a functional interface It is a syntax that can be assigned. The method reference is specified as follows.

//For static methods (and instance methods in some cases)
name of the class::Method name
  
//For instance methods
Instance variable name::Method name

2.12 Optional class

Optional is a class introduced in Java SE 8 that only wraps one value. is there. Optional simply holds the value, but each method of Optional changes its behavior depending on whether the held value is null or not. (Basically, processing is performed only when it is not null)

An instance of Optional becomes an object called empty if the contained value is null, and if there is a value, it becomes an instance that normally holds the value. The side that receives the Optional determines whether the Optional is empty and performs processing. Use the isPresent method to determine if Null is included in Optional. In addition to isPresent, there are orElse that returns the specified value when the value is not stored, orElseThrow that throws an exception when the value is not stored.