English phrases that Java programmers need to master

This article shares the English phrases that Java programmers must master for your reference. The specific contents are as follows

Abstract class: abstract classes cannot create objects. They are mainly used to create subclasses. Abstract classes in Java are defined using the abstract modifier.

Abstract data type (ADT): the abstract data type indicates the possible types and allowed operations, but does not provide implementation.

Access specifier: used to define a method or variable and define which classes can access the method or variable. Access identifiers in Java include public, protected and private. The default visibility of methods or variables without access identifier modification is "package".

Activity record (activation record): the activity record contains all the information necessary to realize the subroutine call, including parameter values, local variables in the subroutine and the return address of the computer at the end of the subroutine call. The activity record is stored in the stack, making it possible for multiple subroutine calls to be active at the same time. This is very important for recursion. During recursion, multiple calls to the same subroutine Activate at the same time as required.

Actual parameter: the parameter of the subroutine is called declaration. When the call is executed, the value is passed to the self function through declaration. The actual parameter is also called "parameter".

Address: each location in the computer's memory has an address, indicating the number of the location. The locations in the memory are arranged according to the serial number. In modern computers, each byte in the memory has its own address. The address is used when storing or reading memory information.

Algorithm: a step-by-step process required to complete a task. The process itself has no ambiguity and can ensure that the task can be completed in limited steps.

Alpha color component: the color component is used to describe the transparency or opacity of a color. The higher the alpha component, the more opaque the color is.

API: application programming interface. Interface description for the software package or toolbox. The API contains all classes or subroutines in the toolbox and their instructions.

Applet: unlike applications that can run separately, applet is a java program that runs on a web page in a web browser.

Animation: a group of static pictures are displayed quickly to show dynamic effects. Each static picture is called a frame. In Java, animation is usually driven by timer object. Each time the timer triggers, the next frame of animation will be displayed.

Anti aliasing: when graphics and text are displayed in pixels, you can reduce the "aliasing" effect by adjusting the color of pixels. When anti aliasing drawing, the graphics only cover part of the pixels, and the color of the graphics is mixed with the color before the pixel. The degree of mixing is determined by the number of covered pixels.

Array: a sequential list of elements. In the list, each element can be identified by its own index, that is, sequence number. In Java, all elements in the array must be of the same type, which is also called the base type of the array. Array is a randomly accessible data structure, that is, you can directly access any element in the array at any time.

Array type: the value of this data type is an array. For example, if the name of the type is type, then type [] is the array type and the base type is type.

Assignment statement: a statement in a computer program that can read or calculate values and store them in variables. The form of assignment statement in Java is: variable name = expression.

Asynchronous event: an asynchronous event refers to an event that occurs at an unpredictable time and cannot be controlled by a computer program. User input events such as clicking a mouse or pressing a key are asynchronous.

ASCII code: American Standard Code for information interchange. This encoding uses 7 bits to encode characters. ASCII code only supports 128 characters, and does not support accented characters, non English characters, special symbols or ideograms of non character languages, such as Chinese. Java uses a larger and more complete Unicode encoding to process characters.

Base case: in the recursive algorithm, the base case can be processed directly without further recursion.

Binary number: numeric values are encoded into a set of 0 and 1 sequences. Generally, numbers are based on "10", which is similar to binary numbers, except that they are based on "2".

Binary tree: a binary tree is a linked data structure. It can be an empty tree, or it can be composed of two smaller binary trees (possibly empty trees) and a root node. The root node contains pointers to two subtrees. These two smaller binary trees are called left subtree and right subtree.

Bit: a binary number, which may be 0 or 1.

Black @ r_279_2419 @: refers to a system or component that does not need to care about its internal structure. Black boxes include interfaces and implementations. In a system, black boxes used as components are called modules.

Block: in Java programming, a group of statements surrounded by curly braces ({}) is called a block. (code) a block is used to combine a group of statements into a statement. A block can be empty, indicating that it does not contain any statements, that is, a pair of empty curly braces.

Blocking operation: if an operation needs to wait for certain events to occur, it is called a "blocking" operation, such as reading data from a network connection. The thread executing the blocking operation will remain in the "blocking" state until the event occurs. When it is in the blocking state, the thread cannot execute any instructions. Other threads in the program can continue to execute.

Blocking queue: when the blocking queue is empty, the out of queue operation will cause blocking until new members join the queue. If the blocking queue has a size limit, the in queue operation will also cause blocking when the queue is full.

