Java reserved word summary

What is a reserved word?
List of reserved words
Explanation of each reserved word

What is a reserved word?

A word whose purpose is predetermined in a programming language. Basically, identifiers (class names, function names, variable names) can be set freely, but the same names as reserved words cannot be used.

List of reserved words


abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	short	static	strictfp	super
switch	synchrnized	this	throw	throws
transient	try	void	volatile	while
_

Description of each reserved word

abstract

Used when declaring an abstract class.
An abstract class is a class that has the following empty methods.

abstract method name(argument, argument, ...);

When to use

When you want to create implementation-level rules when developing with multiple people.
When you want to unify method names, standardize logic, and understand what you are doing.
When you do not want to write common processing every time for all classes.
When the developer defines a subclass and wants to be able to check if the method is forgotten or the method name is correct.

Sample code

abstract class AbstractClass {
  abstract public void method();
}

class ConcreteClass extends AbstractClass{
  public void method(){
    //Implementation details
  }
}

AbstractClass c = new AbstractClass(); //Compile error
AbstractClass c = new ConcreteClass(); //Yes
ConcreteClass c = new ConcreteClass(); //Yes

assert

abstract: Used when declaring an abstract class
assert: Used for program operation verification (assertion).
Assertion (operation verification): A method for checking whether a program is operating normally. If you declare a condition that is always true at that time in various parts of the program, Java will automatically detect that the condition is not satisfied at runtime and an AssertionError will be returned.
You can enable or disable assertions by passing the option -enebleassertions (or -ea) at runtime.

When to use

When you want to provide debugging support.
When you want to describe the developer's intention in the source code in the program.

Sample code

private int divide(int x, int y) {
    assert y != 0 : y +“Must be a number greater than 0”;

    return x / y;
}

boolean

A data type that indicates that either true or false data will always be included.
If you declare it as an instance variable, false will be entered as the initial value, but if you declare it as a local variable, the initial value will not be set, so you must set it.
Instance variable: Variable declared in the class
Local variables: Variables declared in the method
There is also a Boolean, which is used as a class. Also, while boolean cannot express null, Boolean can handle null. However, if you do not set the variable to be null, you will get a NullPointerException.

When to use

When expressing the comparison result of a numerical value or a character string.
When the if statement indicates the direction of branching.
When deciding whether to continue the loop with a for statement or while statement.

Sample code

//In the case of if statement
public class Main {
    public static void main(String[] args) throws Exception {
        boolean bool1 = false;
        
        if(bool1) {
          System.out.println("The value of bool1 is true");            
        } else {
          System.out.println("The value of bool1 is false");
        }
        
        int number = 100;
        
        boolean isResult = number < 200;
        
        if(isResult) {
          System.out.println("The value of isResult is true");            
        } else {
          System.out.println("The value of isResult is false");    
        }
 
    }
}
//Execution result
The value of bool1 is false
The value of isResult is true

//For while statement
public class Main {
    public static void main(String[] args) throws Exception {
        boolean bool = true;　//Initial value setting
        int count = 1; //Initial value setting
        
        while(bool) {
            System.out.println("The value of count is" + count + "is.");  
            if(count == 5) {
                bool = false; //Processing to be executed when the value of count reaches 5.
            }
            count++; //Add 1 to the value of the variable "count".
        }
 
    }
}
//Execution result
The value of count is 1.
The value of count is 2.
The value of count is 3.
The value of count is 4.
The value of count is 5.

//For Boolean type
public class Main {
    public static void main(String[] args) throws Exception {
        Boolean bool = null;
        
        if(bool == null) {
            System.out.println("The value of bool is null");
        } else if(bool) {
            System.out.println("The value of bool is true");
        } else {
            System.out.println("The value of bool is false");            
        }
 
    }
}
//Execution result
The value of bool is null

break

The break statement is a syntax used in blocks of for statements, while statements, do..while statements, and switch statements to break out in the middle of processing. Get out of the innermost loop (repetitive process). When exiting a double loop, attach a label (like a name) to the first for statement, and specify that label when exiting with break.

When to use

When you want to finish the process and execute the next process under specific conditions.

Sample code

//For switch statements
public static void main(String[] args) {
  int num = 3;
  switch(num) {
    case 1:
      System.out.println("It's 1");
      break;
    case 2:
      System.out.println("It's 2");
      break;
    case 3:
      System.out.println("It's 3");
      break;
    case 4:
      System.out.println("It's 4");
      break;
    default:
      System.out.println("It's default");
  }
}
//Execution result
It's 3

//For statement
public static void main(String[] args) {
  for (int i = 1; i <= 5; i++) {
    if (i == 3) {
      break;
    }
    System.out.println(i + "Time");
  }
  System.out.println("It's done");
}
//Execution result
First time
Second time
It's done

//For while statement
public static void main(String[] args) {
  int num = 1;
  while(true) {
    if (num == 3) {
      break;
    }
    System.out.println(num + "This is the second time");
    num++;
  }
  System.out.println("It's done");
}
//Execution result
It's the first time
It's the second time
It's done

//For double loop
loop1: for(Initialization formula;Conditional expression;Change formula){//Specify the name of the for statement in loop1
        for(Initialization formula;Conditional expression;Change formula){
                if(Conditional expression when exiting the for loop) break loop1;//Specify the for statement to exit in loop1

Processing content
        }
}
//Execution result
When the condition is met, exit the loop1 process

byte

An integer data type, one of the so-called primitives.
Can represent integers from -128 to 127.

When to use

When handling binary files and binary data "as is".
Binary file: A file of binary data. Of these, those that can be handled by a text editor are classified as text files.
Binary data: Data expressed in binary for direct processing by a computer.
The data sent from the server during streaming when watching a video is binary data.
Often used to represent a collection of binary data as an array rather than as a single variable.

