Analysis of HelloWorld principle in Java

The first program we use when learning Java is "hello world". The following is an analysis of the principles of Java HelloWorld through example code. Friends who are interested can learn together.

The first program for us to learn Java is "hello world"

 public class HelloWorld {
   public static void main(String[] args) {
     System.out.println("hello world");
   }
}

What is the above program? What about outputting "hello world" on the screen? This is what was originally intended to be explained, that is, the principle of System.out.println("hello world").

Let’s first look at the process of System.out.println. Let’s first look at the definition of out in System.java. The source code is as follows:

public final class System {
   ... 
   public final static PrintStream out = null; 
   ...
 }

From it, we find that

(01) out is static## of System.java #variable.

(02) And out is a PrintStream

object, and there are many overloaded println() methods in PrintStream.java.

OK, we know that out is a PrintStream object. Next, see how it is initialized and how it is related to screen output?

Let’s analyze it step by step. First, look at the initializeSystemClass() method of System.java.

1. The source code of initializeSystemClass() is as follows: Mark the out part in red

 private static void initializeSystemClass() {
   props = new Properties();
   initProperties(props); // initialized by the VM
   sun.misc.VM.saveAndRemoveProperties(props);
   lineSeparator = props.getProperty("line.separator");
   sun.misc.Version.init();
   FileInputStream fdIn = new FileInputStream(FileDescriptor.in);
   FileOutputStream fdOut = new FileOutputStream(FileDescriptor.out);
   FileOutputStream fdErr = new FileOutputStream(FileDescriptor.err);
   setIn(new BufferedInputStream(fdIn));
   setOut0(new PrintStream(new BufferedOutputStream(fdOut, 128), true));
   setErr0(new PrintStream(new BufferedOutputStream(fdErr, 128), true));
   loadLibrary("zip");
   Terminator.setup();
   sun.misc.VM.initializeOSEnvironment();
   Thread current = Thread.currentThread();
   current.getThreadGroup().add(current);
   setJavaLangAccess();
   sun.misc.VM.booted();
 }

We only need to pay attention to the red code part above:

FileOutputStream fdOut = new FileOutputStream(FileDescriptor.out);
setOut0(new PrintStream(new BufferedOutputStream(fdOut, 128), true));

Change these two sentences If subdivided, it can be divided into the following steps:

Step 1 FileDescriptor fd = FileDescriptor.out;

Step 2 FileOutputStream fdOut = new FileOutputStream(fd);

Step 3 BufferedOutputStream bufOut = new BufferedOutputStream(fdOut, 128);

Step 4 PrintStream ps = new PrintStream(bufout, true);

Step 5 setOut0(ps);

Instructions:

(01) Step 1, get the static member out in FileDescriptor.java. out is a FileDescriptor object, which is actually the identifier of "standard output (screen)" .

The code related to FileDescriptor.out in FileDescriptor.java is as follows:

 public final class FileDescriptor {
    private int fd;
   public static final FileDescriptor out = new FileDescriptor(1);
   private FileDescriptor(int fd) {
     this.fd = fd;
     useCount = new AtomicInteger();
   }
   ...
 }

(02) Create a "File Output Stream" corresponding to "Standard Output (Screen)".

(03) Create a "buffered output stream" corresponding to the "file output stream". The purpose is to add "buffering" functionality to the "File Output Stream".

(04) Create a "print output stream" corresponding to the "buffered output stream". The purpose is to provide a convenient printing

interface for the "buffered output stream", such as print(), println(), printf(); so that it can print output conveniently and quickly.

(05) Execute setOut0(ps);

Next, parse the setOut0(ps) in step 5. Check the declaration of setOut0() in System.java, as follows:

private static native void setOut0(PrintStream out);

From it, we find that setOut0() is a native local method. Through openjdk, we can find its corresponding source code, as follows:

 JNIEXPORT void JNICALL
 Java_java_lang_System_setOut(JNIEnv *env, jclass cla, jobject stream)
 {
   jfieldID fid =
     (*env)->GetStaticFieldID(env,cla,"out","Ljava/io/PrintStream;");
   if (fid == 0)
     return;
   (*env)->SetStaticObjectField(env,cla,fid,stream);
 }

Description:

This is a JNI

function, let’s do a simple analysis of it.

(01) Function name

JNIEXPORT void JNICALL Java_java_lang_System_setOut0(JNIEnv *env, jclass cla, jobject stream)

This is the static registration method of JNI. Java_java_lang_System_setOut0(JNIEnv *env, jclass cla, jobject stream) will be the same as setOut0(PrintStream out) in System.java Association; moreover, the parameter stream corresponds to the parameter out. To put it simply, when we call setOut0(), we actually call Java_java_lang_System_setOut0().

(02) jfieldID fid = (*env)->GetStaticFieldID(env,cla,"out","Ljava/io/PrintStream;");

The function of this sentence It is to obtain the jfieldID of the static member out of System.java. "Ljava/io/PrintStream;" means that out is a java.io.PrintStream object.

The purpose of obtaining out's jfieldID is that we need to change the value of out by operating "out's jfieldID".

(03) (*env)->SetStaticObjectField(env,cla,fid,stream);

The function of this sentence is to set the corresponding fid (fid is the jfieldID of out) The value of the static member is stream.

stream is the parameter we pass to Java_java_lang_System_setOut0(), which is the parameter passed to setOut0.

Summary of the above. We know that the function of setOut0(PrintStream ps) is to set ps to the out static variable of System.java.

As mentioned before, FileDescriptor.out is the file identifier of the machine's "standard output (screen)". We can generally understand the file identifier as the "standard output" represented by FileDescriptor.out.

Therefore, in initializeSystemClass(), the above 5 steps are to encapsulate "FileDescriptor.out". The encapsulated System.in has both buffering function and convenient operation interfaces, such as print(), println(), and printf().

The above is the detailed content of Analysis of HelloWorld principle in Java. For more information, please follow other related articles on the PHP Chinese website!