Shulou(Shulou.com)06/02 Report--

This article mainly explains "what are Java keywords and reserved words". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn what Java keywords and reserved words are.

1. Access control

1) private private

The private keyword is an access control modifier that can be applied to a class, method, or field (variables declared in a class). Private (internal) classes, methods, or fields can only be referenced in classes that declare them. They are not visible outside the class or for subclasses.

2) protected protected

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 a class that declares them, any other class in the same package, and any subclass, regardless of which package the subclass is declared in.

3) public Public

The public keyword is an access control modifier that can be applied to a class, method, or field (a variable declared in a class). Public classes, methods, or fields may only be referenced in any other class or package.

So let's sum up the permission access modifier in Java (in fact, there is another permission access condition, which is by default, let's call it default).

2. Class, method, and variable modifiers

1) abstract declares abstraction

The abstract keyword can modify a class or method. The abstract class can be extended (adding subclasses), but cannot be instantiated directly. The abstract method is not implemented in the class that declares it, but must be overridden in a subclass. A class that takes the abstract method is inherently abstract and must be declared as abstract.

2) class class

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. A class usually represents an actual 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 class's object, and then call the class's method to access the class's functionality.

3) extends inheritance, extension

The extends keyword is used in class or interface declarations to indicate that the declared class or interface is a subclass of the class or interface whose name is followed by the extends keyword. The subclass inherits all the public and protected variables and methods of the parent class (but not the constructor). Subclasses can override any non-final methods of the parent class. A class can extend only one other class.

The extends keyword is used in class or interface declarations to indicate that the declared class or interface is a subclass of the class or interface whose name is followed by the extends keyword.

4) final is final and unchangeable

In Java, the final keyword can be used to modify classes, methods, and variables (including member and local variables). The final method is bound at compile time, called static binding (static binding). Let's take a look at the basic usage of the final keyword from these four aspects.

Modifier class

When you modify a class with final, it indicates that the class cannot be inherited and cannot have subclasses. In other words, if a class you will never let it be inherited, you can modify it with final. The member variable in the final class can be set to final as needed, but note that all member methods in the final class are implicitly specified as final methods.

Modification method

There are two reasons for using the final method. The first reason is to lock the method to prevent any inherited class from changing its meaning; the second reason is efficiency. In earlier versions of the Java implementation, the final method was converted to an inline call. But if the method is too large, you may not see any performance improvement from embedded calls. In recent versions of Java, there is no need to use the final method for these optimizations.

Therefore, set the method to final only if you want to explicitly prohibit the method from being overridden in the subclass.

Also, the private method of the class is implicitly specified as the final method.

Modified variable

Decorating variables is the place where final is most used.

For a final variable, if it is a variable of a basic data type, its value cannot be changed once initialized; if it is a variable of a reference type, it cannot point to another object after initialization. After the reference variable is modified by final, it can no longer point to other objects, but the content of the object it points to is mutable.

Final parameter

When the function argument is of type final, you can read and use the parameter, but you cannot change the value of the parameter or the reference point. The reason is the same as the final variable.

To sum up, it is:

A method declared as a final type in class A cannot be overridden in a subclass

If class An is declared as a class of type final, then class B cannot inherit class A.

If a member variable is declared as a final type, then the member variable cannot be modified

Note:

A class cannot be both abstract and final. Abstract means that the class must be extended, and final means that the class cannot be extended. A method cannot be both abstract and final. Abstract means that methods must be overridden, and final means that methods cannot be overridden. The two contradict each other.

When using final to act on member variables of a class, member variables (note that they are class member variables, local variables only need to be initialized before use) must be initialized at definition time or in the constructor, and final variables can no longer be assigned once they have been initialized.

The difference between final variables and ordinary variables. When a final variable is a primitive data type and a String type, if its exact value is known during compilation, the compiler optimizes it and uses it as a compile-time constant. That is, where the final variable is used, it is equivalent to the constant accessed directly, and does not need to be determined at run time. This is a bit like macro substitution in C language. On the other hand, ordinary variables cannot determine their own value at compile time and need to be known at run time.

Local inner classes and anonymous inner classes can only access local final variables. Because the local variables here need to be determined during the compilation phase. That is, if the value of the local variable can be determined during compilation, a copy is created directly inside the anonymity. If the value of the local variable cannot be determined during compilation, the copy is initialized by passing parameters from the constructor.