Sample code

//Declaration of byte type variable and assignment of initial value
byte b = 100;
 
//Declaration of byte type array and assignment of value to each index
byte[] byteArray1 = new byte[3];
byteArray1[0] = 11;
byteArray1[1] = 12;
byteArray1[2] = 13;
 
//Declaration of byte type array and initialization at the same time
byte[] byteArray2 = { -128, 0, 127 };

switch

A reserved word that performs conditional branch processing.

When to use

Used when there are multiple conditional branch destinations.

Sample code

public class Main {
  public static void main(String[] args) {
    int num = 3;
    switch(num) {
    case 1:
      System.out.println("Variable num is 1");
      break;
    case 2:
      System.out.println("The variable num is 2");
      break;
    case 3:
      System.out.println("Variable num is 3");
      break;
    case 4:
      System.out.println("Variable num is 4");
      break;
    default:
      System.out.println("The variable num is not an integer from 1 to 4");
    }
  }
}
//Execution result
Variable num is 3

case

A reserved word used when performing conditional branch processing in a switch statement.

When to use

Used when describing the conditional branch destination of a switch statement.

Sample code

public class Main {
  public static void main(String[] args) {
    int num = 3;
    switch(num) {
    case 1:
      System.out.println("Variable num is 1");
      break;
    case 2:
      System.out.println("The variable num is 2");
      break;
    case 3:
      System.out.println("Variable num is 3");
      break;
    case 4:
      System.out.println("Variable num is 4");
      break;
    default:
      System.out.println("The variable num is not an integer from 1 to 4");
    }
  }
}
//Execution result
Variable num is 3

default

A reserved word for processing when a condition is not met in a switch statement.
A reserved word for having a method to be implemented in interface.

When to use

Used when executing processing when the condition is not met in the switch statement.
When you want the interface to have a method.

Sample code

public class Main {
  public static void main(String[] args) {
    int num = 5;
    switch(num) {
    case 1:
      System.out.println("Variable num is 1");
      break;
    case 2:
      System.out.println("The variable num is 2");
      break;
    case 3:
      System.out.println("Variable num is 3");
      break;
    case 4:
      System.out.println("Variable num is 4");
      break;
    default:
      System.out.println("The variable num is not an integer from 1 to 4");
    }
  }
}
//Execution result
The variable num is not an integer from 1 to 4

//For interface
interface Foo{
    void print(String s);
    default void twice(String s){
        print(s);
        print(s);
    }
}

try

A reserved word used for processing that may cause an exception.

When to use

Used to describe the processing that may cause an exception when you want to perform the processing when an exception occurs.
When you want to understand the cause when a problem occurs during processing.

Sample code

public class Main {
 
    public static void main(String[] args) {
        int result;
        result = div(5, 0);
        System.out.println("Return value= " + result);
    }
 
    public static int div(int num1, int num2) {
        try {
            int result = num1 / num2;
            
            return result;
 
        } catch (ArithmeticException e) {
            System.out.println("Exception occured.");
            System.out.println(e);
 
            return 0;
        }
    }
 
}

catch

A reserved word to handle when an exception occurs.
Describe as follows.

catch(Exception class variable name) {
Exception handling;
}

Exception class: There are the following.
Throwable
- Error
Error exceptions * OutOfMemoryError * ClassFormatError ...etc.
- Excption
Exception type exception * IOException * ConnectException ...etc.
RuntimeException * NullPointException * ArrayIndexOUtOFBOUndsExeception ...etc.

When to use

When there is a process that may cause an exception, it is used to describe the process that you want to perform when an exception actually occurs.

Sample code

public class Main {
 
    public static void main(String[] args) {
        int result;
        result = div(5, 0);
        System.out.println("Return value= " + result);
    }
 
    public static int div(int num1, int num2) {
        try {
            int result = num1 / num2;
            
            return result;
 
        } catch (ArithmeticException e) {
            System.out.println("Exception occured.");
            System.out.println(e);
 
            return 0;
        }
    }
 
}
//Execution result
Exception occured.
java.lang.ArithmeticException: / by zero
Return value= 0

finally

A reserved word that declares the process to be executed regardless of whether an exception occurs.

When to use

Used to describe the process you want to execute when there is a process that is likely to cause an exception, regardless of whether an exception occurs.

Sample code

int n[] = {18, 29, 36};

System.out.println("start");

try{
  for (int i = 0; i < 4; i++){
    System.out.println(n[i]);
  }
}
catch(ArrayIndexOutOfBoundsException e){
  System.out.println("Beyond the range of the array");
}
finally{
  System.out.println("Finished outputting the array");
}

System.out.println("Finished");

throw

A reserved word for intentionally raising an exception and handling the exception.
Intentionally raising an exception: Raising an exception and returning an error message when a certain condition is met.

When to use

Used when you want to raise an exception when processing.

Sample code

public class Main {
 
    public static void main(String[] args) {
        int result;
        result = div(5, 0);
        System.out.println("Return value= " + result);
    }
 
    public static int div(int num1, int num2) {
        try {
            if (num2 == 0) {
                throw new ArithmeticException("Raise an exception when divided by 0");
            }
            int result = num1 / num2;
 
            return result;
 
        } catch (Exception e) {
            System.out.println("Exception occured.");
            System.out.println(e);
 
            return 0;
        }
    }
 
}
//Execution result
Exception occured.
java.lang.ArithmeticException:Raise an exception when divided by 0
Return value= 0

throws

A reserved word that allows the caller to handle the exception when an exception occurs.
What is the caller: In the code below, main calls the math method, so main is the caller and math is the callee.

