The protected keyword is an access control modifier that can be applied to a class, method, or field (a variable declared in a class). You can reference protected classes, methods, or fields in any class that declares them, any other class in the same package, and any subclass (regardless of the package in which the subclass is declared). The default access scope for all class members is package access, which means that class members can be accessed from any class in the same package unless specific access-control modifiers are present.

The class keyword is used to declare a new Java class, which is a collection of related variables and/or methods. Class is the basic construction unit of object-oriented programming method. Classes usually represent some physical entity, such as a geometric shape or a person. A class is a template for an object. Each object is an instance of a class. To use a class, you typically use the new operator to instantiate the object of the class and then call the class’s methods to access the class’s functionality.

The final keyword can be applied to a class to indicate that the class cannot be extended (there can be no subclasses). The final keyword can be applied to a method to indicate that the method cannot be overridden ina subclass. A class cannot be abstract and final at the same time. Abstract means that the class must be extended, and final means that it cannot be extended. A method cannot be abstract and final at the same time. Abstract means that the method must be overridden, and final means that the method cannot be overridden.

The interface keyword is used to declare a new Java interface, which is a collection of methods.

Interfaces are a powerful feature of the Java language. Any class can declare that it implements one or more interfaces, which means that it implements all the methods defined in those interfaces.

Any class that implements an interface must provide implementations of all methods in that interface. A class can implement multiple interfaces.

The new keyword is used to create a new instance of the class.

The argument after the new keyword must be the class name, and the class name must be followed by a set of constructor arguments (parentheses must be used).

The parameter collection must match the signature of the constructor of the class.

The type of the variable to the left of = must be assignment compatible with the class or interface to be instantiated.

Strictfp means FP-strict, which means precise floating point. If strictFP keyword is not specified in Java virtual machine floating-point operation, the Compiler and runtime environment of Java take a kind of almost arbitrary behavior to complete these operations on the expression of floating-point operation, so that the results are often not satisfactory. When strictFP is used to declare a class, interface, or method, the declared scope of the Java compiler and runtime environment is executed according to the floating-point specification IEEE-754. So if you want to make floating-point calculations more accurate and not have inconsistent results from different hardware platforms, use the keyword strictfp.

You can declare a class, interface, and method as STRICtFP, but you are not allowed to declare strictFP keywords for methods and constructors in the interface

The transient keyword can be applied to a member variable of a class to indicate that the member variable should not be serialized when the class instance containing it has been serialized.

When an object is serialized, transient variables are not included in the serialized representation, whereas non-transient variables are included.

Java’s serialization provides a mechanism for persisting object instances. When an object is persisted, there may be a special object data member that we do not want to use serialization mechanisms to store. To turn off serialization on a field for a particular object, you can prefix the field with the keyword TRANSIENT. Transient is a Java language keyword used to indicate that a field is not part of the object’s serialization. When an object is serialized, transient variables are not included in the serialized representation, whereas non-transient variables are included.

The continue keyword is used to jump to the next iteration of the for, while, or DO loop.

Continue always skips to the next iteration of the deepest while, for, or DO statement.

The do keyword is used to specify a loop that checks its condition at the end of each iteration.

The do loop body executes at least once.

A conditional expression must be followed by a semicolon.

The if keyword indicates conditional execution of a block of code. The result of the condition must be a Boolean value.

An if statement can have an optional else clause that contains the code to be executed if the condition is false.

Expressions containing Boolean operands can only contain Boolean operands.

The for keyword is used to specify a loop that checks its conditions at the end of each iteration.

The for statement is of the form for(initialize; condition; increment)

The initialize statement is executed once the control flow enters the for statement.

The result of the condition is evaluated each time the body of the loop is executed. If condition is true, the body of the loop is executed.

After each execution of the body of the loop, the INCREMENT statement is executed before the condition of the next iteration is evaluated.

The switch statement is used to select one of multiple code blocks to execute based on an expression.

The result of the switch condition must be equal to byte, char, short, or int.

Case blocks have no implicit end point. The break statement is usually used at the end of each case block to exit the switch statement.

If there is no break statement, the execution stream will enter all subsequent case and/or default blocks.

The default keyword is used to mark the default branch in the switch statement.

The default block has no implicit end point. The break statement is typically used at the end of each case or default block to exit the switch statement when the block is complete.