5) implements implementation

The implements keyword is used in the class declaration to indicate that the declared class provides an implementation of all methods declared in the interface specified by the name after the implements keyword. Class must provide implementations of all methods declared in the interface. A class can implement multiple interfaces.

6) interface interface

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

Interface is a powerful function of 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 an implementation of all methods in that interface. A class can implement multiple interfaces.

7) native local

The native keyword can be applied to a method to indicate that the method is implemented in a language other than Java, and the corresponding implementation of the method is not in the current file, but in a file implemented in other languages, such as C and C++.

Java is not perfect, Java's deficiency is reflected in the running speed is much slower than the traditional C++, Java can not directly access the bottom of the operating system (such as system hardware, etc.), so Java uses native methods to expand the functions of Java programs.

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

Declare the native () method in Java and compile

Generate a .h file with javah

Write a .cpp file to implement the native export method, which needs to include the .h file generated in the second step (note that the jni.h file with JDK is also included)

Compile the .cpp file of step 3 into a dynamic link library file

Load the dynamic link library file generated in step 4 in Java with the System.loadLibrary () method, and the native () method can be accessed in Java.

Situations where the JAVA local method is applicable

1. In order to use a feature of the underlying host platform, which cannot be accessed through JAVA API

2. To access an old system or use an existing library that is not written in JAVA

3. In order to speed up the performance of the program, the time-sensitive code is implemented as a local method.

8) new new, create

The new keyword is used to create new instances 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 parameters (must be in parentheses). The parameter collection must match the signature of the constructor of the class.

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

9) static static

Static can be used to decorate attributes, code blocks, methods, and classes.

Static modifier attribute: no matter how many objects a class generates, all of these objects share a unique static member variable; when an object modifies the static member variable, the value of the static member variable of other objects changes accordingly. If a member variable is static, then we can use the 'class name. Member variable name'to use it.

Static modification method: the method of static modification is called static method. For static methods, you can use the 'class name. The method name'is accessed. Static methods can only inherit, not Override, because rewriting is used to represent polymorphism, rewriting can only be applied to instance methods, while static methods can be called without generating instances directly with the class name, which will conflict with the rewritten definition and polymorphism, so static methods can not be rewritten, but can only be hidden.

Static methods and non-static methods: non-static member variables cannot be accessed in static methods; static member variables can be accessed in static methods. Static member variables can be accessed in non-static methods: because static methods can be called directly with the class name, non-static member variables allocate memory and initialize variable values only when the object instance is created.

The this keyword cannot be used in static methods: because static methods can be called directly with the class name, this is actually an application corresponding to the instance when the instance is created, so you cannot use this on static methods.

Static decorated code block: static code block. The role of static code blocks is also to do some initialization work. * * first execute the static code block, and then execute the constructor. * * static code blocks are executed when the class is loaded, and the constructor is executed when the object is generated; to call a class to generate the object, you need to load the class on the Java virtual machine (JVM) first, and then load the class to generate the object by JVM.

The static code block of a class is executed only once, when the class is loaded, because each class is loaded only once, so the static code block is executed only once, while the constructor is not, the constructor of the class is called each time an object is generated, so new calls the constructor once. If there are both constructors and static code blocks in the inheritance system, then first execute the static code block of the topmost class, all the way to the static code block of the lowermost class, and then execute the constructor of the topmost class all the way to the constructor of the lowermost class. Note: static code blocks are executed only once.

Static decorating class: this is a bit special. First of all, static can be used to modify classes, but static is not allowed to modify ordinary classes, but can only be used to modify inner classes. Inner classes modified by static can use the new keyword to directly create an instance. There is no need to create external class instances first. The static inner class can be instantiated and referenced by other classes (even if it is a top-level class).

In fact, it is easy to understand. Because static mainly modifies the members of a class, including inner classes, properties, and methods. The purpose of modifying these variables is also simple, which is to imply that this member is the only copy of the class, and even if the class is constantly instantiated, all objects of this class will share these static members. That makes it easy. Because it is shared and unique, there is no need to call the member through this class after instantiating the class, which is obviously a bit troublesome, so it is simple to call the static member directly through the class name, which is more direct. However, after this setting, there is a restriction that the non-static property cannot be accessed in the static method, because the non-static property may not have allocated memory to him at this time, and the class has not yet been instantiated.