Bottom up design: bottom up design is a software design method. Start designing from the basic components of the system, and then combine them into more complex components, and so on.

Bufferedimage class: bufferedimage class shows "off screen canvas", that is, pictures are stored in computer memory and can be drawn off screen.

Branch: a branch is a control structure. The computer selects from two or more different execution paths through branches. Java has two kinds of branch statements: if statement and switch statement.

Byte: a byte is an 8-bit memory unit. A byte can hold 8-bit binary numbers.

Bytecode: "Java bytecode" is a common name for the machine language of the Java virtual machine. Java programs are compiled into Java bytecode, which is executed by the JVM.

Charset: a charset is a specific form of encoding character data into binary. For example, UTF-8 and iso-8859-1.

Checked exception: in Java, the checked exception must be handled. It can be caught by the try catch statement or thrown by the throw statement on the method. If the checked exception is not handled in these two ways, a syntax error will be reported.

Class: a class is the basic programming unit of Java. A class is a collection of static methods, non static methods and variables. Static members are part of the class itself. Non static or "instance" members are the blueprint for creating objects, and the objects created thereby "belong to" this class.

Class variable and class methods: aliases for "static variable" and "static method". They are part of a class and independent of objects.

Client / Server: a network communication mode in which the "server" waits for a known address on the network and waits for the "client" to initiate a connection request. This is the basic communication model of TCP / IP protocol.

Command line interface: a method of computer interaction. The user enters commands into the computer, and the computer responds to each command.

Comments: in a computer program, comments are text that is ignored by the computer. The purpose of comments is to facilitate people to read and understand the program.

Compiler: a compiler is a computer program that translates a program written in a computer language (usually a high-level language) into a machine language program.

Component: a component is a generic term for GUI visual elements, including windows, buttons or menus. In Java, a component is represented as an object created by a subclass of java.awt.component.

Constructor: a special subroutine of a class, which is mainly used to create the object of the class. Constructors are generally called with the new operator and are usually not regarded as "methods".

Container: a component such as JPanel. The container can contain other GUI components. You can add components to the container by calling the add () method of the container.

Contract of a method: the semantic component of a method interface. It specifies the method and the responsibilities of its caller, how to call the method, and the tasks that will be performed when the method is called correctly. The method contract should be fully described in the Javadoc annotation of the method.

Control structure: similar to if statement and while loop, it can affect the program control flow (i.e. the execution order of instructions in the program).

CPU: central processing unit. CPU is the part of a computer that actually performs calculations and runs programs.

Data structure: an organized collection of data. It is treated as a unit in a program.

Deadlock: a situation in which multiple threads wait indefinitely. The cause of deadlock is that each thread is waiting for resources locked by other threads.

Default method: a method in the Java 8 interface that provides its own implementation. All interfaces that implement the default method can use the default implementation, but cannot override the default method. The default method is marked by the default reserved word. Java 7 does not support the default method.

Default package: the default package does not have a package name. Classes not declared in a package with a name belong to the default package.

Define assignment: in a program, a variable must be assigned before use. Local variables can only be used legally after assignment. In order to meet this requirement, the compiler must check the assignment of each path of the variable from declaration to use.

Deprecated: indicates that it has been deprecated, but it is still retained for compatibility. Deprecated Java classes or methods are still part of the Java language, but are not recommended for use in new code. Deprecated content will be removed in future Java versions.

Dialog @ r_279_2419 @: dialog is a new form created by relying on other forms. Pop up dialog is usually used to obtain user information or display messages. In swing API, dialog is represented as an object created by jdialog.

Distributed computing: a kind of parallel processing in multiple computers connected by a network.

Dummy parameter: the identifier used to replace the actual input parameter when calling the subroutine. The dummy parameter is also called "formal parameter" (sometimes the argument is used to represent the argument, and the dummy parameter is also called "parameter").

Enum: enumeration type. The definition of an enumeration type lists all possible values of that type. In Java, an enumeration type is a class, and all possible values are objects.

Event: in GUI programming, an event refers to an operation that occurs outside the program control, such as clicking the mouse. The program must respond to the event.

Exception: an error or exception outside the program control process. In Java, an exception is represented as a throwable object, which can be caught and handled by the try.. catch statement.

Fetch and execute cycle: also known as instruction cycle. It refers to the process in which the CPU executes machine language programs. The CPU will fetch (i.e. read) instructions from memory, execute (run) instructions, and then recycle and repeat the process.

