data.html

java 基础的 一点东西,,可以看看

example. A more detailed explanation of the changes to the
method implementation follows the code. 

</FONT>

<PRE>
public void actionPerformed(
		ActionEvent event){
  Object source = event.getSource();
  if(source == button){
//Variable to display text read from file
    String s = null; 
    if(_clickMeMode){
      try{
//Code to write to file
        String text = textField.getText();
        byte b[] = text.getBytes();

        String outputFileName = 
		System.getProperty(&quot;user.home&quot;, 
	  File.separatorChar + &quot;home&quot; + 
	  File.separatorChar + &quot;monicap&quot;) + 
	  File.separatorChar + &quot;text.txt&quot;;
          File outputFile = new File(outputFileName);
          FileOutputStream out = new 
		FileOutputStream(outputFile);
          out.write(b);
          out.close();

//Code to read from file
        String inputFileName = 
		System.getProperty(&quot;user.home&quot;, 
	  File.separatorChar + &quot;home&quot; + 
	  File.separatorChar + &quot;monicap&quot;) + 
	  File.separatorChar + &quot;text.txt&quot;;
          File inputFile = new File(inputFileName);
          FileInputStream in = new 
		FileInputStream(inputFile);

        byte bt[] = new 
		byte[(int)inputFile.length()];
        in.read(bt);
        s = new String(bt);
        in.close();
       }catch(java.io.IOException e){
        System.out.println(&quot;Cannot access text.txt&quot;);
       }
//Clear text field
      textField.setText("");
//Display text read from file
      text.setText(&quot;Text retrieved from file:&quot;);
      textField.setText(s);
      button.setText(&quot;Click Again&quot;);
      _clickMeMode = false;
    } else {
//Save text to file
      text.setText(&quot;Text to save to file:&quot;);
      textField.setText(&quot;&quot;);
      button.setText(&quot;Click Me&quot;);
      _clickMeMode = true;
    }
  }
}
</PRE>

<FONT FACE="Verdana, Arial, Helvetica, sans-serif">

<P>
To write the end user text to a file, the text is retrieved from the
<CODE>textField</CODE> and converted to a byte array.

</FONT>

<PRE>
   String text = textField.getText();
   byte b[] = text.getBytes();
</PRE>

<FONT FACE="Verdana, Arial, Helvetica, sans-serif"> 

<P>
Next, a <CODE>File</CODE> object is created for the file to be
written to and used to create a <CODE>FileOutputStream</CODE>
object. 

</FONT>

<PRE>

      String outputFileName =
                System.getProperty(&quot;user.home&quot;,
        File.separatorChar + &quot;home&quot; +
        File.separatorChar + &quot;monicap&quot;) +
        File.separatorChar + &quot;text.txt&quot;;
        File outputFile = new File(outputFileName);
        FileOutputStream out = new
                FileOutputStream(outputFile);
</PRE>

<FONT FACE="Verdana, Arial, Helvetica, sans-serif">

Finally, the <CODE>FileOutputStream</CODE> object writes the byte
array to the <CODE>File</CODE> object and closes the output stream
when the operation completes.

</FONT>

<PRE>
   out.write(b);
   out.close();
</PRE>

<FONT FACE="Verdana, Arial, Helvetica, sans-serif">

The code to open a file for reading is similar.
To read text from a file, a <CODE>File</CODE> object is created
and used to create a <CODE>FileInputStream</CODE> object.

</FONT>

<PRE>
      String inputFileName =
                System.getProperty(&quot;user.home&quot;,
        File.separatorChar + &quot;home&quot; +
        File.separatorChar + &quot;monicap&quot;) +
        File.separatorChar + &quot;text.txt&quot;;
        File inputFile = new File(inputFileName);
        FileInputStream out = new
                FileInputStream(inputFile);
</PRE>

<FONT FACE="Verdana, Arial, Helvetica, sans-serif">

Next, a <CODE>byte</CODE> array is created the same size as
the file into which the file contents are read. 

</FONT>

<PRE>
   byte bt[] = new byte[(int)inputFile.length()];
   in.read(bt);
</PRE>

<FONT FACE="Verdana, Arial, Helvetica, sans-serif">