So, in general, the static keyword means that the entity to which it is applied is available outside of any particular instance of the class that declares the entity.

You can call the static method from outside the class without first instantiating the class. Such a reference always includes the class name as a qualifier for method calls.

10) strictfp is strict and accurate

Strictfp means FP-strict, which means precise floating point. When the Java virtual machine performs floating-point operations, if the strictfp keyword is not specified, the compiler and running environment of Java take an approximate behavior to perform floating-point operations on the expressions of floating-point operations, so that the results are often not satisfactory. Once strictfp is used to declare a class, interface, or method, the declared scope of the Java compiler and runtime environment will be executed in full accordance with the floating-point specification IEEE-754. So if you want to make floating-point operations more accurate and not because the results performed by different hardware platforms are inconsistent, use the keyword strictfp.

A class, interface, and method can be declared as strictfp, but methods and constructors in the interface are not allowed to declare the strictfp keyword.

11) synchronized threads, synchronization

The synchronized keyword can be applied to methods or statement blocks and provides protection for critical code segments that should be executed by only one thread at a time.

The synchronized keyword prevents key snippets of code from being executed by multiple threads at a time.

If applied to a static method, the entire class is locked when the method is executed by one thread at a time.

If applied to an instance method, the instance is locked when the method is accessed by one thread at a time.

If applied to an object or array, the object or array is locked when the associated block of code is executed by one thread at a time.

The general uses are:

The synchronized method controls access to class member variables: each class instance corresponds to a lock

Each synchronized method must acquire a lock of the class instance that calls the method before it can be executed, otherwise the thread it belongs to blocks, and once the method is executed, the lock is monopolized and the lock is not released until it is returned from the method, and then the blocked thread can acquire the lock and re-enter the executable state. This mechanism ensures that for each class instance, at most one of its member functions declared as synchronized is executable (because at most one can obtain the corresponding lock for the class instance), thus effectively avoiding access conflicts of class member variables (as long as all possible methods to access class member variables are declared as synchronized).

In Java, not only class instances, but also each class corresponds to a lock, so we can also declare the static member function of the class as synchronized to control its access to the static member variables of the class.

The drawback of the synchronized method: declaring a large method as synchronized will greatly affect efficiency. Typically, if you declare the thread class method run () as synchronized, because it has been running throughout the thread's lifetime, it will cause its calls to any synchronized methods of this class to never succeed. Of course, we can solve this problem by putting the code that accesses the class member variables into a special method, declaring it as synchronized, and calling it in the main method, but Java provides us with a better solution, which is the synchronized block.

Synchronized block.

When two concurrent threads access the synchronized (this) synchronous code block in the same object object, only one thread can be executed at a time. Another thread must wait for the current thread to finish executing the code block before it can be executed.

However, when one thread accesses a synchronized (this) synchronization block of object, another thread can still access a non-synchronized (this) synchronization block in that object.

Crucially, when one thread accesses one of object's synchronized (this) synchronous code blocks, other threads' access to all other synchronized (this) synchronous code blocks in object will be blocked. It is also applicable to other synchronous code blocks. That is, when a thread accesses a synchronized (this) synchronization block of object, it acquires the object lock of that object. As a result, access by other threads to all parts of the synchronous code of the object object is temporarily blocked.

The key point here is that there is only one object lock for this object, and each lock corresponds to a thread.

12) transient is short

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 that contains it has been serialized.

When an object is serialized, the value of existing variables is not included in the serialized representation, while non-serialized 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, and we don't want to use the serialization mechanism to save it. To turn off serialization on a domain of a particular object, you can prefix the keyword transient to that domain.

Transient is the keyword of the Java language to indicate that a domain is not part of the serialization of the object. When an object is serialized, the value of existing variables is not included in the serialized representation, while non-serialized variables are included.

13) volatile is easy to lose

The volatile keyword is used to represent member variables that can be modified asynchronously by multiple threads.

Note: the volatile keyword is not implemented in many Java virtual machines. The purpose of volatile is to ensure that all threads see the same value of the specified variable.

Each time a Volatile-decorated member variable is accessed by a thread, it forces the value of the member variable to be reread from main memory. Also, when a member variable changes, the thread is forced to write back the change value to main memory. So that at any time, two different threads always see the same value of a member variable.