Flag: a Boolean value. When set to true, it indicates that certain conditions have been met or something has happened. A bit in a binary number can be used as a flag.

Formal parameter: another term for "virtual parameter".

Frame: a picture that constitutes an animation. It is also another way of saying activity recording.

Function: a subroutine with a return value.

Garbage collection: the process of automatically reclaiming memory. The reclaimed memory is occupied by objects but will no longer be accessed.

Generic programming: the code written is not limited to a single data type, but can adapt to multiple data types. Java collection framework and other classes using similar technologies are examples of generic programming.

Getter method: an instance method in a class, which is used to read a property value of the class. Typically, attributes represent the values of some instance variables. By convention, the getter method is named getxyz (), where XYZ is the name of the property.

Global variable: alias of member variable. It emphasizes that member variables in a class can exist outside class methods.

Graphics context: it is used to draw the data and methods necessary for some specific places. The graphics context in Java is an object belonging to the graphics class.

GUI: graphical user interface is a modern way of interacting with computer. The computer displays interface components such as buttons and menus on the display through the GUI, and users can interact with them by clicking with the mouse.

Hash table: an optimized data structure that can efficiently search, insert and delete objects. The hash table contains an array of addresses of objects. The addresses stored by objects are determined by their own "hash code". The integer values of addresses can be efficiently calculated from the contents of objects.

Heap: the area of computer memory where objects are stored.

High level language: a computer language like Java is convenient for people to read, but it needs to be translated into machine language before execution.

HSB: a color system. The color is represented by three values (in Java, the actual value is between 0.0 and 1.0). They represent hue, saturation and brightness respectively.

IDE: integrated development environment. The programming environment with graphical user interface integrates various tools for creating, editing and executing programs.

Identifier: a set of identifiers that can be used as names in a program. Identifiers can be used as variable names, method names, and class names.

Index number: the position number of the element in the array.

Implementation: the internal implementation of a black box, such as the implementation code of a subroutine.

Immutable object: immutable objects cannot be changed after construction, because all variables in the instance are marked final.

Infinite loop: the loop will never end because its loop condition is always determined to be true.

Inheritance: one class can inherit from another. The inheritor inherits data and behavior from the parent class.

Instance of a class: an object belonging to a class (or a subclass of this type). When a class is used as an object template, the object created by the constructor in the class belongs to this class.

Instance method: a non static method in a class. All instances of the class have this method.

Instance variable: a non static variable in a class. All instances of this class contain this variable.

Interface: a general term for how to use a black box like a subroutine. An interface does not provide any information about what happens inside it. "Interface" is also a reserved word in Java. In this sense, an interface is a type that defines one or more abstract methods. The object implementing the interface must provide the definition of these methods.

Interpreter: a computer program that executes a program written in a programming language by reading instructions from the program one by one and then executing them one by one (translating the instructions into an equivalent machine language).

I / O: input / output. Communication between computer programs and other parts, such as displaying data to users, obtaining information from users, reading and writing files, sending and obtaining data through the network.

Iterator: an object associated with a collection such as list or set. It can be used to traverse the collection. The iterator accesses each element in the collection in turn.

Java collection framework (JCF): a set of standard classes that implement generic data structures, including ArrayList, TreeSet, etc.

JavaFX: new application GUI toolset. Recommended in Java 8. JavaFX is beyond the scope of this book.

JDK: Java development toolset. Basic software that supports compiling and running Java programs. The JDK contains the command-line programming environment and JRE. To compile java source code or execute precompiled programs, you need to use JDK.

JRE (Java runtime environment): Java runtime environment. It supports running compiled standard Java programs. JRE includes a Java virtual machine and all standard Java classes.

Just in time compiler: a combination of interpreter and compiler, which can compile a part of the program while interpreting it. The next execution of the part of the program is faster than the first run. This can greatly improve the execution speed. Modern JVMs use real-time compilers.

JVM: Java virtual machine. A virtual machine that executes Java bytecode as a machine language. Also called a computer program that parses bytecode. To run a java program on a computer, you need to use a JVM.

Layout manager: the object responsible for the layout of components in the container. Some operations include setting the size and location. Different types of layout managers implement different layout strategies.

Linked data structure: a set of object data linked by pointers. These pointers are stored in the instance variables of the object. Linked data structures include linked lists and binary trees.