public static void main(String[] args) {
    int num = 10;

    math(num);

    math(int i) {
        int i += 100;
    }
}

When to use

Used when you want to handle the exception occurrence of the called method in the calling method.
Readability can be improved by calling various methods with the main method and handling exceptions there.

Sample code

public class Main {
 
    public static void main(String[] args) {
        int result = 0;
        try {
            result = div(5, 0);
        } catch (Exception e) {
            System.out.println("Exception occured.");
            System.out.println(e);
        }
 
        System.out.println("Return value= " + result);
    }
 
    public static int div(int num1, int num2) throws ArithmeticException {
        int result = num1 / num2;
 
        return result;
    }
 
}
//Execution result
Exception occured.
java.lang.ArithmeticException: / by zero
Return value= 0

for

Reserved words that can create iterative processes.

for(Initialization formula;Conditional expression;Change formula){
Process to be executed
}

There is also an extended for statement, which is described as follows.

for (Type variable name:Array name or collection name){
Process to be executed
}

When to use

Used when repeating processing.

Sample code

public class sample {
    public static void main (String[] args){
        int sum = 0;//[1]
        for (int number = 1; number <= 10; number++) {//[2]
            sum += number;//[3]
        }
        System.out.println("sum:" + sum);//[4]
    }
}
//Execution result
sum:55

continue

A reserved word for skipping the rest of the processing and returning to the beginning of the repetition in the middle of the iterative processing such as for statement and while statement.

When to use

Used when you want to skip the rest of the process and return to the beginning of the iterative process under certain conditions when performing the iterative process.
Can only be used in iterative processing.

Sample code

class sample{
    public static void main(String args[]){
  
      for (int i = 1; i < 10; i++){
        if (i % 2 == 0){//In this case, only when the value of i is even(1)Will be skipped
          continue;
        }
  
        System.out.println("i = " + i);//(1)
      }
    }
  }
//Execution result
i = 1
i = 3
i = 5
i = 7
i = 9

Reserved words for conditional branching.

When to use

There are 6 ways to use it.
1. Description method when there are multiple conditions in the if-else statement
1. How to use comparison operators (equal and inequality signs)
1. How to use logical operators (OR / AND / NOT)
1. A description method in which the if-else statement is omitted on one line using the ternary operator.
1. How to check if the string matches (equal) / contains the string
1. How to control the loop with break or continue

Sample code

//In case of 1
public class Main{
  public static void main(String[] args){
    int number = 80;
 
    if (number > 90) {
      System.out.println("Great result!");
    } else if (number > 60) {
      System.out.println("It's a good result.");
    } else {
      System.out.println("Let's do our best.");
    }
  }
}
//Execution result
It's a good result.

//In case of 2
public class Main{
  public static void main(String[] args){
    int number = 10;
    if (number < 20) {
      System.out.println(number + "Is less than 20");
    }
  }
}
//Execution result
10 is less than 20

//In case of 3
public class Main{
  public static void main(String[] args){
    int number = 10;
 
    if ((number < 20) || (number >= 10)) {
      System.out.println(number + "Is a value greater than or equal to 10 or less than 20");
    }
  }
}
//Execution result
10 is a value greater than or equal to 10 or less than 20

//In case of 4
public class Main {
    public static void main(String[] args) {
 
        int number = 10;
        String str = (number == 5) ? "number is 5" : "number is not 5";
        System.out.println(str);
    }
}
//Execution result
number is not 5

//In case of 5
public class Main {
    public static void main(String[] args) {
 
        String str1 = "Pote bread";
        if(str1 == "Pote bread") {
          System.out.println("str1 matches the string "potepan"");
        } else {
          System.out.println("str1 does not match the string "potepan"");
        }
    }
}
//Effective result
str1 matches the string "potepan"

else

A reserved word for processing when the condition is false when performing conditional branching with an if statement.

When to use

Used when describing the processing when the condition is not satisfied in the if statement.

Sample code

class sample {
    public static void main (String[] args){
        int number = 200;//[1]
        if (number >= 1 && number <= 9){//[2]
            System.out.println("[3] number : 1 - 9");
        } else if (number >= 10 && number <= 99) {//[4]
            System.out.println("[5] number : 10 - 99");
        } else {//[6]
            System.out.println("[7] number >= 100");
        }
    }
}
//Execution result
[7] number >= 100

char

A type that can store one character.
Use the one expressed in 16-bit Unicode.
16-bit Unicode: Characters numbered from 0 to 65535.

When to use

Used when storing one character.

Sample code

class sample {
    public static void main(String[] args) {
        char  chrHensu1 = 'A';      //Substitute A as it is
        char  chrHensu2 = 0x0041;   //Specify 0x0041
        char  chrHensu3 = 65;       //Specify 65
         
        System.out.println(chrHensu1);
        System.out.println(chrHensu2);
        System.out.println(chrHensu3);
    }
}
//Execution result
A
A
A

class

A reserved word that declares a class.

When to use

Used when declaring a class.

Sample code

class class name{
Execution processing...
}

const

Invalid reserved word.
A reserved word that means "constant" in C / c ++.
In Java, it corresponds to "final".

When to use

Since it is a reserved word, it cannot be used for variable names, function names, and class names.

Sample code

None

Reserved words used with while statements.

When to use

In iterative processing, the evaluation of the first conditional expression is usually performed before the iterative processing is started. In some cases, the next process may be executed without being processed even once.
Used when you want to process the while statement only once to prevent such a situation.

Sample code

public class sample {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println((i + 1) + "This is the second process");
            i++;
        } while (i < 3);
        System.out.println("Processing is finished");
    }
}
//Execution result
This is the first process
This is the second process
This is the third process
Processing is finished