The Java language specification states that:

For optimal speed, allow threads to keep private copies of shared member variables and compare them to the original values of shared member variables only when the thread enters or leaves the synchronous code block.

In this way, when multiple threads interact with an object at the same time, it is necessary to pay attention to the changes of shared member variables in time.

The volatile keyword is to prompt VM that you cannot keep a private copy of this member variable, but should interact directly with the shared member variable.

Usage suggestion: use volatile on member variables accessed by two or more threads. Do not need to be used when the variable to be accessed is already in the synchronized code block or is constant.

Because the use of volatile blocks the necessary code optimizations in VM, it is inefficient, so be sure to use this keyword only when necessary.

The volatile variable in the Java language can be thought of as a "lighter synchronized"; the volatile variable requires less coding and less runtime overhead than the synchronized block, but what it can do is only part of the synchronized.

3. Program control statement

1) break pops out, interrupts

The break keyword is used to exit the for, while, or do loop ahead of time, or to end a case block in a switch statement.

Break always exits the deepest while, for, do, or switch statements.

2) continue continues

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.

3) return returns

The return keyword causes the method to return to the method that called it, passing a value that matches the return type of the returned method. If the method has a return type that is not void, the return statement must have parameters of the same or compatible type. Parentheses on both sides of the return value are optional.

4) do running

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

The do loop body is executed at least once. A conditional expression must be followed by a semicolon.

5) while cycle

The while keyword is used to specify a loop that repeats as long as the condition is true.

6) if if

The if keyword indicates that the block of code is executed conditionally. The condition must be evaluated as a Boolean.

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

Expressions that contain boolean operands can only contain boolean operands.

7) else otherwise

The else keyword is always used in conjunction with the if keyword in if-else statements. The else clause is optional and executes if the if condition is false.

8) for cycle

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

When the for statement is in the form of a for (initialize; condition; increment) control flow into the for statement, the initialize statement is executed once. The result of the condition is calculated before each execution of the loop body. If condition is true, the loop body is executed.

After each execution of the loop body, the increment statement is executed before calculating the condition for the next iteration.

9) instanceof instance

The instanceof keyword is used to determine the class to which the object belongs.

10) switch observation

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

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

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

Without the break statement, the execution flow enters all subsequent case and / or default blocks.

11) case returns the results in observation

Case is used to mark each branch in the switch statement.

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

Without the break statement, the execution flow enters all subsequent case and / or default blocks.

12) default default

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 completed.

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

4. Error handling

1) try catches exceptions

The try keyword is used to contain blocks of statements that may throw exceptions.

Each 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 along the call stack to the next closed try block. If no exception is caught in any closed try block, the Java interpreter exits and displays an error message and stack trace information.

2) catch handles exceptions

The catch keyword is used to define exception handling blocks in try-catch or try-catch-finally statements.

The opening and closing tags {and} are part of the syntax of the catch clause, and cannot be omitted even if the clause contains only one statement. Each 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 along the call stack to the next closed try block. If no exception is caught in any closed try block, the Java interpreter exits and displays an error message and stack trace information.

3) throw throws an exception object

The throw keyword is used to throw an exception.

The throw statement takes java.lang.Throwable as a parameter. The Throwable propagates up the call stack until it is captured by the appropriate catch block. Any method that throws a non-RuntimeException exception must also declare the exception it throws using the throws modifier in the method declaration.

4) throws declares that an exception may be thrown

The throws keyword can be applied to a method to indicate that the method throws a specific type of exception.

The throws keyword takes a comma-separated java.lang.Throwables list as an argument.

Any method that throws a non-RuntimeException exception must also declare the exception it throws using the throws modifier in the method declaration. To include a call to a method with a throws clause in a try-catch block, you must provide a caller for the method.

5) finally

In the exception handling mechanism, its function is like a human meal, what must be done, whether there is an exception or no exception, the code to be executed can be put into the finally block. Finally blocks must be used with try blocks and cannot be used alone or directly with catch blocks.

The finally keyword is used to define blocks that are always executed in a try-catch-finally statement.

The finally block usually contains cleanup code to resume normal operation after the partial execution of the try block.

5. Packet correlation

1) introduction of import

