如何用记事本生成API文档？javadoc命令使用

作者：岳述穗__ | 来源：互联网 | 2023-10-10 10:06

1》在我们jdk的bin目录下有一个javadoc可执行程序其作用是根据java源文件生成doc文档，也就是api文档2》我们可以自己用记事本来编写一段java源文

1》在我们jdk的bin目录下有一个javadoc可执行程序

其作用是根据java源文件生成doc文档&＃xff0c;也就是api文档

2》我们可以自己用记事本来编写一段java源文件

这里我直接copy了一份PrintStream 类源码

/** Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.** This code is free software; you can redistribute it and/or modify it* under the terms of the GNU General Public License version 2 only, as* published by the Free Software Foundation. Oracle designates this* particular file as subject to the "Classpath" exception as provided* by Oracle in the LICENSE file that accompanied this code.** This code is distributed in the hope that it will be useful, but WITHOUT* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License* version 2 for more details (a copy is included in the LICENSE file that* accompanied this code).** You should have received a copy of the GNU General Public License version* 2 along with this work; if not, write to the Free Software Foundation,* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.** Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA* or visit www.oracle.com if you need additional information or have any* questions.*/package java.io;import java.util.Formatter; import java.util.Locale; import java.nio.charset.Charset; import java.nio.charset.IllegalCharsetNameException; import java.nio.charset.UnsupportedCharsetException;/*** A PrintStream adds functionality to another output stream,* namely the ability to print representations of various data values* conveniently. Two other features are provided as well. Unlike other output* streams, a PrintStream never throws an* IOException; instead, exceptional situations merely set an* internal flag that can be tested via the checkError method.* Optionally, a PrintStream can be created so as to flush* automatically; this means that the flush method is* automatically invoked after a byte array is written, one of the* println methods is invoked, or a newline character or byte* (&＃39;\n&＃39;) is written.**

All characters printed by a PrintStream are converted into* bytes using the platform&＃39;s default character encoding. The {&＃64;link* PrintWriter} class should be used in situations that require writing* characters rather than bytes.** &＃64;author Frank Yellin* &＃64;author Mark Reinhold* &＃64;since JDK1.0*/public class PrintStream extends FilterOutputStreamimplements Appendable, Closeable {private final boolean autoFlush;private boolean trouble &＃61; false;private Formatter formatter;/*** Track both the text- and character-output streams, so that their buffers* can be flushed without flushing the entire stream.*/private BufferedWriter textOut;private OutputStreamWriter charOut;/*** requireNonNull is explicitly declared here so as not to create an extra* dependency on java.util.Objects.requireNonNull. PrintStream is loaded* early during system initialization.*/private static T requireNonNull(T obj, String message) {if (obj &＃61;&＃61; null)throw new NullPointerException(message);return obj;}/*** Returns a charset object for the given charset name.* &＃64;throws NullPointerException is csn is null* &＃64;throws UnsupportedEncodingException if the charset is not supported*/private static Charset toCharset(String csn)throws UnsupportedEncodingException{requireNonNull(csn, "charsetName");try {return Charset.forName(csn);} catch (IllegalCharsetNameException|UnsupportedCharsetException unused) {// UnsupportedEncodingException should be thrownthrow new UnsupportedEncodingException(csn);}}/* Private constructors */private PrintStream(boolean autoFlush, OutputStream out) {super(out);this.autoFlush &＃61; autoFlush;this.charOut &＃61; new OutputStreamWriter(this);this.textOut &＃61; new BufferedWriter(charOut);}private PrintStream(boolean autoFlush, OutputStream out, Charset charset) {super(out);this.autoFlush &＃61; autoFlush;this.charOut &＃61; new OutputStreamWriter(this, charset);this.textOut &＃61; new BufferedWriter(charOut);}/* Variant of the private constructor so that the given charset name* can be verified before evaluating the OutputStream argument. Used* by constructors creating a FileOutputStream that also take a* charset name.*/private PrintStream(boolean autoFlush, Charset charset, OutputStream out)throws UnsupportedEncodingException{this(autoFlush, out, charset);}/*** Creates a new print stream. This stream will not flush automatically.** &＃64;param out The output stream to which values and objects will be* printed** &＃64;see java.io.PrintWriter#PrintWriter(java.io.OutputStream)*/public PrintStream(OutputStream out) {this(out, false);}/*** Creates a new print stream.** &＃64;param out The output stream to which values and objects will be* printed* &＃64;param autoFlush A boolean; if true, the output buffer will be flushed* whenever a byte array is written, one of the* println methods is invoked, or a newline* character or byte (&＃39;\n&＃39;) is written** &＃64;see java.io.PrintWriter#PrintWriter(java.io.OutputStream, boolean)*/public PrintStream(OutputStream out, boolean autoFlush) {this(autoFlush, requireNonNull(out, "Null output stream"));}/*** Creates a new print stream.** &＃64;param out The output stream to which values and objects will be* printed* &＃64;param autoFlush A boolean; if true, the output buffer will be flushed* whenever a byte array is written, one of the* println methods is invoked, or a newline* character or byte (&＃39;\n&＃39;) is written* &＃64;param encoding The name of a supported* * character encoding** &＃64;throws UnsupportedEncodingException* If the named encoding is not supported** &＃64;since 1.4*/public PrintStream(OutputStream out, boolean autoFlush, String encoding)throws UnsupportedEncodingException{this(autoFlush,requireNonNull(out, "Null output stream"),toCharset(encoding));}/*** Creates a new print stream, without automatic line flushing, with the* specified file name. This convenience constructor creates* the necessary intermediate {&＃64;link java.io.OutputStreamWriter* OutputStreamWriter}, which will encode characters using the* {&＃64;linkplain java.nio.charset.Charset#defaultCharset() default charset}* for this instance of the Java virtual machine.** &＃64;param fileName* The name of the file to use as the destination of this print* stream. If the file exists, then it will be truncated to* zero size; otherwise, a new file will be created. The output* will be written to the file and is buffered.** &＃64;throws FileNotFoundException* If the given file object does not denote an existing, writable* regular file and a new regular file of that name cannot be* created, or if some other error occurs while opening or* creating the file** &＃64;throws SecurityException* If a security manager is present and {&＃64;link* SecurityManager#checkWrite checkWrite(fileName)} denies write* access to the file** &＃64;since 1.5*/public PrintStream(String fileName) throws FileNotFoundException {this(false, new FileOutputStream(fileName));}/*** Creates a new print stream, without automatic line flushing, with the* specified file name and charset. This convenience constructor creates* the necessary intermediate {&＃64;link java.io.OutputStreamWriter* OutputStreamWriter}, which will encode characters using the provided* charset.** &＃64;param fileName* The name of the file to use as the destination of this print* stream. If the file exists, then it will be truncated to* zero size; otherwise, a new file will be created. The output* will be written to the file and is buffered.** &＃64;param csn* The name of a supported {&＃64;linkplain java.nio.charset.Charset* charset}** &＃64;throws FileNotFoundException* If the given file object does not denote an existing, writable* regular file and a new regular file of that name cannot be* created, or if some other error occurs while opening or* creating the file** &＃64;throws SecurityException* If a security manager is present and {&＃64;link* SecurityManager#checkWrite checkWrite(fileName)} denies write* access to the file** &＃64;throws UnsupportedEncodingException* If the named charset is not supported** &＃64;since 1.5*/public PrintStream(String fileName, String csn)throws FileNotFoundException, UnsupportedEncodingException{// ensure charset is checked before the file is openedthis(false, toCharset(csn), new FileOutputStream(fileName));}/*** Creates a new print stream, without automatic line flushing, with the* specified file. This convenience constructor creates the necessary* intermediate {&＃64;link java.io.OutputStreamWriter OutputStreamWriter},* which will encode characters using the {&＃64;linkplain* java.nio.charset.Charset#defaultCharset() default charset} for this* instance of the Java virtual machine.** &＃64;param file* The file to use as the destination of this print stream. If the* file exists, then it will be truncated to zero size; otherwise,* a new file will be created. The output will be written to the* file and is buffered.** &＃64;throws FileNotFoundException* If the given file object does not denote an existing, writable* regular file and a new regular file of that name cannot be* created, or if some other error occurs while opening or* creating the file** &＃64;throws SecurityException* If a security manager is present and {&＃64;link* SecurityManager#checkWrite checkWrite(file.getPath())}* denies write access to the file** &＃64;since 1.5*/public PrintStream(File file) throws FileNotFoundException {this(false, new FileOutputStream(file));}/*** Creates a new print stream, without automatic line flushing, with the* specified file and charset. This convenience constructor creates* the necessary intermediate {&＃64;link java.io.OutputStreamWriter* OutputStreamWriter}, which will encode characters using the provided* charset.** &＃64;param file* The file to use as the destination of this print stream. If the* file exists, then it will be truncated to zero size; otherwise,* a new file will be created. The output will be written to the* file and is buffered.** &＃64;param csn* The name of a supported {&＃64;linkplain java.nio.charset.Charset* charset}** &＃64;throws FileNotFoundException* If the given file object does not denote an existing, writable* regular file and a new regular file of that name cannot be* created, or if some other error occurs while opening or* creating the file** &＃64;throws SecurityException* If a security manager is present and {&＃64;link* SecurityManager#checkWrite checkWrite(file.getPath())}* denies write access to the file** &＃64;throws UnsupportedEncodingException* If the named charset is not supported** &＃64;since 1.5*/public PrintStream(File file, String csn)throws FileNotFoundException, UnsupportedEncodingException{// ensure charset is checked before the file is openedthis(false, toCharset(csn), new FileOutputStream(file));}/** Check to make sure that the stream has not been closed */private void ensureOpen() throws IOException {if (out &＃61;&＃61; null)throw new IOException("Stream closed");}/*** Flushes the stream. This is done by writing any buffered output bytes to* the underlying output stream and then flushing that stream.** &＃64;see java.io.OutputStream#flush()*/public void flush() {synchronized (this) {try {ensureOpen();out.flush();}catch (IOException x) {trouble &＃61; true;}}}private boolean closing &＃61; false; /* To avoid recursive closing *//*** Closes the stream. This is done by flushing the stream and then closing* the underlying output stream.** &＃64;see java.io.OutputStream#close()*/public void close() {synchronized (this) {if (! closing) {closing &＃61; true;try {textOut.close();out.close();}catch (IOException x) {trouble &＃61; true;}textOut &＃61; null;charOut &＃61; null;out &＃61; null;}}}/*** Flushes the stream and checks its error state. The internal error state* is set to true when the underlying output stream throws an* IOException other than InterruptedIOException,* and when the setError method is invoked. If an operation* on the underlying output stream throws an* InterruptedIOException, then the PrintStream* converts the exception back into an interrupt by doing:*

*     Thread.currentThread().interrupt();*

* or the equivalent.** &＃64;return true if and only if this stream has encountered an*         IOException other than*         InterruptedIOException, or the*         setError method has been invoked*/public boolean checkError() {if (out !&＃61; null)flush();if (out instanceof java.io.PrintStream) {PrintStream ps &＃61; (PrintStream) out;return ps.checkError();}return trouble;}/*** Sets the error state of the stream to true.**  This method will cause subsequent invocations of {&＃64;link* #checkError()} to return true until {&＃64;link* #clearError()} is invoked.** &＃64;since JDK1.1*/protected void setError() {trouble &＃61; true;}/*** Clears the internal error state of this stream.** 
 This method will cause subsequent invocations of {&＃64;link* #checkError()} to return false until another write* operation fails and invokes {&＃64;link #setError()}.** &＃64;since 1.6*/protected void clearError() {trouble &＃61; false;}/** Exception-catching, synchronized output operations,* which also implement the write() methods of OutputStream*//*** Writes the specified byte to this stream.  If the byte is a newline and* automatic flushing is enabled then the flush method will be* invoked.** 
 Note that the byte is written as given; to write a character that* will be translated according to the platform&＃39;s default character* encoding, use the print(char) or println(char)* methods.** &＃64;param  b  The byte to be written* &＃64;see #print(char)* &＃64;see #println(char)*/public void write(int b) {try {synchronized (this) {ensureOpen();out.write(b);if ((b &＃61;&＃61; &＃39;\n&＃39;) && autoFlush)out.flush();}}catch (InterruptedIOException x) {Thread.currentThread().interrupt();}catch (IOException x) {trouble &＃61; true;}}/*** Writes len bytes from the specified byte array starting at* offset off to this stream.  If automatic flushing is* enabled then the flush method will be invoked.** 
 Note that the bytes will be written as given; to write characters* that will be translated according to the platform&＃39;s default character* encoding, use the print(char) or println(char)* methods.** &＃64;param  buf   A byte array* &＃64;param  off   Offset from which to start taking bytes* &＃64;param  len   Number of bytes to write*/public void write(byte buf[], int off, int len) {try {synchronized (this) {ensureOpen();out.write(buf, off, len);if (autoFlush)out.flush();}}catch (InterruptedIOException x) {Thread.currentThread().interrupt();}catch (IOException x) {trouble &＃61; true;}}/** The following private methods on the text- and character-output streams* always flush the stream buffers, so that writes to the underlying byte* stream occur as promptly as with the original PrintStream.*/private void write(char buf[]) {try {synchronized (this) {ensureOpen();textOut.write(buf);textOut.flushBuffer();charOut.flushBuffer();if (autoFlush) {for (int i &＃61; 0; i &＃61; 0))out.flush();}}catch (InterruptedIOException x) {Thread.currentThread().interrupt();}catch (IOException x) {trouble &＃61; true;}}private void newLine() {try {synchronized (this) {ensureOpen();textOut.newLine();textOut.flushBuffer();charOut.flushBuffer();if (autoFlush)out.flush();}}catch (InterruptedIOException x) {Thread.currentThread().interrupt();}catch (IOException x) {trouble &＃61; true;}}/* Methods that do not terminate lines *//*** Prints a boolean value.  The string produced by {&＃64;link* java.lang.String#valueOf(boolean)} is translated into bytes* according to the platform&＃39;s default character encoding, and these bytes* are written in exactly the manner of the* {&＃64;link #write(int)} method.** &＃64;param      b   The boolean to be printed*/public void print(boolean b) {write(b ? "true" : "false");}/*** Prints a character.  The character is translated into one or more bytes* according to the platform&＃39;s default character encoding, and these bytes* are written in exactly the manner of the* {&＃64;link #write(int)} method.** &＃64;param      c   The char to be printed*/public void print(char c) {write(String.valueOf(c));}/*** Prints an integer.  The string produced by {&＃64;link* java.lang.String#valueOf(int)} is translated into bytes* according to the platform&＃39;s default character encoding, and these bytes* are written in exactly the manner of the* {&＃64;link #write(int)} method.** &＃64;param      i   The int to be printed* &＃64;see        java.lang.Integer#toString(int)*/public void print(int i) {write(String.valueOf(i));}/*** Prints a long integer.  The string produced by {&＃64;link* java.lang.String#valueOf(long)} is translated into bytes* according to the platform&＃39;s default character encoding, and these bytes* are written in exactly the manner of the* {&＃64;link #write(int)} method.** &＃64;param      l   The long to be printed* &＃64;see        java.lang.Long#toString(long)*/public void print(long l) {write(String.valueOf(l));}/*** Prints a floating-point number.  The string produced by {&＃64;link* java.lang.String#valueOf(float)} is translated into bytes* according to the platform&＃39;s default character encoding, and these bytes* are written in exactly the manner of the* {&＃64;link #write(int)} method.** &＃64;param      f   The float to be printed* &＃64;see        java.lang.Float#toString(float)*/public void print(float f) {write(String.valueOf(f));}/*** Prints a double-precision floating-point number.  The string produced by* {&＃64;link java.lang.String#valueOf(double)} is translated into* bytes according to the platform&＃39;s default character encoding, and these* bytes are written in exactly the manner of the {&＃64;link* #write(int)} method.** &＃64;param      d   The double to be printed* &＃64;see        java.lang.Double#toString(double)*/public void print(double d) {write(String.valueOf(d));}/*** Prints an array of characters.  The characters are converted into bytes* according to the platform&＃39;s default character encoding, and these bytes* are written in exactly the manner of the* {&＃64;link #write(int)} method.** &＃64;param      s   The array of chars to be printed** &＃64;throws  NullPointerException  If s is null*/public void print(char s[]) {write(s);}/*** Prints a string.  If the argument is null then the string* "null" is printed.  Otherwise, the string&＃39;s characters are* converted into bytes according to the platform&＃39;s default character* encoding, and these bytes are written in exactly the manner of the* {&＃64;link #write(int)} method.** &＃64;param      s   The String to be printed*/public void print(String s) {if (s &＃61;&＃61; null) {s &＃61; "null";}write(s);}/*** Prints an object.  The string produced by the {&＃64;link* java.lang.String#valueOf(Object)} method is translated into bytes* according to the platform&＃39;s default character encoding, and these bytes* are written in exactly the manner of the* {&＃64;link #write(int)} method.** &＃64;param      obj   The Object to be printed* &＃64;see        java.lang.Object#toString()*/public void print(Object obj) {write(String.valueOf(obj));}/* Methods that do terminate lines *//*** Terminates the current line by writing the line separator string.  The* line separator string is defined by the system property* line.separator, and is not necessarily a single newline* character (&＃39;\n&＃39;).*/public void println() {newLine();}/*** Prints a boolean and then terminate the line.  This method behaves as* though it invokes {&＃64;link #print(boolean)} and then* {&＃64;link #println()}.** &＃64;param x  The boolean to be printed*/public void println(boolean x) {synchronized (this) {print(x);newLine();}}/*** Prints a character and then terminate the line.  This method behaves as* though it invokes {&＃64;link #print(char)} and then* {&＃64;link #println()}.** &＃64;param x  The char to be printed.*/public void println(char x) {synchronized (this) {print(x);newLine();}}/*** Prints an integer and then terminate the line.  This method behaves as* though it invokes {&＃64;link #print(int)} and then* {&＃64;link #println()}.** &＃64;param x  The int to be printed.*/public void println(int x) {synchronized (this) {print(x);newLine();}}/*** Prints a long and then terminate the line.  This method behaves as* though it invokes {&＃64;link #print(long)} and then* {&＃64;link #println()}.** &＃64;param x  a The long to be printed.*/public void println(long x) {synchronized (this) {print(x);newLine();}}/*** Prints a float and then terminate the line.  This method behaves as* though it invokes {&＃64;link #print(float)} and then* {&＃64;link #println()}.** &＃64;param x  The float to be printed.*/public void println(float x) {synchronized (this) {print(x);newLine();}}/*** Prints a double and then terminate the line.  This method behaves as* though it invokes {&＃64;link #print(double)} and then* {&＃64;link #println()}.** &＃64;param x  The double to be printed.*/public void println(double x) {synchronized (this) {print(x);newLine();}}/*** Prints an array of characters and then terminate the line.  This method* behaves as though it invokes {&＃64;link #print(char[])} and* then {&＃64;link #println()}.** &＃64;param x  an array of chars to print.*/public void println(char x[]) {synchronized (this) {print(x);newLine();}}/*** Prints a String and then terminate the line.  This method behaves as* though it invokes {&＃64;link #print(String)} and then* {&＃64;link #println()}.** &＃64;param x  The String to be printed.*/public void println(String x) {synchronized (this) {print(x);newLine();}}/*** Prints an Object and then terminate the line.  This method calls* at first String.valueOf(x) to get the printed object&＃39;s string value,* then behaves as* though it invokes {&＃64;link #print(String)} and then* {&＃64;link #println()}.** &＃64;param x  The Object to be printed.*/public void println(Object x) {String s &＃61; String.valueOf(x);synchronized (this) {print(s);newLine();}}/*** A convenience method to write a formatted string to this output stream* using the specified format string and arguments.** 
 An invocation of this method of the form out.printf(format,* args) behaves in exactly the same way as the invocation** 
*     out.format(format, args) 
** &＃64;param  format*         A format string as described in Format string syntax** &＃64;param  args*         Arguments referenced by the format specifiers in the format*         string.  If there are more arguments than format specifiers, the*         extra arguments are ignored.  The number of arguments is*         variable and may be zero.  The maximum number of arguments is*         limited by the maximum dimension of a Java array as defined by*         The Java™ Virtual Machine Specification.*         The behaviour on a*         null argument depends on the conversion.** &＃64;throws  java.util.IllegalFormatException*          If a format string contains an illegal syntax, a format*          specifier that is incompatible with the given arguments,*          insufficient arguments given the format string, or other*          illegal conditions.  For specification of all possible*          formatting errors, see the Details section of the*          formatter class specification.** &＃64;throws  NullPointerException*          If the format is null** &＃64;return  This output stream** &＃64;since  1.5*/public PrintStream printf(String format, Object ... args) {return format(format, args);}/*** A convenience method to write a formatted string to this output stream* using the specified format string and arguments.**  An invocation of this method of the form out.printf(l, format,* args) behaves in exactly the same way as the invocation** 
*     out.format(l, format, args) 
** &＃64;param  l*         The {&＃64;linkplain java.util.Locale locale} to apply during*         formatting.  If l is null then no localization*         is applied.** &＃64;param  format*         A format string as described in Format string syntax** &＃64;param  args*         Arguments referenced by the format specifiers in the format*         string.  If there are more arguments than format specifiers, the*         extra arguments are ignored.  The number of arguments is*         variable and may be zero.  The maximum number of arguments is*         limited by the maximum dimension of a Java array as defined by*         The Java™ Virtual Machine Specification.*         The behaviour on a*         null argument depends on the conversion.** &＃64;throws  java.util.IllegalFormatException*          If a format string contains an illegal syntax, a format*          specifier that is incompatible with the given arguments,*          insufficient arguments given the format string, or other*          illegal conditions.  For specification of all possible*          formatting errors, see the Details section of the*          formatter class specification.** &＃64;throws  NullPointerException*          If the format is null** &＃64;return  This output stream** &＃64;since  1.5*/public PrintStream printf(Locale l, String format, Object ... args) {return format(l, format, args);}/*** Writes a formatted string to this output stream using the specified* format string and arguments.**  The locale always used is the one returned by {&＃64;link* java.util.Locale#getDefault() Locale.getDefault()}, regardless of any* previous invocations of other formatting methods on this object.** &＃64;param  format*         A format string as described in Format string syntax** &＃64;param  args*         Arguments referenced by the format specifiers in the format*         string.  If there are more arguments than format specifiers, the*         extra arguments are ignored.  The number of arguments is*         variable and may be zero.  The maximum number of arguments is*         limited by the maximum dimension of a Java array as defined by*         The Java™ Virtual Machine Specification.*         The behaviour on a*         null argument depends on the conversion.** &＃64;throws  java.util.IllegalFormatException*          If a format string contains an illegal syntax, a format*          specifier that is incompatible with the given arguments,*          insufficient arguments given the format string, or other*          illegal conditions.  For specification of all possible*          formatting errors, see the Details section of the*          formatter class specification.** &＃64;throws  NullPointerException*          If the format is null** &＃64;return  This output stream** &＃64;since  1.5*/public PrintStream format(String format, Object ... args) {try {synchronized (this) {ensureOpen();if ((formatter &＃61;&＃61; null)|| (formatter.locale() !&＃61; Locale.getDefault()))formatter &＃61; new Formatter((Appendable) this);formatter.format(Locale.getDefault(), format, args);}} catch (InterruptedIOException x) {Thread.currentThread().interrupt();} catch (IOException x) {trouble &＃61; true;}return this;}/*** Writes a formatted string to this output stream using the specified* format string and arguments.** &＃64;param  l*         The {&＃64;linkplain java.util.Locale locale} to apply during*         formatting.  If l is null then no localization*         is applied.** &＃64;param  format*         A format string as described in Format string syntax** &＃64;param  args*         Arguments referenced by the format specifiers in the format*         string.  If there are more arguments than format specifiers, the*         extra arguments are ignored.  The number of arguments is*         variable and may be zero.  The maximum number of arguments is*         limited by the maximum dimension of a Java array as defined by*         The Java™ Virtual Machine Specification.*         The behaviour on a*         null argument depends on the conversion.** &＃64;throws  java.util.IllegalFormatException*          If a format string contains an illegal syntax, a format*          specifier that is incompatible with the given arguments,*          insufficient arguments given the format string, or other*          illegal conditions.  For specification of all possible*          formatting errors, see the Details section of the*          formatter class specification.** &＃64;throws  NullPointerException*          If the format is null** &＃64;return  This output stream** &＃64;since  1.5*/public PrintStream format(Locale l, String format, Object ... args) {try {synchronized (this) {ensureOpen();if ((formatter &＃61;&＃61; null)|| (formatter.locale() !&＃61; l))formatter &＃61; new Formatter(this, l);formatter.format(l, format, args);}} catch (InterruptedIOException x) {Thread.currentThread().interrupt();} catch (IOException x) {trouble &＃61; true;}return this;}/*** Appends the specified character sequence to this output stream.** 
 An invocation of this method of the form out.append(csq)* behaves in exactly the same way as the invocation** 
*     out.print(csq.toString()) 
**  Depending on the specification of toString for the* character sequence csq, the entire sequence may not be* appended.  For instance, invoking then toString method of a* character buffer will return a subsequence whose content depends upon* the buffer&＃39;s position and limit.** &＃64;param  csq*         The character sequence to append.  If csq is*         null, then the four characters "null" are*         appended to this output stream.** &＃64;return  This output stream** &＃64;since  1.5*/public PrintStream append(CharSequence csq) {if (csq &＃61;&＃61; null)print("null");elseprint(csq.toString());return this;}/*** Appends a subsequence of the specified character sequence to this output* stream.** 
 An invocation of this method of the form out.append(csq, start,* end) when csq is not null, behaves in* exactly the same way as the invocation** 
*     out.print(csq.subSequence(start, end).toString()) 
** &＃64;param  csq*         The character sequence from which a subsequence will be*         appended.  If csq is null, then characters*         will be appended as if csq contained the four*         characters "null".** &＃64;param  start*         The index of the first character in the subsequence** &＃64;param  end*         The index of the character following the last character in the*         subsequence** &＃64;return  This output stream** &＃64;throws  IndexOutOfBoundsException*          If start or end are negative, start*          is greater than end, or end is greater than*          csq.length()** &＃64;since  1.5*/public PrintStream append(CharSequence csq, int start, int end) {CharSequence cs &＃61; (csq &＃61;&＃61; null ? "null" : csq);write(cs.subSequence(start, end).toString());return this;}/*** Appends the specified character to this output stream.**  An invocation of this method of the form out.append(c)* behaves in exactly the same way as the invocation** 
*     out.print(c) 
** &＃64;param  c*         The 16-bit character to append** &＃64;return  This output stream** &＃64;since  1.5*/public PrintStream append(char c) {print(c);return this;}}