This article shares the English phrases that Java programmers must master for your reference. The specific content is as follows
Abstract class: Abstract class cannot create objects, and is mainly used to create subclasses. Abstract classes in Java are defined using abstract modifiers.
Abstract data type ADT: Abstract data type indicates possible types and operations allowed, but no implementation is provided.
Access identifier: used for method or variable definitions, which defines which classes can access the method or variable. Access identifiers in Java are public, protected and private. The default visibility of the variable without accessing identifier modification is "package".
Activity record: Activity record contains all the information necessary to implement subroutine calls, including parameter values, local variables in the subroutine, and the return address of the computer when the subroutine calls end. Activity records are stored in the stack, making it possible for multiple subroutine calls to be active simultaneously. This is very important for recursion, where multiple calls to the same subroutine are required to be activated simultaneously.
Actual parameter: The parameters of a subroutine are called declarations. When the call is executed, the value is passed to the self-function by declaration. Actual parameters are also called "parameters".
Address: Each location in the computer memory has an address, indicating the number of that location. Locations in memory are arranged by sequence number. In modern computers, each byte in memory has its own address. Use the address when storing or reading memory information.
Algorithm: A step-by-step process required to complete a task. The process itself is not ambiguity and can ensure that the task is completed within a limited number of steps.
Alpha color component: The color composition is used to describe the transparency or opacity of the color. The higher the alpha composition, the more opaque the color.
API: Application programming interface. Interface instructions for packages or "toolboxes". The API contains all classes or subroutines in the toolbox and their instructions for use.
Applet: Unlike applications that can be run separately, Applet is a Java program that runs on web pages in a web browser.
Animation: A set of static images quickly displays dynamic effects. Each static image is called a frame. In Java, animations are usually driven by Timer objects. Each time the timer fires, the next frame of the animation is displayed.
Antialiasing: When graphics and text are displayed in pixels, the "jagged" effect can be mitigated by adjusting the color of the pixels. When drawing anti-aliasing, the graphics cover only part of the pixel, and the color of the graphics is mixed with the previous color of the pixel. The degree of mixing is determined by the amount of pixels covered.
Array: A list of elements arranged in order. In the list, each element can be identified by its own index, that is, the sequence number. In Java, all elements in an array must have the same type, and this type is also called the base type of the array. An array is a randomly accessible data structure, which means that 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 numeric values and store them in variables. The assignment statement in Java is: variable name = expression.
Asynchronous event: An asynchronous event refers to an event with an unexpected time that the computer program cannot control. User input events like clicking the mouse and pressing the key are asynchronous.
ASCII code: American information exchange standard code. This encoding uses 7 bits to encode characters. The ASCII code only supports 128 characters and does not support accented characters, non-English characters, special symbols or ideograms in non-characterized languages, such as Chinese. Java uses larger and more complete Unicode encoding to process characters.
Base case: In recursive algorithm, baseline conditions can be directly processed without continuing recursion.
binary number: The value is encoded into a set of 0 and 1 sequences. Generally, numbers are based on "10" and binary numbers are similar to them, except that they are based on "2".
Binary tree: A binary tree is a chain data structure. It can be an empty tree, or consists of two smaller binary trees (possibly an empty tree) with the root node. The root node contains a pointer to two subtrees. These two smaller binary trees are called the left subtree and the right subtree.
bit: a binary number, which may be 0 or 1.
Black box: refers to the system or component that does not need to care about internal structure when used. Black box includes interfaces and implementations. In the system, the black box used as a component is called a module.
Block: In Java programming, a set of statements surrounded by curly braces ({}) are called blocks. The (code) block is used to combine a group of statements into a statement. A block can be empty, indicating that it does not contain any statement, that is, a pair of empty curly braces.
Blocking operation: An operation is called a "blocking" operation if it needs to wait for certain events to occur, such as reading data from a network connection. The thread that performs the blocking operation will remain in a "blocking" state until the event occurs. When in a 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 dequeue operation will cause blockage until a new member of the queue joins. If there is a size limit for the blocking queue, the enqueue operation will also cause blockage 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 combining them into more complex components, and so on.
BufferedImage class: The BufferedImage class displays "off-screen canvas", that is, the image is stored in computer memory and can be drawn off-screen.
Branch: A branch is a control structure in which a computer selects two or more different execution paths through branches. Java has two branch statements: if statement and switch statement.
Byte: Byte is a memory unit composed of 8 bits. One byte can hold 8 bit binary numbers.
Bytecode: "Java bytecode" is a common name for the Java virtual machine language. Java programs are compiled into Java bytecode, which is executed by the JVM.
Charset: A character set is a specific encoding form that encodes character data into binary. For example, UTF-8 and ISO-8859-1.
Checked exception: The checked exception must be processed in Java. It can be caught by the try catch statement, or throw the exception using the throw statement on the method. If the detected exception is not handled in both ways, a syntax error will be reported.
Class: 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, and non-static or "instance" members are the blueprint for creating objects, and the objects created from them "belong to" to that class.
Class variables and class methods: alias for "static variables" and "static methods". They are part of a class and have nothing to do with the object.
Client/server: A network communication mode. Among them, the "server" is waiting for a known address on the network and waits for the "client" to initiate a connection request to it. This is the basic communication model of the TCP/IP protocol.
Command-line interface: a computer interaction method. The user enters commands to the computer, and the computer responds to each command.
Comment: In a computer program, comments are text that is ignored by the computer. The purpose of comments is to facilitate people to read and help understand the program.
Compiler: A compiler is a computer program that translates programs written in a certain computer language (usually a high-level language) into machine language programs.
Component: Component is a general term for GUI visual elements, including windows, buttons, or menus. In Java, components appear as objects created by the java.awt.Component subclass.
Constructor: A special subroutine of a class, mainly used to create class objects. Constructors are generally called using the new operator and are usually not regarded as "method".
Container: Components like JPanel, containers can contain other GUI components. Calling the add() method of the container can add components to it.
Contract of a method: The semantic component of a method interface. It specifies the method and its caller's responsibilities, how to call the method, and the tasks that will be executed when the method is called correctly. The method contract should be fully described in the Javadoc comments of the method.
Control structure: A program structure similar to if statements and while loops can affect program control flow (that is, the order of instruction execution in the program).
CPU: Central processor. The CPU is the part of the computer that actually executes calculations and runs programs.
Data structure: an organized data collection. It is processed as a unit in the program.
Deadlock: A situation where multiple threads wait infinitely. The reasons for deadlocks are, such as each thread is waiting for resources locked by other threads.
Default method: A method in the Java 8 interface, which provides its own implementation. All interfaces that implement default methods can use default implementations, but cannot override default methods. Keep the default method by default. Java 7 does not support the default method.
Default package: The default package has no package name. Classes that are not declared in packages with names belong to the default package.
Definite assignment: In a program, variables must be ensured to be assigned before use. Local variables can only be used legally after assignment. To achieve this requirement, the compiler must perform assignment checks on every path from the start of the declaration to the use of the variable.
Deprecated: means it has been abandoned, 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. In future Java versions, deprecated content will be removed.
Dialog box: A dialog box is a new form created by relying on other forms. A pop-up dialog box is usually used to obtain user information or display messages. In the Swing API, the dialog box is represented as an object created by JDialog.
distributed computing: a parallel processing performed in multiple computers connected by a network.
Dummy parameter: The identifier used to replace the actual passed parameters when calling a subroutine. Virtual parameters are also called "formal parameters" (sometimes "variable argument" is used to represent real parameters, and at this time, virtual parameters are also called "parameters").
enum: Enum type. The enumeration type definition lists all possible values of the type. In Java, an enum type is a class, and all possible values are objects.
Event: In GUI programming, events refer to operations that occur outside program control, such as clicking the mouse. The program must respond to events that occur.
Exception: An error or exception condition outside the program control process. In Java, exceptions are represented as Throwable objects and can be caught and processed by try..catch statements.
fetch-and-execute cycle: also known as instruction cycle. Refers to the process by which the CPU executes a machine language program. The CPU will fetch (i.e. read) instructions from memory, execute (run) instructions, and then repeat the process again.
Flag: A boolean value. Set to true means that something is 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 certain picture that forms an animation, which is another way of saying activity records.
Function: a subroutine with a return value.
Garbage collection: The process of automatically collecting memory. The recycled memory is occupied by the object but is no longer accessible to it.
Generic programming: The code written is not limited to a single data type, but can be adapted to multiple data types. The Java collection framework and other classes that use similar technologies are examples of generic programming.
getter method: an instance method in the class, used to read a property value of a 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: an alias for member variables. Emphasize that member variables in a class can exist outside of a class method.
Graphics context: The data and methods necessary to draw certain specific locations. The graphical context in Java is an object belonging to the Graphics class.
GUI: Graphical user interface is a modern way of interacting with computers. The computer displays interface components like buttons and menus on the display through a GUI, and users can interact with it through a mouse click.
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 address of the object storage is determined by its own "hash code". The address integer value can be calculated efficiently through the content of the object.
Heap: The area in computer memory where objects are stored.
High level language: A computer language similar to Java is convenient for people to read, but it needs to be translated into machine language before execution.
HSB: A color system. Where the color is represented by 3 numerical values (in Java, the actual numerical values are between 0.0 and 1.0). Represents hue, saturation and brightness respectively.
IDE: Integrated development environment. A programming environment with graphical user interface that 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 the black box, such as the implementation code of the subroutine.
Immutable object: The immutable object cannot be changed after the construction of the immutable object is completed, because all variables in the instance are marked final.
Infinite loop: The loop never ends because its loop condition is always judged to be true.
Inheritance: One class can inherit another class. The heirs inherit data and behavior from the parent class.
Instance of a class: refers to an object that belongs to a class (or a subclass of the 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, and all instances of the class contain this variable.
Interface: A common saying about how to use black boxes like subroutines. The interface provides no information on what is happening 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 a definition of these methods.
Interpreter: A computer program that executes a program, and the executed program is written by a certain programming language. By reading instructions one by one from the program and then executing them one by one (translating the instructions into equivalent machine language).
I/O: Input/Output. The communication methods of computer programs with other parts, such as displaying data to users, obtaining information from users, reading and writing files, sending and obtaining data over the network.
Iterator: an object associated with a collection such as list or set. Can be used to traverse the collection. The iterator takes turns accessing each element in the collection.
Java Collection Framework JCF: A set of standard classes that implement generic data structures. Including ArrayList, TreeSet, etc.
JavaFX: New GUI toolset for the application. Recommended in Java 8. JavaFX is not within the scope of this book.
JDK: Java development toolset. Basic software that supports compiling and running Java programs. JDK includes 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. 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 that can be compiled while interpreting a part of a program. The next step is to execute this part of the program faster than the first run. This can greatly improve execution speed. Modern JVMs use instant compilers.
JVM: Java virtual machine. A virtual computer that executes Java bytecode as a machine language. Also used to refer to computer programs that parse bytecode programs. To run Java programs on your computer, you need to use a JVM.
Layout Manager: The object responsible for laying out components in the container. Some operations performed include setting size and position. Different types of layout managers implement different layout strategies.
Linked data structure: a set of object data linked to each other by pointers. These pointers are stored in the object's instance variable. A chained data structure includes a linked list and a binary tree.
Linked list: A chained data structure, where pointers are connected to form a linear linked list.
Listener: In GUI programming, trigger notifications for specific events can be registered with objects. Therefore, it can be said that the object is "listening" to these events.
Literal: A set of characters typed in the program to represent constant values. For example, when A appears in a Java program, 'A' is a constant character.
(Memory) Location (location in memory): Computer memory consists of a series of locations. These locations are numbered in sequence, and the number identifying a particular location is called the address of that location.
Local variable: A variable declared inside a method can only be used inside the method. The validity of declared variables in a code block starts at the declaration and ends at the end of the code block.
Loop: A control structure that repeatedly executes a set of instructions. Java provides 3 types of loops: for loop, while loop and do loop.
Loop control variable: a variable in a loop. The loop variable value will be modified every time the for loop is executed. By checking the variable, whether to end the loop.
Machine language: a programming language composed of instructions that the computer can execute directly. Instructions in 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 directly accessed by the CPU. Other forms of memory, such as disk drives, can also store information, but only the main memory can be directly accessed by the CPU. Programs and data in disk partitions can only be accessed by the CPU if they are copied to memory.
map: A map 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 does not belong to any method. Member variables are different from local variables, which are defined in a method.
Memory: The memory in the computer is used to store programs and data.
Method: Another name for subroutines, used in object-oriented programming. A method refers to a subroutine contained in a class or object.
Module: Components in large systems that interact with other parts of the system in a simple, clear and direct way.
Multitasking: Execute multiple programming tasks at once. Either switch back and forth quickly between multiple tasks or perform multiple tasks one by one at the same time.
Multiprocessing: Multiprocessing uses multiple processors when performing 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 resource at the same time. In Java, this method is applied to multiple threads simultaneously accessing resources in synchronization methods or synchronization statements. Mutual exclusion can prevent race conditions, but can trigger deadlocks.
MVC pattern: Model-view-controller mode. A strategy for division of responsibilities in GUI components. The model represents the data of the component, the view refers to the display of the model on the screen, and the controller is responsible for responding to the model change events. In MVC mode, these responsibilities are handled by different objects.
Non-numeric value (NaN): Not a numeric value. Double.NaN represents a special double value, indicating an undefined or illegal value.
Node: A common name for an object in a chain data structure.
null: A special pointer value that means "no pointing 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, which reduces or adds one more element when processing. Usually it is caused by technical errors or cycles due to premature stopping or excessive execution.
Object: An entity in a computer program with data (variables) and behaviors (methods). Objects in Java must use a certain class as the template to create. The class to which the object belongs determines the classes and methods the object contains.
Object type: The value of this type is an object rather than a base type. 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: basic software that has been running on the computer. Computers without an operating system will not work. The operating system is made of Linux, Mac OS and Windows Vista.
Operator: Operators like "+", "<=" or "++", can calculate one or more values in an expression.
(Operator) Overloading (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 at the same time.
(Method Name) Overloading (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, the method inherited from the parent class is redefined, and the newly defined method is to rewrite the original method.
Package: In Java, a famous collection of related classes and subpackages is called packages, such as java.awt and javax.swing.
Parallel processing: Execute multiple tasks at the same time, either multiple processors, or one processor can re-execute between multiple tasks.
Parameter: When calling a subroutine, the parameters are used to provide information to the subroutine. Before executing the subroutine code, the "real arguments" in the subroutine call statement will be assigned to the "virtual parameters" defined by the subroutine.
Parameterized type: Similar to ArrayList<String>, a type containing one or more types of parameters (the parameter type here is String).
parsing: The process of determining the string syntax structure in the rehearsal. The parsing string is used to determine whether the string follows the syntax of the language; if so, it determines how the string is created based on the syntax.
Partially full array: Arrays are used to store elements of different numbers. Partially complete arrays are represented as a normal array with a counter for tracing elements.
Pixel: refers to the "image element" in the screen or picture. An image consists of rows and columns of pixels. The colors of each pixel can be set separately.
Polymorphism: Polymorphism refers to the meaning of calling an instance method depends on the actual type of the object when calling the method. That is, if the type of the variable is var, the statement that calls the method, such as var.action(), depends on the type of object that var points to at execution time, rather than the type of the var variable.
Pointer: The value of a certain address in the computer memory, so it can be regarded as "pointing" to the location with that address. In Java, variables do not have objects; variables simply point to the location where the object is stored. Pointers are also called "references".
Pragmatics: Rules of thumb for describing how to write a good program. For example, style rules and program organization guides are all part of programming pragmatics.
Precedence: The priority of an operator refers to the order in which multiple operators act in the expression without brackets.
Precondition: During the execution of the program, in order for the program to run correctly, the precondition must be determined to be true. 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 actual parameter values of the incoming subroutine.
Priority queue: A data structure that represents the combination of elements, where each element has its own "priority". The priority queue has add and remove operations. Elements can be added in any order, but the elements with the lowest priority are always removed first when removing. (Some versions of the priority queue will first remove the highest priority element)
Postcondition: On a node where the program is executed, the calculation result of this condition is true. The post-condition of the subroutine must be true after the subroutine is executed. The postcondition of a function is usually expressed as the return value of the function.
Primitive type: The 8 built-in basic data types in Java include double, float, long, int, short, byte, boolean and char. The primitive type variable stores the true value, not a pointer to the numeric value.
Thread priority (priority of a thread): an integer value associated with a thread, which can affect the execution order of threads. Threads with high priority execute in advance than threads with low priority.
Producer/consumer: A classic model in parallel programming in which products produced by one or more producers are used by one or more consumers. Producers and consumers are designed to be executed in parallel. The difficulty here lies in how to safely and efficiently from producers to consumers without matching products. In Java, the producer/consumer pattern is implemented by blocking the queue.
Program: A set of instructions written in some suitable programming language, executed by a computer. When used as a verb, it indicates the action to create the instruction.
Programming language: a language used to program computers. The complexity of programming languages spans a lot from machine language to high-level languages like Java.
Protocol: A set of specifications that constitute legal communication in a specified context. The agreement stipulates legal messages, transmission time, expected recovery type, etc.
Pseudocode: informal algorithm specification. Compared to actual programming languages, pseudocode is closer to English. And, it is often not necessary to write out every detail of the process explicitly.
Queue: a data structure composed of a set of elements. You can only add data at one end of the list and remove data at the other end of the list.
Race condition: Possible source of errors in parallel programming. An error is raised because a thread changes the program state (such as variable value) that the second program depends on.
RAM (Random Access Memory): Random access memory. Synonyms for main memory of computer. However, from a technical point of view, RAM means that memory addresses can be accessed in any time. RAM also means that data can be read and written simultaneously.
Recursion: Define yourself in your own form. In particular, a recursive subroutine can indirectly call itself directly or through a series of other subroutines. The way recursive algorithms work by splitting a complex problem into smaller subproblems. The subproblem can either be solved directly or the same algorithm can be used "recursively".
RGB: A color system. The color is defined by 3 numeric values (in Java, the range of values ranges from 0 to 255). It represents the composition of red, green and blue in the color respectively.
Reference: Another term for "pointer".
Return type of a function: The type of the function returns the value.
Reserved word: A set of string sequences that look very similar to identifiers. However, it cannot be used as an identifier because it has special meaning in programming languages. For example, class and public are reserved words in Java.
Resource: Pictures, sounds, texts, or data files in programs are resources. Java resource files are stored in the same path as compiled class files.
Robust program: Robust programs are not only correct, but also can handle errors reasonably, such as files do not exist or network connection cannot be established.
Set: A set of objects without duplicates. In Java, collections are represented by the generic interface Set<T>.
scope: represents the valid scope of the identifier declared in the program.
Semantics: Semantics refers to the semantic rules of a language that determine the meaning of string symbols (such as sentences or statements) in the language.
Sentinel value: A special mark that indicates the end of the data sequence, indicating that the data has ended.
setter method : an instance method in the class, used to set some attribute values in the class. Usually, these properties are just instance variable values. By convention, the setter method is named setXyz(), where xyz is the name of the property.
Method signature (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 method signature to identify which method is called by the specified subroutine call statement.
Socket: The connection between two computers on the network, an abstract representation of one end. Sockets represent a logical connection between computer programs, not a physical connection between computers.
Stack: A list data structure composed of a group of elements can only be at the end of the list, also known as the "top of the stack". Adding elements to the stack is called "stack push", and removing elements is called "stack pop". The stack also refers to the activity record used to implement subroutine calls.
Standard input: The standard source for the program to read input data, represented by the System.in object. Typically, standard input comes from text typed by the user, but standard output can also be redirected to other sources, such as files.
Standard output: The standard target that the program writes output text to, represented by the System.out object. Typically, standard output will be shown 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 messages.
State machine: a computer model. An abstract "machine" can be in any state in a finite state set. The machine will determine its behavior based on its own state and switch states based on input or event. The basic logic of a GUI program can be manifested as a state machine.
Step-wise refinement: an algorithm development technology. Start listing the outline of the algorithm steps, usually represented in pseudo-code, and then gradually fill in the details.
Stream: An abstract representation of the input data source or output data target. Java provides 4 basic classes for character and binary data input and output streams. These classes form the basis of the Java I/O API.
Source code: Text written in a high-level programming language. Before the computer executes, it must be translated into machine language, such as Java bytecode.
Subclass: A class that directly or indirectly inherits other classes, thus inheriting its data and behavior. The previous class is called the second class subclass.
Subroutine: A series of program instructions. The subroutine can be "called" by the subroutine name. In object-oriented programming, subroutines are also called methods.
Subroutine call statement: a statement in the program that calls a subroutine. When a subroutine call statement is executed, the computer executes the code inside the subroutine.
super: A special variable that is automatically defined in the instance method. super refers to the object containing the method and 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 the member variables in the subclass.
Syntax: Defines which string symbols in the language comply with the syntax rules of the language.
TCP/IP：Internet上用来网络通讯的协议。
this：一个特殊变量，在实例方法中自动定义，归属于方法所在的类。
线程（thread）：对一系列逐条执行语句的抽象表示。计算机可以并行执行多个线程。
线程池（thread pool）：执行任务时可以使用的一组“工作线程”。当任务就绪时，可分配给池中的线程。线程池通常使用阻塞式队列存储任务。
自顶向下设计（top-down design）：一种软件设计方法。开始把问题作为一个整体，然后拆分成更小的问题，再逐步细化，直到子问题可以直接解决。
类型（type）：数值的特定类型。例如，int类型规定了整形值可以表示为32比特二进制数。在Java中，类型可以是基本类型、类名或接口名。类型名可用来定义变量的类型，子程序中的虚拟参数和子程序的返回类型。
类型转换（type cast）：把一种类型的值强制转换为另一种类型。例如，在(int)(6*Math.random()) 中，(int) 是一个类型转换操作，将(6*Math.random()) 的浮点值转换为了整形，丢弃了实数中的小数部分。
Unicode：将字符编码成二进制数的一种方式。Unicode字符集包含了许多语言的字符，不仅限于英语。Java内部使用的就是Unicode字符集。
URL：全球资源定位器。Internet上资源的地址，比如网页。
变量（variable）：一个带名字的内存位置（或一系列位置），用来存储数据。在程序中创建变量，通过变量声明语句将名字赋予该变量。根据使用情况，这个名字在程序中可以代指该内存位置，或者向内存地址中存储数据。在Java中，变量具有类型，可以表示变量持有数据的种类。
包装类（wrapper class）：类似Double、Integer这样的类，将一个基本类型的值“包装”在对象中，该对象归属于包装类。这样，在需要使用对象的地方也可以使用基本类型值，比如Java集合框架。
XML（eXtensible Markup Language）：可扩展标记语言。一种非常常见且语法标准、支持良好的语言。用来创建基于文本的数据表示。
The above is all the content of this article. I hope it will be helpful to everyone's learning and I hope everyone will support Wulin.com more.