Linked list: a linked data structure in which pointers are connected in series between nodes to form a linear linked list.

Listener: in GUI programming, you can register trigger notifications of specific events with objects. Therefore, it can be said that objects are "listening" to these events.

Literal: a sequence of characters typed in a program that represents a constant value. For example, 'a' is a constant character when a appears in a java program.

Location in memory: computer memory consists of a series of locations. These locations are numbered sequentially. The number identifying a specific location is called the address of the location.

Local variable: a variable declared inside a method, which can only be used inside the method. The validity of a variable declared in a code block starts from the declaration to the end of the code block.

Loop: a control structure that repeatedly executes a set of instructions. Java provides three loops: for loop, while loop and do loop.

Loop control variable: a variable in the for loop. The value of the loop variable is modified every time the for loop is executed. Check the variable to determine whether to end the loop.

Machine language: a programming language composed of instructions that can be directly executed by a computer. The instructions in the machine language are encoded into binary numbers. Each type of computer has its own machine language. Programs written in other languages must be translated into the machine language of the calculation before they can be executed on it.

Main memory: programs and data can be stored in the main memory of the computer, and the main memory can be accessed directly by the CPU. Although other forms of memory, such as disk drive, can also store information, only the main memory can be accessed directly by the CPU. Programs and data in disk partitions can be accessed by the CPU only if they are copied to the memory.

Map: a mapping array. This data structure associates an object in a collection with all objects in a set. In Java, map is represented by the generic interface map < T, s >.

Member variable: a variable defined in a class but not belonging to any method. Member variables are different from local variables, which are defined in a method.

Memory: the memory in a computer used to store programs and data.

Method: another term for a subroutine, used in object-oriented programming. A method refers to a subroutine contained in a class or object.

Module: a component in a large system that interacts with other parts of the system in a simple, clearly defined and direct manner.

Multitasking: perform multiple programming tasks at one time. Either switch quickly between multiple tasks, or perform multiple tasks one by one at the same time.

Multiprocessing: multiple processors are used for multitasking. In this way, multiple tasks can be executed one by one at the same time.

Mutual exclusion: prevents two threads from accessing the same resources at the same time. In Java, this method is applied to multiple threads accessing resources in synchronous methods or synchronous statements at the same time. Mutual exclusion can prevent race conditions, but may cause deadlocks.

MVC pattern: model view controller pattern. A strategy used to divide responsibilities in GUI components. A model represents component data, a view refers to the display of the model on the screen, and the controller is responsible for responding to model change events. In MVC pattern, these responsibilities are handled by different objects.

Non numeric (Nan): not a numeric value. Double.nan represents a special double value, which represents an undefined or illegal value.

Node: the common name of an object in a linked data structure.

Null: a special pointer value indicating "no point to anything".

Numerical analysis: use approximation methods to study the fields of algorithms, such as real numbers and errors obtained from approximation calculations.

Off by one error: a common error in which an extra element is added or subtracted during processing. It is usually caused by technical error or premature stop or over execution of loops for other reasons.

Object: an entity with data (variables) and behavior (Methods) in a computer program. An object in Java must use a class as a creation template. The class to which the object belongs determines the classes and methods contained in the object.

Object type: the value of this type is an object rather than the underlying type. Both classes and interfaces are object types.

OOP (object-oriented programming): object-oriented programming. A method of computer programming and implementation. OOP uses classes and objects to create and represent entities and interactions between entities.

Operating system: the basic software that runs all the time in the computer. Computers without an operating system cannot work. The operating system consists of Linux, Mac OS and windows vista.

Operator: operators like "+", "< =" or "+ +" can evaluate one or more values in expressions.

Overloading of operators: the same operator can be used on different types of data. For example, the "+" operation can be applied to both numeric and character types.

(method name) overloading of method names: several methods with the same name are defined in the same class. The difference is that the signatures of each method are different.

Overriding: redefine in a subclass. In a subclass, redefine the method inherited from the parent class. The newly defined method is to override the original method.

Package: in Java, famous collections of related classes and sub packages are called packages, such as java.awt and javax.swing.

Parallel processing: multiple tasks can be executed at the same time, which can be executed by multiple processors or by one processor.

Parameter: when calling a subroutine, the parameter is used to provide information to the subroutine. Before executing the subroutine code, the "actual parameter" in the subroutine call statement will be assigned to the "virtual parameter" defined by the subroutine.