Finally, the byte array is used to construct a <CODE>String</CODE>
object, which is used to create the text for the <CODE>label</CODE>
component. The <CODE>FileInputStream</CODE> is closed when the
operation completes. 

</FONT>

<PRE>
   String s = new String(bt);
   label.setText(s);
   in.close();
</PRE>

<FONT FACE="Verdana, Arial, Helvetica, sans-serif">

<A NAME="prop"></A>
<H4>System Properties</H4>

The above code used a call to <CODE>System.getProperty</CODE>
to create the pathname to the file in the user's home
directory. The <CODE>System</CODE> class maintains a set of
properties that define attributes of the current working
environment. When the Java platform starts, system properties
are initialized with information about the runtime 
environment including the current user, Java platform
version, and the character used to separate components of a
file name (<CODE>File.separatorChar</CODE>).

<P>
The call to <CODE>System.getProperty</CODE> uses the
keyword <CODE>user.home</CODE> to get the user's home
directory and supplies the default value 
<CODE>File.separatorChar + &quot;home&quot; + File.separatorChar + &quot;monicap&quot;)</CODE>
in case no value is found for this key. 

<A NAME="sep"></A>
<H4>File.separatorChar</H4>

The above code used the <CODE>java.io.File.separatorChar</CODE>
variable to construct the directory pathname. This variable
is initialized to contain the file separator value stored
in the <CODE>file.separator</CODE> system property and gives
you a way to construct platform-independent pathnames.

<P>
For example, the pathname <CODE>/home/monicap/text.txt</CODE>
for Unix and <CODE>\home\monicap\text.txt</CODE> for Windows
are both represented as <CODE>File.separatorChar + &quot;home&quot;
+ File.separatorChar + &quot;monicap&quot; + File.separatorChar + &quot;text.txt&quot;	
</CODE> in a platform-independent construction.

<A NAME="excep"></A>
<H3>Exception Handling</H3>

An exception is a class that descends from either
<CODE>java.lang.Exception</CODE> or
<CODE>java.lang.RuntimeException</CODE> that defines mild
error conditions your program might encounter. Rather
than letting the program terminate, you can write code to 
handle exceptions and continue program execution.

<P>
<IMG SRC="./Art/exception.gif" WIDTH="187" HEIGHT="241" ALT="" ALIGN=LEFT>
The file input and output code in the <CODE>actionPerformed</CODE>
method is enclosed in a <CODE>try</CODE> and <CODE>catch</CODE> block
to handle the <CODE>java.lang.IOException</CODE> that might be
thrown by code within the block.

<P>
<CODE>java.lang.IOException</CODE> is what is called
a checked exception.  The Java platform requires that a method
catch or specify all checked exceptions that can be thrown within
the scope of a method.  

<P>
Checked exceptions descend from <CODE>java.lang.Throwable</CODE>.
If a checked exception is not either caught or specified, the
compiler throws an error. 

<P>
In the example, the <CODE>try</CODE> and <CODE>catch</CODE> block
catches and handles the <CODE>java.io.IOException</CODE> checked 
exception. If a method does not catch a checked exception, the method 
must specify that it can throw the exception because an exception that 
can be thrown by a method is really part of the method's public interface. 
Callers of the method must know about the exceptions that a method can 
throw so they can take appropriate actions.

<P>
However, the <CODE>actionPerformed</CODE> method already has
a public interface definition that cannot be changed to specify the
<CODE>java.io.IOException</CODE>, so in this case, the only
thing to do is catch and handle the checked exception. Methods you 
define yourself can either specify exceptions or catch and handle
them, while methods you override must catch and handle checked
exceptions. Here is an example of a user-defined method that
specifies an exception so callers of this method can catch
and handle it:

</FONT>

<PRE>
  public int aComputationMethod(int number1, 
	int number2)
	throws IllegalValueException{
     //Body of method
   } 
</PRE>

<FONT FACE="Verdana, Arial, Helvetica, sans-serif"> 

<BLOCKQUOTE>
<HR>
<STRONG>Note:</STRONG> 
You can find more information on this topic in
<A HREF="http://java.sun.com/docs/books/tutorial/">The
Java Tutorial</A> trail on 
<A HREF="http://java.sun.com/docs/books/tutorial/essential/exceptions">Handling
Errors with Exceptions</A>.
<HR>
</BLOCKQUOTE>