If there is no default statement, a switch statement whose arguments do not match any case block will do nothing.

The try keyword is used to contain a block of statements that might throw an exception.

Every try block must have at least one catch or finally clause.

If a particular exception class is not handled by any catch clause, the exception is propagated recursively down the call stack to the next enclosing try block. If no exception is caught by any of the enclosing try blocks, the Java interpreter exits with an error message and stack trace information.

The throw keyword is used to throw an exception.

The throw statement takes java.lang.throwable as an argument. The Throwable propagates up the call stack until it is caught by the appropriate catch block.

Any method that throws a non-RuntimeException must also declare the exception it throws using the throws modifier in the method declaration.

The package keyword specifies the Java package in which the class declared in the Java source file resides.

The package statement (if present) must be the first non-annotated text in the Java source file.

Example: the Java. Lang. Object.

If the Java source file does not contain package statements, the classes defined in that file will be in the “default package.” Note that classes in the default package cannot be referenced from classes that are not in the default package.

Boolean is a Java primitive type. Boolean variables can be true or false.

Boolean variables can only take a value of true or false. Boolean cannot be converted to and from numeric types.

Expressions containing Boolean operands can only contain Boolean operands.

A Boolean class is a wrapper object class for the Boolean primitive type.

Char is the Java primitive type. The char variable can store a Unicode character.

The following char constants can be used: \b – space, \ F – page feed, \ N – newline, \ R – Carriage return, \ T – horizontal TAB, \’ – single quotes, \” – double quotes, \\ – backslashes, \ XXX – Latin-1 characters encoded in XXX. \x and \xx are both legal forms but may cause confusion. \ uXXXX – Unicode character encoding XXXX in hexadecimal.

The Character class contains static methods that you can use to handle char variables, including isDigit(), isLetter(), isWhitespace(), and toUpperCase().

Char values are unsigned.

Float is a Java primitive type. A float variable can store single-precision floating point values.

Follow these rules when using this keyword:

Floating-point literals in Java always default to double precision. To specify a single-precision literal value, add f or f after the value, such as 0.01f.

Since floating-point data types are approximations of actual values, equality comparisons of floating-point values are generally not performed.

Java floating point values can represent infinity and NaN (non-numeric). The Float wrapper object class is used to define constants MIN_VALUE, MAX_VALUE, NEGATIVE_INFINITY, POSITIVE_INFINITY, and NaN.

Long is a Java primitive type. The long variable can store 64-bit signed integers.

The Long class is a wrapper object class for the primitive type of Long. It defines MIN_VALUE and MAX_VALUE constants that represent a range of values of this type.

All integer values in Java are 32-bit ints, unless the value is followed by l or L (such as 235L), which means that the value should be interpreted as long.

Null is a Java reserved word that indicates no value.

Assigning NULL to a non-original variable frees the object previously referenced by the variable.

Null cannot be assigned to primitives (byte, short, int, long, char, float, double, Boolean).

The false keyword represents one of two valid values for a Boolean variable.

The super keyword is used to refer to the superclass of the class that uses the keyword.

Appearing as a separate statement, super means calling the constructor of the superclass.

Super. <methodName>() indicates the method that calls the superclass. This usage is only necessary if you want to call a method that was overridden in the class so that you can specify that the method in the superclass should be called.

The void keyword indicates the null type.

Void can be used as the return type of a method to indicate that the method does not return a value.

Goto preserves the keyword but does nothing. Structured programming can complete processes without goTO statements, and the use of GOTO statements tends to make programs less readable, so Java does not allow GOto jump.

Java is not perfect. In addition to the fact that the running speed of Java is much slower than that of traditional C++, Java cannot directly access the bottom layer of the operating system (such as system hardware, etc.), so Java uses native methods to expand the functions of Java programs.

Native method can be compared to the interface between Java program and C program, and its implementation steps are as follows:

1. Declare native() methods in Java and compile them.

2. Create a. H file using Javah.

3, write a. CPP file to implement native export method, which needs to include the. H file generated in the second step (note that it also includes the JDK with the jni.h file);

4. Compile the. CPP file in step 3 into a dynamic link library file.

5. Use the System.loadLibrary() method to load the DLL generated in step 4 in Java, and the native() method can be accessed in Java.