Parameterized type: similar to ArrayList < string >, it contains one or more types of parameters (the parameter type here is string).

Parsing: the process of determining the syntax structure of a string in rehearsal. Parsing a string is used to determine whether the syntax of the language is followed in the string; if so, it will determine how the string is created according to the syntax.

Partially full array: an array is used to store a different number of elements. A partially complete array is represented as an ordinary array with a counter that tracks the number of elements.

Pixel: refers to the "image element" in a screen or picture. An image consists of rows and columns of pixels. The color of each pixel can be set separately.

Polymorphism: polymorphism means that the meaning of calling an instance method depends on the actual type of the object when the method is called. That is, if the type of the variable is VaR, the statement calling the method, such as var.action (), depends on the object type pointed to by VAR during execution, not the type of VaR variable.

Pointer: represents the value of an address in the computer memory, so it can be regarded as "pointing" to the location with the address. In Java, variables do not have objects; variables only point to the location where the object is stored. Pointers are also called "references".

Pragmatics: rules of thumb that describe how to write a good program. For example, style rules and Program Organization guidelines are all part of programming pragmatics.

Priority: the priority of an operator refers to the order in which multiple operators operate in an expression without parentheses.

Precondition: during the execution of a program, the precondition must be determined to be true in order for the program to run correctly. The precondition of a subroutine refers to the precondition that must be met in order for the subroutine to run correctly. The precondition of a subroutine is usually a restriction on the argument value of the incoming subroutine.

Priority queue: a data structure that represents the combination of elements, in which each element has its own "priority". Priority queues have add and remove operations. Elements can be added in any order, but the element with the lowest priority is always removed first. (some versions of priority queues remove the element with the highest priority first)

Postcondition: at a node of the executing program, the condition evaluates to true. The postcondition of a subroutine must be true after the execution of the subroutine. The postcondition of a function is usually expressed as the return value of the function.

Primitive type: the eight built-in basic data types of Java include double, float, long, int, short, byte, Boolean and char. Variables of primitive type store real values rather than pointers to numerical values.

Priority of a thread: the integer value associated with the thread, which can affect the execution order of the thread. Higher priority threads execute earlier than lower priority threads.

Producer / consumer Producer / Consumer: a classic mode in parallel programming. Products produced by one or more producers are used by one or more consumers. Producers and consumers are designed to execute in parallel. The difficulty here is how to safely and efficiently distribute products from producers to consumers. In Java, the producer / consumer mode is realized by blocking queues.

Program: a set of instructions written in a suitable programming language and executed by a computer. When used as a verb, it indicates the action of creating the instruction.

Programming language: a language used to program computers. The complexity of programming language ranges from machine language to high-level language such as Java.

Protocol: a set of specifications constituting legal communication in a specified context. The protocol specifies the legal message, transmission time, expected recovery type, etc.

Pseudo code: informal algorithm specification. Pseudo code is closer to English than actual programming language. Moreover, it is usually not necessary to write every detail of the process explicitly.

Queue: a data structure consisting of a set of elements. Data can only be added at one end of the list and removed at the other end of the list.

Race condition: a possible error source in parallel programming. An error is caused because a thread changes the program state (such as variable value) that the second program depends on.

RAM (random access memory): random access memory. Synonymous with the main memory of a computer. However, from a technical point of view, RAM means that the memory address can be accessed at any time. Ram also means that data can be read and written at the same time.

Recursion: defines itself in its own form. In particular, recursive subroutines can call themselves directly or indirectly through a series of other subroutines. Recursive algorithms work by splitting a complex problem into smaller subproblems. Subproblems can either be solved directly or "recursively" using the same algorithm.

RGB: a color system. Color is defined by three values (in Java, the range of values is 0 to 255). They represent red, green and blue in the color.

Reference: another name for "pointer".

Return type of a function: the type of the return value of a function.

Reserved word: a string sequence that looks like an identifier. However, it cannot be used as an identifier because it has special meaning in the programming language. For example, class and public are reserved words in Java.

Resources: pictures, sounds, text or data files in programs are resources. Java resource files are stored in the same path as compiled class files.

Robust program: a robust program is not only correct, but also can reasonably handle errors, such as the file does not exist or the network connection cannot be established.

Set: a set of objects without duplication. In Java, a set is represented by the generic interface set < T >.

Scope: represents the valid scope of the identifier declared in the program.