<P>
When you catch exceptions in your code, you should handle them
in a way that is friendly to your end users. The exception
and error classes have a <CODE>toString</CODE> method to print system 
error text and a <CODE>printStackTrace</CODE> method to print 
a stack trace, which can be very useful for debugging your application 
during development. But, it is probably better 
to deploy the program with a more user-friendly approach to handling 
errors. 

<P>
You can provide your own application-specific error text
to print to the command line, or display a dialog box with
application-specific error text. Using application-specific
error text that you provide will also make it much easier to
internationalize the application later on because you will
have access to the text.

<P>
For the example programs in this lesson, the error message
for the file input and output is handled with application-specific 
error text that prints at the command line as follows:

<PRE>
//Do this during development
  }catch(java.io.IOException e){
   System.out.println(e.toString());
   System.out.println(e.printStackTrace());
  }

//But deploy it like this
  }catch(java.io.IOException e){
   System.out.println(&quot;Cannot access text.txt&quot;);
  }
</PRE>

If you want to make your code even more user friendly, you
could separate the write and read operations and
provide two <CODE>try</CODE> and <CODE>catch</CODE>
blocks.  The error text for the read operation could
be <EM>Cannot read text.txt</EM>, and the error text for
the write operation could be <EM>Cannot write text.txt</EM>.

<P>
As an exercise, change the code to handle the read
and write operations separately. Give it a try before
peeking at the <A HREF="./Code/FileIOError.java">solution</A>. 
 
<A NAME="applet"></A>
<H3>File Access by Applets</H3>

The file access code for the 
<A HREF="./Code/FileIOAppl.java">FileIOAppl.java</A>
code is equivalent to the FileIO.java application, but shows
how to use the APIs for handling data in character streams instead 
of byte streams.  You can use either approach in applets or applications. 
In this lesson, the choice to handle data in bytes streams in the application 
and in character streams in the applet is purely random. In real-life
programs, you would base the decision on your specific application
requirements.

<P>
The changes to instance variables and the <CODE>constructor</CODE> are
identical to the application code, and the changes to the
<CODE>actionPerformed</CODE> method are nearly identical with
these two exceptions: 

<UL>
<LI><FONT FACE="Verdana, Arial, Helvetica, sans-serif">
<STRONG>Writing:</STRONG> When the <CODE>textField</CODE> text is 
retrieved, it is passed directly to the <CODE>out.write</CODE> call.</FONT>
<P>
<LI><FONT FACE="Verdana, Arial, Helvetica, sans-serif">
<STRONG>Reading:</STRONG> A character array is created
to store the data read in from the input stream. </FONT>
</UL>

</FONT>

<PRE>
public void actionPerformed(ActionEvent event){
  Object source = event.getSource();
  if(source == button){
//Variable to display text read from file
    String s = null;
    if(_clickMeMode){
      try{
//Code to write to file
        String text = textField.getText();
        String outputFileName =
                System.getProperty(&quot;user.home&quot;,
          File.separatorChar + &quot;home&quot; +
          File.separatorChar + &quot;monicap&quot;) +
          File.separatorChar + &quot;text.txt&quot;;
          File outputFile = new File(outputFileName);
          FileWriter out = new
                FileWriter(outputFile);
        out.write(text);
        out.close();
//Code to read from file
        String inputFileName = 
                System.getProperty(&quot;user.home&quot;,
          File.separatorChar + &quot;home&quot; +
          File.separatorChar + &quot;monicap&quot;) +
          File.separatorChar + &quot;text.txt&quot;;
        File inputFile = new File(inputFileName);
        FileReader in = new FileReader(inputFile);
        char c[] = new 
	char[(char)inputFile.length()];
        in.read(c);
        s = new String(c);
        in.close();
      }catch(java.io.IOException e){
       System.out.println(&quot;Cannot access text.txt&quot;);
      }
//Clear text field
      textField.setText("");
//Display text read from file
      text.setText(&quot;Text retrieved from file:&quot;);
      textField.setText(s);
      button.setText(&quot;Click Again&quot;);
      _clickMeMode = false;
    } else {
//Save text to file
      text.setText(&quot;Text to save to file:&quot;);
      textField.setText(&quot;&quot;);
      button.setText(&quot;Click Me&quot;);
      _clickMeMode = true;
    }