double

One of the data types that can handle decimal numbers.
There is also a class Double, which can also represent null.
Can be expressed as null when there is a mistake in the assigned number and there is no value.

When to use

Used when handling large numbers in the range of 10 ^ 303 to 10 ^ -324.
The way to write numbers that can be assigned to double variables is as follows.
Decimal number (integer, decimal)
Decimal number + exponential notation
Binary (starting with 0b, integer), Java 7 or later
Eighth number (starting with 0, integer)
Hexadecimal (starting with 0x, integer)
Hexagon + exponential notation

Sample code

//Decimal numbers with a decimal point and integers in binary, octal, and hexadecimal numbers
double d1 = 12345; //Decimal number(integer)
double d2 = 1.2345; //Decimal number(There is a decimal point)
double d3 = -123_456.789_012; //Decimal number, with delimiter
double d4 = 0b0101; //Binary integer
double d5 = 012345; //Integer integer
double d6 = 0x12345; //Hexian integer

//Decimal and hexadecimal exponential notation
double d1 = 1.23e4; //Decimal exponential notation(1.23 × 10 4) → 12300
double d2 = -1.23e-4; //Decimal exponential notation(-1.23x10-4th power) → -0.000123
double d3 = 0x1.23p4; //Hexagonal exponential notation(0x1.23 x 2 to the 4th power) → 18.1875
double d4 = -0x1.23p-4; //Hexagonal exponential notation(-0x1.23x2-4th power) → -0.071044921875

//D as a suffix/If you add a D, the literal will be treated as a double
double d1 = 5 / 10; //→ 0, int 5 is divided by int 10 so the calculation result is int 0
double d2 = 5 / 10d; // → 0.Since 5 of 5 and int is divided by 10 of double, 5 also becomes double, and the calculation result is 0 of double..Become 5

enum

A type that can combine multiple constants into one.
Because it is a class, you can define fields and methods.
important point
You can assign values to the enumeration of the Enum class, but in that case you need to define the fields and constructor.
Only private access modifiers are allowed in the Enum class constructor.
The Enum class cannot inherit from another class, but it can implement an interface.
Describe and use as follows.

Access modifier enum enum{Enumerator 1,Enumerator 2,・ ・ ・};

When to use

Used when you want to process a fixed value.
Because you can describe the constant you decided in enum, and you can describe the process with switch statement etc. for that value.

Sample code

When using a switch statement
public class Main {
 
    public static void main(String[] args) {
        Fruit fruit_type = Fruit.Orange;
        
        switch(fruit_type) {
            case Orange:
                System.out.println("Delicious oranges");
                break;
            case Apple:
                System.out.println("I want to eat apples");
                break;
            case Melon:
                System.out.println("Melon is everything");
                break;
        }
    }
    
    protected enum Fruit {
        Orange,
        Apple,
        Melon
    };
    
}
//Execution result
Delicious oranges

When defining fields and methods
public class sample {
    public static void main(String[] args) {
        for(Fruit frt : Fruit.values()) {
            System.out.println(frt.ordinal() + ":" + frt.name() + "," + frt.getValue());
        }
    }
    protected enum Fruit {
        Orange("Ehime"),
        Apple("Aomori"),
        Melon("Ibaraki");
        
        //Define field
        private String name;
        
        //Define constructor
        private Fruit(String name) {
            this.name = name;
        }
        
        //Method
        public String getValue() {
            return this.name;
        }
    }
    
}
//Execution result
0:Orange,Ehime
1:Apple,Aomori
2:Melon,Ibaraki

extends

Reserved words for class inheritance.
The inheriting class is called "base class", "super class", "parent class", etc.
Classes that inherit the base class are called "derived classes", "subclasses", "small classes", etc.
In the derived class, if you want to change the processing of the base class, you can write another processing without changing the method name and arguments of that processing. This is called an override.

When to use

The amount of code to be programmed can be reduced and the readability of the source code can be improved.
By defining a parent class, it can be used in other child classes, so the code can be handled together.

Sample code

public class Student{
　　String name;
　　int id;
　　attend(){}
}

public class School extends Student{
　　test(){}
}

interface

Reserved words used when implementing an interface.
There is a rule that the interface can only define constants and methods.

When to use

Use the constants defined in the interface in the defined method.
It is the same if you define what is defined in the parent class in the small class like inheritance of the class, but the big difference from the inheritance of the class is that the class can inherit only one at a time, whereas the interface Can be implemented many at a time. Instead, you must define all the methods that you have defined in the interface-less where you implemented the interface.

Sample code

//Creating an interface
interface Calc {
    int NUM1 = 1;
    int NUM2 = 2;
 
    void calc();
}
 
//Implement the interface and create a class to add
class Add implements Calc {
    public void calc() {
        System.out.println(NUM1 + NUM2);
    }
}
 
//Implement the interface and create a class to subtract
class Sub implements Calc {
    public void calc() {
        System.out.println(NUM1 - NUM2);
    }
}
 
//Create a class that executes the class that implements the interface
public class sample {
    public static void main(String[] args) {
        Add add = new Add();
        add.calc();
 
        Sub sub = new Sub();
        sub.calc();
    }
}
//Execution result
3
-1

implements

A reserved word used when implementing an interface when defining a class.

When to use

Assuming that the interface is defined, use it when you want to implement it in the class.

Sample code

public class Sample implements interface name{}

private

Access modifier.
Access modifiers: Control the access restrictions of defined classes and where their members can access them.

When to use

A qualifier that can only be accessed from within the class.

Sample code

class PublicClass {
    private String fieldVariable = "PublicClass field variable.";
    