Semantics: semantics means that the semantic rules of a language determine the meaning of string symbols (such as sentences or statements) in the language.

Sentinel value: a special mark indicating the end of the data sequence, indicating that the data has ended.

Setter method: the instance method in the class, which is used to set some property values in the class. Typically, these properties are just instance variable values. By convention, the setter method is named setxyz (), where XYZ is the name of the property.

Signature of a method: the method name, the number of formal parameters in the method definition and the type of each formal parameter. The compiler uses the method signature to identify which method is called by the specified subroutine call statement.

Socket: an abstract representation of one end of a connection between two computers on a network. A socket represents a logical connection between computer programs, not a physical connection between computers.

Stack: a list data structure composed of a group of elements, which can only be at the end of the list, also known as the "top of the stack". Adding elements to the stack is called "push into the stack", and removing elements is called "pop out of the stack". Stack also refers to the activity record used to realize subroutine calls.

Standard input: the standard source from which the program reads input data, represented by the system.in object. Usually, the standard input comes from the text typed by the user, but the standard output can also be redirected to other sources, such as files.

Standard output: the standard target that the program writes the output text to, which is represented by the system.out object. Usually, the standard output will be displayed to the user, but it can also be "redirected" to other targets, such as files. In addition, the system.err object is used to output error information.

State machine: a computer model. An abstract "machine" can be in any state in a finite state set. The machine will determine its behavior according to its own state and switch states according to inputs or events. The basic logic of GUI programs can be expressed as state machines.

Step wise refinement: an algorithm development technique that begins by outlining algorithm steps, usually represented by pseudo code, and then gradually filling in details.

Stream: abstract representation of input data source or output data target. Java provides four basic classes for character and binary data input and output streams. These classes form the basis of Java I / O API.

Source code: text written in a high-level programming language. Before computer execution, it must be translated into machine language, such as Java bytecode.

Subclass: a class that directly or indirectly inherits other classes, thereby inheriting its data and behavior. The former class is called a subclass of the second class.

Subroutine: a series of program instructions. A subroutine can be "called" by its name. In object-oriented programming, a subroutine is also called a method.

Subroutine call subroutine (call statement): a statement calling subroutines in a program. When a subroutine calls a statement, the computer executes the internal code of the subroutine.

Super: a special variable that is automatically defined in the instance method. Super refers to the object containing the method, which belongs to the parent class of the class where the method is located. Super can access hidden member variables in the parent class, which have the same name as member variables in the child class.

Syntax: defines which string symbols in the language conform to the syntax rules of the language.

TCP / IP: the protocol used for network communication on the Internet.

This: a special variable, which is automatically defined in the instance method and belongs to the class of the method.

Thread: an abstract representation of a series of statements executed one by one. A computer can execute multiple threads in parallel.

Thread pool: a set of "worker threads" that can be used to execute tasks. When tasks are ready, they can be assigned to threads in the pool. Thread pools usually use blocking queues to store tasks.

Top-down design: a software design method. First, the problem is taken as a whole, then divided into smaller problems, and then gradually refined until the sub problems can be solved directly.

Type: a specific type of numeric value. For example, int type specifies that the integer value can be expressed as a 32-bit binary number. In Java, the type can be a basic type, class name or interface name. The type name can be used to define the type of variable, virtual parameters in subroutine and the return type of subroutine.

Type cast: cast a value of one type to another. For example, in (int) (6 * math. Random()), (int) is a type cast operation that converts the floating-point value of (6 * math. Random()) to an integer, discarding the decimal part of the real number.

Unicode: a way to encode characters into binary numbers. The Unicode character set contains characters from many languages, not just English. The Unicode character set is used internally in Java.

URL: global resource locator. The address of a resource on the Internet, such as a web page.

Variable: a memory location with a name (or a series of locations) to store data. Create a variable in the program and assign the name to the variable through the variable declaration statement. Depending on the usage, this name can refer to the memory location in the program or store data in the memory address. In Java, a variable has a type, which can indicate the type of data held by the variable.

Wrapper class: classes such as double and integer "wrap" the value of a basic type in the object, which belongs to the wrapper class. In this way, the basic type value can also be used where the object needs to be used, such as Java collection framework.

XML (Extensible Markup Language): extensible markup language. It is a very common, standard syntax and well supported language. It is used to create text-based data representation.

The above is the whole content of this article. I hope it will be helpful to your study, and I hope you can support programming tips.