The import keyword makes one or all classes in a package visible in the current Java source file. You can reference the imported class without using a fully qualified class name.

When multiple packages contain classes of the same name, many Java programmers use only specific import statements (without "*") to avoid uncertainty.

2) package package

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

The package statement, if present, must be the first non-annotative text in the Java source file. Example: java.lang.Object. If the Java source file does not contain package statements, the classes defined in the file will be in the default package. Note that classes in the default package cannot be referenced from classes in a non-default package.

6. Basic types

1) boolean Boolean type

Boolean is the primitive type of Java. The value of the boolean variable can be true or false.

The boolean variable can only take true or false as its value. Boolean cannot be converted to and from numeric types.

Expressions that contain boolean operands can only contain boolean operands.

The Boolean class is a wrapper object class of the boolean primitive type.

2) byte byte type

Byte is the primitive type of Java. Byte can store integer values within the range of [- 128,127].

The Byte class is a wrapper object class of the byte primitive type. 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 int values, unless the value is followed by an l or L (such as 235L), which means that the value should be interpreted as long.

3) char character type

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

The following char constants are available:

\ B-spaces,\ f-page feeds,\ n-line feeds,\ r-carriage returns,\ t-horizontal tabs,'- single quotes, "- double quotes,\-backslashes,\ xxx-Latin-1 characters encoded by xxx.\ x and\ xx are legal forms, but can cause confusion.\ uxxxx-Unicode characters in hexadecimal encoded xxxx.

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

The char value has no sign.

4) double double precision

Double is the primitive type of Java. The double variable can store double-precision floating-point values.

Because the floating-point data type is an approximation of the actual value, it is generally not possible to compare floating-point values for equality.

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

5) float floating point

Float is the primitive type of Java. The float variable can store single-precision floating-point values.

The following rules should be followed when using this keyword:

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

Because the floating-point data type is an approximation of the actual value, it is generally not possible to compare floating-point values for equality.

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.

6) int integer

Int is the primitive type of Java. The int variable can store 32-bit integer values.

The Integer class is a wrapper object class of the int primitive type. 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 int values, unless the value is followed by an l or L (such as 235L), which means that the value should be interpreted as long.

7) long long integer

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

The Long class is a wrapper object class of the long primitive type. 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 int values, unless the value is followed by an l or L (such as 235L), which means that the value should be interpreted as long.

8) short short integer

Short is the primitive type of Java. The short variable can store 16-bit signed integers.

The Short class is a wrapper object class of the short primitive type. 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 int values, unless the value is followed by an l or L (such as 235L), which means that the value should be interpreted as long.

9) null null

Null is a reserved word for Java, which means no value.

Assigning a null to a non-original variable is equivalent to releasing the object previously referenced by that variable.

You cannot assign null to primitive type (byte, short, int, long, char, float, double, boolean) variables.

10) true True

The true keyword represents one of the two legal values of the boolean variable.

11) false leave

The false keyword represents one of the two legal values of the boolean variable.

7. Variable reference

1) super parent class, superclass

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

Super, which appears as a stand-alone statement, indicates that the constructor of the superclass is called. Super. () represents a method that calls a superclass. This usage is required only if a method that is overridden in the class is called to specify that the method should be called in the superclass.

2) this this class

The this keyword is used to reference the current instance. When the reference may be ambiguous, you can use the this keyword to refer to the current instance.

3) No return value for void

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.

8. Reserved words

It is important to correctly identify the keywords (keyword) and reserved words (reserved word) of the java language. The keywords of Java have a special meaning to the compiler of java. They are used to represent a data type, or the structure of a program, etc. Reserved words are keywords reserved for java, and although they are not used as keywords now, they may be used as keywords in future upgrades. Identify keywords in the java language and do not confuse them with keywords in other languages, such as those in cUniverse +. Const and goto are reserved words for java. All keywords are lowercase

1) goto Jump

Goto retains keywords, but has no effect. Structured programming does not need goto statements to complete various processes, and the use of goto statements often reduces the readability of the program, so Java does not allow goto jump.

2) const static

Const reserved word, is a type modifier, and objects declared with const cannot be updated. Somewhat similar to final.

Thank you for your reading, the above is the content of "what are Java keywords and reserved words". After the study of this article, I believe you have a deeper understanding of what Java keywords and reserved words are, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.