    public void publicMethod() {
        System.out.println(fieldVariable + "Output from publicMethod.");
    }
}
 
public class sample {
 
    public static void main(String[] args) {
        PublicClass pc = new PublicClass();
        pc.publicMethod();
    }
 
}
//Execution result
PublicClass field variable.Output from publicMethod.

protected

Access modifier.

When to use

An access modifier that allows a class in the same package or a different package to be accessed from within a subclass that inherits that class.

Sample code

//When referencing from a subclass
class SuperClass {
    protected String str = "Variables in SuperClass";
}
 
public class sample extends SuperClass {
 
    public static void main(String[] args) {
        sample sc = new sample();
        System.out.println(sc.str);
    }
 
}
//Execution result
Variables in SuperClass

//When referencing from the same class
public class sample{
 
    public static void main(String[] args) {
        method();
    }
 
    protected static void method() {
        System.out.println("Methods with protected");
    } 
}
//Execution result
Methods with protected

//If you cannot access
class SuperClass {
    protected String str = "Variables in SuperClass";
}
 
class SubClass_NG {
 
    public static void main(String[] args) {
        SubClass_NG sc = new SubClass_NG();
        System.out.println(sc.str);
    }
 
}
//Execution result
sample.java:9:error:Can't find symbol

public

Access modifier.

When to use

A modifier that makes it accessible from anywhere.
There is only one public class and interface per file.
Also, the file name excluding the extension, the class name, and the interface name must be the same.
The access modifier that can be boiled in the class directly under the package must be public.

Sample code

class PublicClass {
    public String fieldVariable = "PublicClass field variable.";
    
    public void publicMethod() {
        System.out.println(fieldVariable + "Output from publicMethod.");
    }
}
 
public class sample {
 
    public static void main(String[] args) {
        PublicClass pc = new PublicClass();
        System.out.println(pc.fieldVariable);
    }
 
}
//Execution result
PublicClass field variable.

package

A reserved word for declaring the creation of a package.

When to use

Used when declaring a package.
What is a package: A mechanism for grouping and separating classes and interfaces.
Basically, duplicate class names are not allowed, but if the package is different, there is no problem even if the class name is covered.
Therefore, the package is used so that the class name can be covered when developing with multiple people.

Sample code

package lang.java.hello;
 
public class HelloJava {
    public HelloJava() {
        System.out.println("Hello Java!");
    }
}
package lang.cpp.hello;
 
public class HelloCpp {
    public HelloCpp() {
        System.out.println("Hello C++!");
    }
}

import

Reserved words for importing packages.

When to use

Used when importing packages.
Describe as follows.

import package name.Class name you want to import;

You can import all the classes in a package by adding. * (Wildcard) after the package name.

Sample code

import lang.cpp.hello.HelloCpp;
import lang.java.hello.HelloJava;
 
public class Main {
 
    public static void main(String[] args) {
        HelloJava hello1 = new HelloJava();
        HelloCpp hello2 = new HelloCpp();
    }
 
}

while

Syntax for iterating.

When to use

The for statement can specify the number of iterations, but the while statement is used when performing iterations for which the number is not specified.

Sample code

public class sample {
    public static void main(String[] args) {
        int num = 0;
        while (num < 3) {
            System.out.println(num);
            num++;
        }
    }
}
//Execution result
0
1
2

goto

An invalid reserved word in Java.
In C / C ++ languages, reserved words for jumping to a specific line.

When to use

Not available. If you use it, a compile error will occur.

Sample code

None

void

A reserved word that indicates that there is no return value.

When to use

Used when there is no return value of the method.
Return value: The value returned by executing the process of no method.

Sample code

public class sample {

    static String sampleMethod() {
  
        //Return the string
      return "The sample method was called";
    }
  
    public static void main(String[] args) {
  
        //Call sampleMethod and assign the result to a String variable named str
        String str = sampleMethod();
  
        //Output the contents of the str variable
      System.out.println(str);
    }
  }
//Execution result
The sample method was called

return

A reserved word for returning a return value.

When to use

1. When returning a return value.
1. If used in the middle of a method, the process is returned to the caller without executing any further process.

Sample code

//In case of 2
public class sample {
 
	public static void main(String[] args) {
		num(0, 2);
	}
 
	private static void num(int num1, int num2) {
		if (num1 == 0) {
			System.out.println("Return to the caller.");
			return;
		}
		int addAns = num1 + num2;
		System.out.println("The answer is" + addAns + "is.");
	}
 
}
//Execution result
The answer is 2.

//If there is no return in the same source code
public class sample {
 
	public static void main(String[] args) {
		num(0, 2);
	}
 
	private static void num(int num1, int num2) {
		if (num1 == 0) {
			System.out.println("Return to the caller.");
			
		}
		int addAns = num1 + num2;
		System.out.println("The answer is" + addAns + "is.");
	}
 
}
//Execution result
Return to the caller.
The answer is 2.
//Commentary
Since there is no return, the next processing of the if statement was performed.

new

A reserved word that can be instantiated (create an object).

When to use

Used when instantiating.
An object created based on a class
The one that is executed at the same time when instantiating is called a constructor.
Write the initialization process in this.

Sample code

public class main class name{
    public static void main(String[] args) {

        //Instance generation
Class name Variable name=new class name();
    }
}

class class name{

    //Constructor (executed when instantiating)
public class name(){
Initialization process, etc.
    }
}

static

A reserved word that allows you to access a variable without instantiating the class.

When to use

Can be called with class name.method name () ;.
When you do not want to perform initialization processing by instantiating each time you call. Used when you want to access the same object.

Sample code

class ClassSample {
    private int val1 = 0; //Non-static variables(Instance variables)
    private static int val2 = 0; //static variable(Class variables)
 
