Learn Java's messy notes

1. Local variables: Variables defined in a method, variables defined in a method, variables defined in a For loop, are local variables,
In the stack memory to open up a space, the data is used, automatic release.

2. What defines a function? (Don't need rote, just know)
1. Since the function is a separate function, the result of the operation of the function is to be clarified first.
is the return value type in the explicit function
2. Whether unknown content is required to participate in the operation in the process of clearly defining the feature.
Define the parameter list of the function (the type of the parameter and the number of arguments)

3.break: can only be used to select structure and loop structure.
Continue: can only be used for looping (loop) structures, ending this cycle and continuing the next cycle.
Continue and break if there is no scope to exist alone, it is meaningless and the statement compilation fails

4. You can label the for loop by the letter, and only for the FOR loop label!! Easy to distinguish

5. Accumulation of ideas:
The result of each change is recorded by a variable, and the cumulative operation is carried out in the form of a loop.
Counter idea
The change in the state of the data is recorded by a variable, and it needs to be implemented by loops.

6. When do I use overloading? Overloading is independent of the return value type
When the defined functions are the same, but the unknown content of the participating operations is not the same,
Then define a function name to represent its functionality, facilitate reading, and distinguish multiple functions with the same name by different parameter lists
Note: parameters in the parameter list are sequential!!!!!!!!

7. Function definition idea: each function needs only to complete the function that he wants, does not need the superfluous action, the column is like the summation statement
You only need to complete the sum and return it, instead of making extra printouts, each function is independent
Just complete the definition that should be done, don't need redundant definitions, if necessary, that's what the caller did, each function
You can only return it.

8. One: The variable has its own scope, for the For loop, if the increment of the control loop is defined in the For statement, the variable is only valid within that loop,
When the For statement finishes executing, the variable is freed in memory
Two: The For loop can be interchanged with the while statement, and if you need to define a loop variable, the for loop is more reasonable

9. Escape character: through \ To change-the meaning of the back-letter or symbol.
\ n: line break;
\b: backspace, equivalent to backspace;
\ r: Press ENTER, in Windows system, the return key is represented by two characters \r,\n
On a Linux system, the ENTER key is represented by only one character
\ t: tab, equivalent to Tab key

10. Each entity in the heap memory has a memory address value, either with or without being referenced by the address value contained in the defined variable in the stack memory, rather than directly representing

11. The array angle is zero-based, and the array is defined with a value and the default value is 0.

12. The entities in the heap memory are encapsulated data and have default initialization values

13. Object-oriented three features: 1, Package, 2, inheritance; 3, polymorphic;

14. The difference between an object and a class:
A class is a description of things in real life.
Objects are the entities in which such things exist.

15, in fact, the definition of the class is to describe things, that is, to define properties and behaviors, and attributes and behaviors are collectively referred to as members of the class (member variables and member methods);

16, the class type variable points to the object

17, the difference between a member variable and a local variable:
Scope of Action:
Member variables act on the entire class,
A local variable acts in a function or statement;
In-memory location:
The member variable is in the heap memory, because the object exists, only in memory;
Local variables exist in the stack memory.

18,private: Private, permission modifier that is used to decorate a member (member variable, member function) in a class. Private is only valid in this class
Privatization of member variables to provide access to the set get method to improve the security of data access
Note: Private is only a form of encapsulation, private is encapsulated, but encapsulation is not private

19, the definition of the constructor:
1. Function names are consistent with class names
2. Do not define return value types
3. Do not write a return statement
When an object is established, the corresponding constructor is called
Constructors can be used for object initialization
Detail: When a constructor is not defined in a class, the system defaults to a constructor that adds an empty argument to the class
This class is easy to initialize, and when a constructor is customized in a class, the default constructor is gone.
The difference between a constructor and a general function:
1. Different in wording
2. Different on the run
A constructor is a function that runs when an object is established and initializes the object.
A general function is a function that is performed on an object invocation and adds an object to an object.
An object is established, and the constructor runs only once
A general function can be called many times by an object
When to define a constructor:
When an object is analyzed, it has some characteristics or behavior, then the content is defined in the constructor
In a class, there is a constructor for an empty argument by default, and the permission of the default constructor is the same as the owning class
If the class is modified by public, the default constructor is also with the public modifier
If the class is not modified by public, then the default constructor does not have a public modifier

The permissions of the default constructor change as the class changes.

20. Building blocks of code: role: Initializing objects
The object runs as soon as it is established and takes precedence over the constructor execution
Differences from constructors:
Constructing a code block is a unified initialization for all objects
The constructor is initialized to the corresponding object.
The initialization content of different object commonalities is defined in the Construction code block

New xxx (); First, the default initialization, NULL or 0, display initialization, and then construct the code block initialization, and then the constructor initialization, there is a sequence

21.this Keywords:
Represents the reference to the object to which the function belongs
Simply put: That object is calling this function, this represents that object
This applies: When defining a function in a class, the function is used internally to represent the object when the function is called.
Whenever this type of object is used within this function, it is used to denote
This function: 1. The same name used to differentiate between local variables and member variables.
2. Used to call each other between constructors.
Note: This statement can only be defined in the first row of the constructor, because initialization is performed first, or an error is given
The call to this must be the first statement in the constructor.

22.java of heap memory, stack memory, and method area (shared area, data area);

23.static Keywords:
Usage: is a modifier used to modify members (member variables, member functions);
When a member is statically decorated, it is more of a calling method, except that it can be called by the object.
can also be called directly by the class name, in the form: class name. static members

A static member variable defined is also called a class variable, and the class is called to execute

Member variable also known as instance variable

Static Features:
1. Loads as the class loads.
that is, the static disappears as the class disappears, which means it has the longest life cycle.

2. Precedence over object existence
Explicit, static is first, object is after

3. Shared by all objects

4. The difference between a

instance object and a class variable can be called directly by the class name:
1. Storage location: The
class variable exists in the method area as the class is loaded
instance object exists in the heap memory with the object's creation
2. Life cycle:
Class variable life cycle is the longest and disappears as the class disappears
instance variable declaration period disappears as the object disappears

Static usage considerations:
1. Static methods can only access static members. The
non-static method can access both static and non-static
2. The This,super keyword cannot be defined in a static method
because static takes precedence over the existence of an object, it is not possible to see this
3 in a static method. The main function is static

Static pros and Cons:
Profit: The object's shared data is stored in a separate space, saving space, there is no need to store one copy of each object,
can be directly called by the class name
Disadvantage: The life cycle is too long.
Access is limited (static, only static. ;

24. When do I use static?
to do it in two ways:
because the content that is statically decorated has member variables and member functions.
When are static variables (class variables) defined?
When shared data appears in an object, the data is defined as non-static in heap memory by the unique data in the statically decorated
object. When does the

define a static function?
The function can be defined as static when there is no access to non-static data (unique data for the object) within the function.

25. Special characters for document comments:
@auther author
@version version number
@param parameter
@return return value

26.Person P =new person ("Zhang San",

);

What did you do with that sentence?
1. Because new uses Person.class, the Person.class file is first found and loaded into memory.
2. Execute the static block of code in the class, and if so, initialize the Person.class class.
3. Open up space in heap memory and allocate memory address.
4. Establish the unique properties of the object in heap memory and initialize it by default.
5. Display initialization of the properties.
6. Constructing a code block class on an object
7. Initialize the corresponding constructor for the object.
8 Assign the memory address to the P variable in the stack memory.

27. Things are not only inheritance, but also aggregation: aggregation and composition.

28. Instantiation of Subclasses: (Step up search)

All constructors in a subclass access the null argument constructor in the parent class by default, because the subclass constructor
There is an implicit super statement in the first line of the.

When the constructor for a parent class does not have an empty argument, the subclass must manually specify the constructor in the parent class to access by using the Super statement.

Of course, the first row of constructors in subclasses can also manually specify the this statement to access the constructors in this class, and at least one of the constructors in the subclass will access
The constructor in the parent class.

Note: This and super statements cannot be in a function because all two functions must be in the first row,
And why the This and super statements in the first line, because two statements to be initialized, if not in the first row,
initialization is meaningless.

29. What is a template method
When defining a feature, one part of the functionality is deterministic, while another part of the functionality is indeterminate, and the identified functionality is used in uncertain functions.
An indeterminate function can be exposed and overridden by a subclass.
30.public,protected,private is used in Java to define the access rights of members, there is also a "default", that is, before the member without any permission modifiers. Such as:
public class a{
void method () {};
}
Method belongs to the default permission.

These four modifiers have access to the following table:
-----------------------------------------------
Intra-class package other
Public allow allow allowed allowed
Protected allow allow not allowed
Default allow disallowed not allowed
Private allow not allow not allowed
-----------------------------------------------

For example: Members modified with protected (variables or methods), can be called inside the class, other classes under the same package can also be called, subclasses can also be called, other places can not be called,
This means that in other

The Java language defines the 6 common modifiers for public, protected, private, abstract, static, and final
The word also defines 5 less commonly used modifiers, and the following is an introduction to these 11 Java modifiers:
1.public
Working with objects: classes, interfaces, members
Description: The class (interface, member) is accessible regardless of the package definition in which it is located
2.private
Working with objects: members
Description: A member can be accessed only in the class in which it is defined
3.static
Working with objects: classes, methods, fields, initialization functions
Description: The inner class known as Static is a top-level class, and it is irrelevant to the members of the containing class. Static methods
is a class method,
is a pointer to an instance of the owning class rather than the class. A static field is a class field, regardless of the class where the field is created.
How many instances, the word
Only one instance of a segment is pointed to the class to which it belongs, not to an instance of the class. The initialization function is executed when the class is loaded
Instead of creating a
Executes when the instance is instantiated.
4.final
Working with objects: classes, methods, fields, variables
Description: A class that is defined as final does not allow subclasses, cannot be overwritten (not used for dynamic queries), field values
Not allowed to be
Modify.
5.abstract
Working with objects: classes, interfaces, methods
Description: The class includes methods that are not implemented and cannot be instantiated. If it is an abstract method, the method body
is empty, the party
The implementation of the method is defined in the subclass, and the class containing an abstract method must be an abstract class
6.protected
Working with objects: members
Description: A member can only be accessed in the package that defines it, and if it is accessed in another package, the class that implements this method
Must be the
Subclass of the class to which the member belongs.
7.native
Working with objects: members
Description: Related to the operating platform, the definition does not define its method, and the implementation of the method is implemented by an external library.
8.strictfp
Working with objects: classes, methods
Description: All methods in the STRICTFP decorated class hide the strictfp modifier, and all floating-point methods executed by the method
Calculation compliance
IEEE 754 standard, all values including intermediate results must be expressed as a float or double type, and cannot be exploited
Floating on the local platform
Point format or hardware provides additional precision or range of representation.
9.synchronized
Working with objects: methods
Description: For a static method, the JVM locks the class it is in before execution, and for a non-static class
Law, Enforcement
Lock a particular object instance before the
10.volatile
Working with objects: Fields
Description: Because asynchronous threads can access fields, some optimizations do not necessarily work on fields.
Volatile sometimes
can replace synchronized.
11.transient
Working with objects: Fields
Description: The field is not part of the object's persistent state, and the fields and objects should not be strung together.

31. Differences between interfaces and inheritance:
An interface is an extended property of objects and things, belonging to a separate class that belongs to each implementing interface.
Inheritance, however, is the child class that passes all of the parent class and adds properties specific to the subclass.

Columns such as senior students are students of a kind, senior students inherit all the properties and methods of students, such as learning and thinking.
And some of the senior students will smoke, drink, etc., if inherited, then all students will smoke, drink. However, just
Part of the senior students ' meeting. Therefore, the interface is used to represent the extended attribute.

32. Polymorphism: A variety of forms of the existence of things.
The manifestation of polymorphism: the reference of the parent class points to the object of the child class,
A reference to the parent class can also accept the object of the child class.
Person m = new Mans ();
The prerequisite for polymorphism is that the class must have a relationship with the class, either inherited or implemented, and the subclass has overrides for the parent class.
The benefits of polymorphism: the appearance of polymorphism greatly improves the expansion of the program.
The disadvantage of polymorphism: while increasing the extensibility of the code, you can only access members of the parent class by using a reference to the parent class.
Polymorphism from the beginning to the end is the subclass of the object is changing, can be converted to the parent class when the application points to its own subclass object, you can either upward conversion, can also cast.

The characteristics of member functions in polymorphism:
At compile time, see if there is a calling method in the class to which the referenced variable belongs, and if so, the compilation passes, otherwise it fails.
At run time, see if there are methods called in the class to which the object belongs
That is, when a member function is called in a polymorphic state, the compiler looks to the left and runs to the right.

In polymorphism, the characteristics of member variables;
Reference to the left (the class to which the reference variable belongs), whether compiled or run

In polymorphism, the characteristics of static member functions:
Whether compiling or running, refer to the left.

33. Exception: Program in! Run! Abnormal conditions that occur when the
The origin of the exception: exceptions are a specific problem in real life, and Java is describing these issues as classes and encapsulating them as objects.
Is the behavior of the object after Java describes the abnormal situation.

For the division of the problem: one is a serious problem-error, one is serious----Exception
No code handling for error issues, and exception problem handling
But error and exception have some commonalities.
Columns such as abnormal information, cause, etc.

Throwable
--error

--exception

34. There is a special class in the Exception class Runtimeexceptiom
If an exception is thrown in the function's contents, the function can be declared, compiled by
If an exception is declared in the function, the caller can pass without processing, and the caller is not required to handle it because no

When this code exception occurs, RuntimeException expects this code to stop because in the run, if a stop occurs, you should stop the operation and modify the code

When you customize the exception, if the exception occurs and the program cannot continue, then let the custom class inherit RuntimeException

There are two categories for exceptions
1. Exceptions detected at compile time

2. Exceptions that are not checked at compile time, and exceptions that are checked at runtime (RuntimeException and its subclasses)

35. Overrides in the child parent class are reflected in the exception:
1. When a subclass overrides a parent class, if the method of the parent class throws an exception, the overridden method of the child class can only throw the exception of the parent class or the subclass of the exception.
2. If more than one exception is thrown in the parent class, the child class can only throw a subset of the parent class if it overrides the method.
3. If no exception is thrown in the method of the parent class or interface, the subclass is not allowed to throw an exception in the overridden method
If an exception occurs in a subclass method, only try processing can be done and cannot be thrown.

36. Multithreading:
Process: is a program that is being executed.
Each process execution has an execution order. The order is an execution path, or a control unit. The space that runs in the CPU

Thread: is a separate control unit in the process. Threads control the execution of a process

There is at least one thread in a process.

The JVM will start with a process Java. Exe

At least one thread in the process is responsible for the execution of the Java program
And the code that this thread runs on is in the Main method
This thread is called the primary thread.
Expand:
The JVM actually starts more than one thread, and there are threads responsible for the garbage collection mechanism.

The first method of creating a thread inherits the thread class
1. Define class inheritance thread.
2. Overwrite the Run method in tread
Write the custom code into the Run method to have the thread run.
3. Call the thread's Start method
Start method: 1. Start the thread. 2. Call the Run method

It is found that the results are different at each run.
Because multiple threads are getting the CPU execution right, the CPU executes to who, who runs
Make it clear that at some point the CPU can only execute one thread, and the CPU is switching at high speed to achieve the effect while running (except multicore)
We can take multi-threaded runs to get the execution right in the snatch CPU.

This is also a feature of multithreading: Randomness. Who grabs who to execute. As for how long it takes to execute, the CPU decides.


Create the second method of the thread, implement the Runnable interface
1. Implementing the Runnable interface for the defined class
2. Overwrite the Run method in the Runnable interface
Define the code block that the thread will run in in the Run method
3. Creating thread objects through thread
4. Pass the subclass object of runnable as the actual argument to the constructor of the thread class
Because the owning object of the custom Run method is a subclass object of the Runnable interface
So let the thread execute the Run method of the specified object. The owning object of the Run method must be defined
5. Call the Start method in thread to start the thread and call the Run method in the Runnable interface.

What is the difference between implementation and inheritance?
Implementation is to avoid the limitations of single inheritance
When defining threads, it is recommended to implement the Runnable interface method

Difference:
The biggest difference between the two methods is that the Run method exists in a different location
Inherits the thread class, which is present in the Run method in the thread subclass
Implement the Runnable interface, where thread code exists in the Run method in the Runnable interface

37. Generic class Definition:
Class name < generic name >
Generic wildcard characters?

When you need to define an object with an unknown reference data type, you can better reduce the code by using generics

The Aslist method in 38.Arrays
By turning the array into a collection, you can use the methods in the collection to make it easier

However, you cannot use additions or deletions after becoming a collection because the array length is fixed. is exported. Unsupportedoperationexception Error

If the elements in the array are objects, then the elements in the array are converted directly to the elements in the collection when they become collections

If the elements in the array are basic data types, then this array is said to be passed as an object in the collection.

39.
In fact, Java itself does not have the ability to create data to the file, but in the call to the windows underlying creation of the deposit method
Java on other operating systems, call the operating system internal underlying methods to operate

40.IOExcption Standard processing method
FileWriter FW =null;

Try
{
FW =new FileWriter ("A:\\demo.txt");//If the destination value is wrong, the FW initialization fails, the FW is NULL, the close statement cannot be called, so first judge

Fw.write ("Sdfasfas");


}
catch (IOException E)
{
System.out.println (E.tostring ());
}
finally{

Try
{
if (fw!=null)
Fw.close ();//Be sure to close the stream resource and put it in the finally statement

}
catch (IOException E)
{

System.out.println (E.tostring ());
}
}

41. Decorative design mode:
When you want to enhance an existing object, you can define a class, pass in an existing object,
Based on existing functionality and provides an enhanced method, the custom class is called an ornament class

Decorative classes typically accept objects to be decorated by means of constructors, and are based on the decoration class's
Methods to provide a more powerful approach

Example: The ReadLine method in BufferedReader is based on the Read method in FileReader

The difference between decorative design patterns and inheritance:
Decoration mode is more flexible than inheritance, avoids the bloated nature of excessive inheritance, and reduces the relationship between classes and classes.

Decorative class because it is to enhance the existing objects, has the function and the existing is similar, but provides a stronger method of modification
Therefore, the decoration class and the decoration class are usually belong to the same system, is the combination of relations.


42. Basic rules of flow operation
Three clear
1. Clear source and purpose
Source: Input stream: Byte stream: InputStream character stream: Reader
Purpose: Output stream: Byte stream: OutputStream character stream: Writer

2. Whether the specified data is a plain text file
Yes: Character stream
No: Byte stream

3. When the system is clear, it is necessary to specify which object to use
Differentiate by device
SOURCE device: Memory, HDD, keyboard input
Purpose device: Memory, HDD, console


1. Copy one text file data to another text file
Source: Because it is a source, use the input stream, InputStream Reader

Use a character stream Reader because the manipulated text is plain text

Clear specific use of the device, the text file on the hard drive,
So the method of using the specific action file in the reader class FileReader

If the text file is too large, need to be more efficient, use the buffer method

FileReader fr =new FileReader ("yuan.xxx");
BufferedReader BR =new BufferedReader (FR);

Objective:
Because it is the purpose, so using the output stream, OutputStream Writer

Because the manipulated text is plain text, use the character stream Writer

Clear specific use of the device, the new text file on the hard drive
So the method of using the specific operation file in the writer class FileWriter

If the text file is too large, need to be more efficient, use the buffer method

FileWriter FW =new FileWriter ("newmudi.xxx");
BufferedWriter BW =new bufferedwriter (FW);

43. Expansion: the keyboard input data according to the specified encoding table (UTF-8) to a file

Source: Because it is an input stream, it is Inputstream,reader

Use a character stream Reader because it is plain text

Device: Keyboard, so use system.in
But because it is easy to operate, it is faster to turn into a character stream to operate.
So use the InputStreamReader method in the reader class to turn bytes into characters

InputStreamReader ISR =new InputStreamReader (system.in);

Whether the text being lost is too large. , whether it is necessary to be efficient, add buffers

Bufferedread BR =new bufferedread (ISR);

Purpose: Because it is an output stream, it is outputstream,writer

Because it is plain text, use writer

Device: A new file on the hard disk, so use FileWriter
However, the default encoding table used by FileWriter is GBK

Instead, a text file with a specified encoding format of UTF-8 is stored and can be used only with OutputStreamWriter in the transform stream.
The conversion stream accepts a byte output stream, and the byte output stream that can be manipulated is FileOutputStream

OutputStreamWriter OSW =new OutputStreamWriter (New FileOutputStream ("D.txt"), "UTF-8");

Need to be efficient and buffered

BufferedWriter buw =new bufferedwriter (OSW);

The conversion stream is required for encoding table problems in transcoding.

44.jar Grab Bag
The Java file is packaged first,
A Java file that needs to be compiled to run the javac-d package in DOS
Example: javac-d g:\javab\mypackage Awtdemo5.java AwtDemo5 is loaded into g:\javab\mypackage
Run the Java package name directly in MyPackage. Class name

In the capture package, first declare the main class, that is, create a file that will Main-class: the name of the package. The main class name and then the return table to the end of the line. Note You must have a space after the colon
For example: Main-class:mymenu. AwtDemo5
Grab package format: JAR-CVFN jar Name Declaration main class Package name
Example: JAR-CVFM menu.jar Main.txt MyMenu

45.TCP and UDP
Udp:1. Encapsulates data, purpose, and source into a packet without establishing a connection.
2. The size of each transmitted packet is limited to 64k
3. Unreliable connection due to no connection
4. Because there is no need to establish a connection, so the speed is relatively fast

Example: Walkie-talkie, post office mail, video conferencing, because the transmission is fast, data loss does not matter

Tcp:1. Establishing a data connection to form a channel for transmitting data
2. Transmission of big data can be carried out in the transmission channel.
3. Reliable connection via three-time handshake connection
Three-time handshake connection, that is, the client makes a request to the server, the server responds to the client's request, and the client receives a response back to the server.
4. Because the connection needs to be established, so the speed is relatively slow

Two people on the phone

46. In the function to determine the condition, in the loop to only the result, you can define a tag outside the loop, if the tag changes in the loop, remember the result, otherwise do not remember. Columns such as Boolean flag= true

47.*.split (#) * Object with # Split

48.http Request message Header
/*
Http://169.254.84.190:12000/myweb/demo.html
Get/myweb/demo.html http/1.1 sends a GET request to
Accept:text/html, Application/xhtml+xml, */* supported formats */* tables in addition to the above format support
Accept-language:zh-cn
user-agent:mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Tride
nt/5.0)
Ua-cpu:amd64
Accept-encoding:gzip, deflate Support package format
host:169.254.84.190:12000 Client
Connection:keep-alive//available for closed
Empty line, must exist, used to separate the head and body
This part is the request message body.
*/

The 49.InnetAddress package is an IP address
Innersocketaddress package is IP address plus port number

50. Domain name resolution, if you enter an IP address, directly follow the IP address to open the Web page
If you enter a domain name, it is common to look for the domain name and IP address mapping from the host file under the local C drive. If so, open the Web page according to the mappings in the local file.
If not, look for the mapping relationship from DNS.

51. When an object invokes the specified method, the calling object must be specified, along with the parameters passed in.

52. Regular expression: An expression that conforms to a certain rule.
Function: Used to specialize in manipulating strings.
Features: Used for some specific symbols to represent some code manipulation. This simplifies writing.
So learning regular expressions is the use of learning some special symbols.
Benefit: You can simplify complex operations on strings.
Cons: The more symbol definition, the longer the regular, the worse the reading.
Specific operation function:
1, matching: String matches method. Matches the entire string with a rule, so long as there is a non-conforming rule, the match ends and false is returned.
2, Cut: String split ();
3, replace: String replaceall (REGEX,STR), if there is a defined group in the regex, you can get the existing group in the regular expression in the second argument through the $ symbol.
The fourth function of a regular expression.
4, gets: the string that matches the rule's substring is fetched.
Operation Steps:
1, encapsulates the regular expression into an object.
2 to associate the regular object with the string to manipulate.
3, after correlation, gets the regular match engine.
4, by the engine to the rules of the sub-string operation, such as remove.

53.\\1 a back reference that represents the contents of the parentheses in the expression, from left to right, and the first opening parenthesis.
\2, and so on, represents the second, and the whole expression

$1,$2. Is the contents of the parentheses represented
$ $ is in the first parenthesis, and the 2nd one in parentheses.
Like/gai ([\w]+?) Over ([\d]+)/
Match gainover123
$1= the N in parentheses
$2= the 2nd 123 in parentheses.


Match double-byte characters (including kanji): [^\x00-\xff]

Regular expressions that match Chinese characters: [\U4E00-\U9FA5]

54.static void Seterr (PrintStream err)
Reassign the "standard" error output stream.
static void SetIn (InputStream in)
Reassign the "standard" input stream.
static void SetOut (PrintStream out)
Reassign the "standard" output stream.
Upcoming SYSTEM.OUT.PRINTLN () system.in conversion stream

55. Random access Stream, randomaccessfile readable writable.

The data is encapsulated using tags in 56.html, and the encapsulated data can be manipulated by attributes in the tag.
Details of the data.

57.

Learn Java's messy notes