    //Add 1 to the variable each time the constructor class is instantiated
    public ClassSample(int val1, int val2) {
        this.val1 += val1;
        ClassSample.val2 += val2; //"name of the class.Declare a static variable with "variable name"
    }
 
    //Show variable value
    public void print(){
        System.out.println("val1 = " + val1 + ", val2 = " + val2);
    }
}
 
public class sample {
 
    public static void main(String[] args) { 
        for (int i = 0; i < 3; i++){
            ClassSample cs = new ClassSample(1, 1);
            cs.print();
        }
    }
 
}
//Execution result
val1 = 1, val2 = 1
val1 = 1, val2 = 2
val1 = 1, val2 = 3

final

A reserved word that represents a constant.

When to use

Can be used for classes, methods and variables respectively.
For variables: Used when the value of a variable or the reference destination cannot be changed.
Variables that can be final are all local variables, arguments, and fields (instance variables, class variables).
For a class: Used when the class cannot be inherited.
For methods: Used when overriding is not possible.
Abstract classes and interfaces cannot be final.
Because it cannot be inherited or implemented.

Sample code

//For variables
int x = 0; //Ordinary variable declaration, with initial value
x = 1;     //Change the value of a variable
 
final int y = 10; //Variable is declared as final, with initial value
y = 100;          //Variables set as final cannot be changed and compile error!!
 
String s = "A"; //Ordinary reference type variable declaration, with initial value
s = "B";        //Change the reference destination of the reference type variable
 
final String s2 = "C"; //Reference type variable is declared as final, with initial value
s2 = "D";              //Variables set as final cannot be changed and compile error!!

//For class
final class FinalSample {
}
 
class ChildFinalSample extends FinalSample { //Compile error!!final classes cannot be inherited
}

//For methods
class FinalSample {
 final void method() { //final instance method
 }
}
 
class ChildFinalSample extends FinalSample { //Since it is not a final class, it can be inherited.
 void method() { //Compile error!!Final instance methods cannot be overridden
 }
}

Reserved words that are invalid in Java.

When to use

do not use.

Sample code

None

float

A basic data type that represents a decimal value in 32 bits.

When to use

Used when you want to express a value with a floating point number.
Floating genus: Numerical data on the premise that an error will occur in the calculation.
Difference from double: Difference in the number of bits that can be handled
double : 64bit | float : 32bit

Sample code

public class sample {
  public static void main(String[] args) {
    float f = 1.25f;
    int num = 10;
    float addNum = num + f;

    System.out.println(num + " + " + f + " = " + addNum);
  }
}
//Execution result
10 + 1.25 = 11.25

int

A basic data type that represents an integer in 32 bits.

When to use

Since it is an integer, it handles values that increase or decrease by 1. It can represent integers up to ± 2.1 billion.
How to write int literals
Binary number (starting with “0b”, from Java 7)
Eight-ary number (starting with "0")
Decimal number (without prefix)
Hexadecimal (starting with “0x”)
What is Integer?
Since it is an object type, it is treated as a class.
Used when you want to cast from int type to String type.
Null is available.

Sample code

int i1 = 123456789; //Decimal number
int i2 = 0b1010101; //Binary number
int i3 = 012345670; //8 base
int i4 = 0x123ABCDE; //Hexadecimal
int i5 = 123_456_789; //Digit separator(Every 3 digits)
int i6 = 0b1111_1010_0101; //Digit separator(Every 4 bits)

long

A basic data type that represents an integer in 64 bits.

When to use

Used when handling large numbers that cannot be handled by int type.
int
Maximum value: 2 ^ 32-1
Minimum value: -2 ^ 31
long
Maximum value: 2 ^ 63-1
Minimum value: -2 ^ 63

Sample code

public class sample {
    public static void main(String [] args) {
      int m = 2147483647;
      System.out.println(m);
      
      m += 1;
      System.out.println(m);
  
      long n = 2147483647;
      System.out.println(n);
    
      n += 1;
      System.out.println(n);
    }
  }
//Execution result
2147483647
-2147483648
2147483647
2147483648

short

A basic data type that represents an integer in 16 bits.

When to use

Used when handling numbers between -32768 and 32767.
Not high credit frequency.
int > long > short
When an operation is performed with a short type, the operation result is returned as an int type, so if a value is not received with an int type variable, a compile error will occur.

Sample code

public class sample {
    short a=100;
    short b=10;
    short c=0;
    
    c = a + d;
    System.out.println("c =" + c );
  }
//Execution result
sample.java:6:error: <identifier>there is not

instanceof

A reserved word that determines if the class referenced by the variable is correct.

When to use

When referencing the data type.
When determining if a subclass inherits a superclass.
When determining if an interface is implemented.

Sample code

//When referring to the data type
public class sample {
    public static void main(String[] args) {
 
        Object obj = "samurai";
        System.out.println(obj instanceof String);
        System.out.println(obj instanceof Integer);
    }
}
//Execution result
true
false

//To determine if a subclass inherits a spar class
public class sample {
    public static void main(String[] args) {
 
        SubClass sub = new SubClass();
        System.out.println(sub instanceof SubClass);
        System.out.println(sub instanceof SuperClass);
    }
}
 
class SuperClass {}
class SubClass extends SuperClass{}
//Execution result
true
true

//To determine if an interface is implemented
public class sample {
    public static void main(String[] args) {
 
        SubClass sub = new SubClass();
        System.out.println(sub instanceof SubClass);
        System.out.println(sub instanceof Interface);
    }
}
 
interface Interface {}
class SuperClass implements Interface {}
class SubClass extends SuperClass {}
//Execution result
true
true

this

A reserved word that means oneself.

When to use

When referencing a method or variable of the same class.
When calling another constructor.

Sample code

//When referencing methods and variables of the same class
public class sample {

    //Sample class variable
    String animal = "Rabbits";

    public void printAnimal() {

      //Local variables
      String animal = "Cat";
      System.out.println("Local variable animal:" + animal);
      System.out.println("Class variable animal:" + this.animal);

    }

    public static void main(String[] args) {

        sample s = new sample();
        s.printAnimal();

      }
  }
//Effective result
Local variable animal:Cat
Class variable animal:Rabbits

//When calling another constructor
class ThisSample8 {
    String name;
    int amount;
    
    //① Default constructor
    ThisSample8() {
    this("Anonymous Gonbei", 10); //Call ③ with the default value
    }
    
    //② Overloaded constructor(Part 1)
    ThisSample8(String name) {
    this(name, 20); //Call ③ while using arguments
    }
    
    //③ Overloaded constructor(Part 2)
    ThisSample8(String name, int amount) {
    //Field initialization is done only with this constructor
    this.name = name;
    this.amount = amount;
    }
    
    void printProperty() {
    System.out.println(String.format("my name is%s. The money you have%It is d yen.", name, amount));
    }
    
    public static void sample(String[] args) {
    ThisSample8 sample1 = new ThisSample8();
    sample1.printProperty(); //→ Anonymous Gonbei, 10 yen
    
    ThisSample8 sample2 = new ThisSample8("Yamada Taro");
    sample2.printProperty(); //→ Taro Yamada, 20 yen
    
    ThisSample8 sample3 = new ThisSample8("Jiro Suzuki", 1000);
    sample3.printProperty(); //→ Jiro Suzuki, 1000 yen
    }
   }
//Execution result
My name is Anonymous Gonbei. The money you have is 10 yen.
My name is Taro Yamada. The money you have is 20 yen.
My name is Jiro Suzuki. The money you have is 1000 yen.

super

A reserved word for referencing an instance or member of a superclass.

When to use

When calling a superclass constructor.
When calling the method before overriding.

Sample code

//When calling the superclass constructor
public class sample {
    public static void main(String[] args) throws Exception {
        
        SubClass sub = new SubClass();
    }
}
 
class SuperClass {
 
    public SuperClass(){
        System.out.println("Super_Const");
    }
 
    public SuperClass(String str){
        System.out.println("str : " + str);
    }
    public SuperClass(int num){
        System.out.println("num : " + num);
    }
}
 
class SubClass extends SuperClass {
 
    public SubClass(){
        super("apple");
    }
}
//Execution result
str : apple
//When calling the method before overriding
class SuperClassSample {
    String str = "SuperClass";
 
    public String getSrt() {
        return str;
    }
}
 
class SubClassSample extends SuperClassSample {
    String str = "SubClass";
 
    public String getSrt() {
        return str;
    }
 
    public void print() {
        System.out.println("super.str = " + super.str);
        System.out.println("str = " + str);
 
        System.out.println("super.getSrt() = " + super.getSrt());
        System.out.println("getSrt() = " + getSrt());
    }
}
 
public class sample {
    public static void main(String[] args) {
 
        SubClassSample scs = new SubClassSample();
        scs.print();
 
    }
}
//Execution result
super.str = SuperClass
str = SubClass
super.getSrt() = SuperClass
getSrt() = SubClass

native

A qualifier that indicates a method written in a language other than Java.

When to use

There is a mechanism called JNI (java Native Interface) that links native code such as C / C ++ language.
It is actually used in the UCS source code.
Define the method name like an interface in a Java file.
If you define c file with JNIEXPORT, Java file and c file are associated.
The method name described in the Java file is the method name actually processed in the c file.

Sample code

//Java file
pablic native boolean isCameraMute();

//c file
JNIEXPORT jboolean JNICALL prefix_isCameraMute();
return isCsmeraMute();

strictfp

A reserved word for strictly processing floating point numbers according to the rules defined by the IEEE754 standard.
Classes, interfaces and methods can be employed, but variables cannot be qualified.

When to use

What is IEEE (Institute of Electrical and Electronics Enginners): An academic research organization in the field of electrical and information engineering, headquartered in the United States. Technology standardization body.
What is IEEE754: A standard for floating point numbers. It is used to obtain the same result in any environment where the error of floating point operation differs depending on 32bit or 64bit.
If strictfp is not used, it depends on the CPU of the PC.

Sample code

public class sample {
    public static void main(String args[]) {
        new sample();
    }
    //Constructor generation
    public sample() {
        this.strictfpTest();
    }

    strictfp public void strictfpTest() {
        double a = 0.01;
        double b = 0.02;
        double c = 0.0001;

        System.out.println(a * b * c);
    }
}
//Execution result
2.0E-8

synchronized

Reserved words for exclusive control.

When to use

Used when performing exclusive control.
Exclusive control: Preventing simultaneous access to shared resources that can be used by multiple processes.

Sample code

//When not using synchronized
public class sample{
    public static void main(String[] args) {
        Bathroom bathroom = new Bathroom();
        FamilyTread father = new FamilyTread(bathroom, "father");
        FamilyTread mother = new FamilyTread(bathroom, "mother");
        FamilyTread sister = new FamilyTread(bathroom, "sister");
        FamilyTread me = new FamilyTread(bathroom, "I");

        father.start();
        mother.start();
        sister.start();
        me.start();
    }
}

class FamilyTread extends Thread {
    private Bathroom mBathroom;
    private String mName;

    FamilyTread(Bathroom bathroom, String name) {
        this.mBathroom = bathroom;
        this.mName = name;
    }

    public void run() {
        mBathroom.openDoor(mName);
    }

}

class Bathroom {
    void openDoor(String name) {
        System.out.println(name + ""I'll take a bath!"");
        for (int count = 0; count < 100000; count++) {
            if (count == 1000) {
                System.out.println(name + ""I took a bath."");
            }
        }
        System.out.println(name + ""I got out of the bath!"");
    }
}
//Execution result
Father "I'll take a bath!"
Mother "I'll take a bath!"
Father "I took a bath."
My sister "I'll take a bath!"
I "take a bath!"
Mother "I took a bath."
I "I took a bath."
My sister "I took a bath."
Father "I got out of the bath!"
My sister "I got out of the bath!"
I "I got out of the bath!"
Mother "I got out of the bath!"

//When synchronized is used for class Bathroom
class Bathroom {
    synchronized void openDoor(String name) {
        System.out.println(name + ""I'll take a bath!"");
        for (int count = 0; count < 100000; count++) {
            if (count == 1000) {
                System.out.println(name + ""I took a bath."");
            }
        }
        System.out.println(name + ""I got out of the bath!"");
    }
//Execution result
Father "I'll take a bath!"
Father "I took a bath."
Father "I got out of the bath!"
I "take a bath!"
I "I took a bath."
I "I got out of the bath!"
Mother "I'll take a bath!"
Mother "I took a bath."
Mother "I got out of the bath!"
My sister "I'll take a bath!"
My sister "I took a bath."
My sister "I got out of the bath!"

transient

A qualifier that excludes objects from serialization.

When to use

Serialization: Converting the contents of an object into a byte array so that it can be saved to a file or sent to another machine.
When the Serializable interface is implemented, all fields are serialized by default, but it is used when you want to exclude them.
If you do not need to save the state.
Corresponds to the field you want to initialize when restoring the serialized one.
If the class you want to serialize has non-serializable fields.
The field of the class to be serialized must be a primitive type or a serializable type.
Classes that cannot be serialized: List, Map, Connection, InputStream, etc.
Method that actually performs serialization input / output: write.Object () S

Sample code

//Main.java
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.io.Serializable;

public class Main { 
    public static void main(String[] args) throws Exception { 
        Player player = new Player(new Badminton()); 
        player.play();         System.out.println();

        Player clonePlayer = deepCopy(player); 
        clonePlayer.play(); 
        System.out.println();

        System.out.print("Same instance of Player:"); 
        System.out.println(player == clonePlayer); 
        System.out.print("Same instance of Badminton:"); 
        System.out.println(player.getSports() == clonePlayer.getSports()); 
    }

    @SuppressWarnings("unchecked") 
    public static <T extends Serializable> T deepCopy(T t) throws Exception { 
        if (t == null) { 
            return null; 
        }

        ByteArrayOutputStream byteOut = null; 
        ObjectOutputStream objectOut = null; 
        try { 
            byteOut = new ByteArrayOutputStream(); 
            objectOut = new ObjectOutputStream(byteOut); 
            objectOut.writeObject(t); 
        } finally { 
            objectOut.close(); 
        }

        ObjectInputStream objectin = null; 
        T copy = null; 
        try { 
            objectin = new ObjectInputStream(new ByteArrayInputStream
                                                     (byteOut.toByteArray())); 
            copy = (T) objectin.readObject(); 
        } finally { 
            objectin.close(); 
        } 
        return copy; 
    } 

}

//Sports.java
public interface Sports { 
    void play(); 
}

class Badminton implements Sports { 
    @Override 
    public void play() { 
        System.out.println("Play badminton."); 
    } 
}

//Player.java
import java.io.Serializable;

@SuppressWarnings("serial") 
public class Player implements Serializable { 
    private transient Sports sports;

    public Player(Sports sports) { 
        this.sports = sports; 
        System.out.println("It is a constructor."); 
    }

    public Sports getSports() { 
        return sports;    
 }
 public void play() { 
        System.out.println("Warm up.");

        sports.play();

        System.out.println("Cool down"); 
    } 
}

volatile

A qualifier that matches the value of a variable in shared memory with each thread.

When to use

To suppress the cache of field values.
For multithreading, each thread may cache the same feel value. At this time, there is a risk that the values will be different even in the same field.
What is a cache: By displaying a value in a place different from the main memory, the amount of storage is generally smaller than that of memory, but the value can be called and updated at high speed.
To prevent the compiler from optimizing.
A compiler is software that collectively converts computer programs written in high-level programming (C, Java, etc.) that are easy for humans to understand and have complicated functions and syntax into a format that can be interpreted and executed by a computer.

Sample code

public class VolatileSample {
 
    private static volatile int count = 0;
    //private static int count = 0;
 
    public static void main(String[] args) {
        new MultiThread1().start();
        new MultiThread2().start();
    }
 
    static class MultiThread1 extends Thread {
        public void run() {
            int val = count;
            while(count < 3) {
                if (val != count) {
                    String message = getName() + ": val = " + val + ", count = " + count;
                    System.out.println(message + "update");
                    val = count;
                }
            }
        }
    }
 
    static class MultiThread2 extends Thread {
        public void run() {
            int val = count;
            while(count < 3) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = getName() + ": val = " + val + ", count = " + count;
                System.out.println(message);
                count = ++val;
            }
        }
    }
}
//Execution result
Thread-1: val = 0, count = 0
Thread-0: val = 0, count =1 update
Thread-1: val = 1, count = 1
Thread-0: val = 1, count =2 update
Thread-1: val = 2, count = 2

Java reserved word summary

Java reserved word summary

table of contents

What is a reserved word?

List of reserved words

Description of each reserved word

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code

When to use

Sample code