正文  软件开发 > java编程技术 >

Java面向对象编程实例详解

Java是一种面向对象的语言,是实现面向对象编程的强大工具。但如何在编程中实际运用并发挥其最大效能呢?本文通过一个实际Java程序的开发过程,详细说明了如何使用面向对象实现Java编程。         我们 ...

Java是一种面向对象的语言,是实现面向对象编程的强大工具。但如何在编程中实际运用并发挥其最大效能呢?本文通过一个实际Java程序的开发过程,详细说明了如何使用面向对象实现Java编程。 
   
  
  
  我们要实现的Java应用程序是:当用户输入一个球体的半径,程序将显示该球体的体积与表面积。在您阅读下文以前,请您自己思考一分钟,您将如何设计该Java应用程序。
  
  
  
  一、普通实现方法
  我相信大多数程序员要实现上述功能的程序,非常迅速地、自信地将采用下面的实现代码:
  
  class Sphere
  
  {
  
  public static void main(String[] args)
  
  {
  
  EasyReader console = new EasyReader();
  
  System.out.print("Enter the radius: ");
  
  double radius = console.readDouble();
  
  System.out.println("Radius = " + radius);
  
  double volume = 4.0 / 3.0 * Math.PI * radius * radius * radius;
  
  System.out.println("Volume = " + volume);
  
  double surfArea = 4.0 * Math.PI * radius * radius;
  
  System.out.println("Surface area = " + surfArea);
  
  }
  
  }
  
  EasyReader类代码如下:
  
  import java.io.*;
  
  public class EasyReader
  
  {
  
  protected String myFileName;
  
  protected BufferedReader myInFile;
  
  protected int myErrorFlags = 0;
  
  protected static final int OPENERROR = 0x0001;
  
  protected static final int CLOSEERROR = 0x0002;
  
  protected static final int READERROR = 0x0004;
  
  protected static final int EOF = 0x0100;
  
  
  
  /**
  
  * Constructor. Prepares console (System.in) for reading
  
  */
  
  public EasyReader()
  
  {
  
  myFileName = null;
  
  myErrorFlags = 0;
  
  myInFile = new BufferedReader(
  
  new InputStreamReader(System.in), 128);
  
  }
  
  
  
  /**
  
  * Constructor. opens a file for reading
  
  * @param fileName the name or pathname of the file
  
  */
  
  public EasyReader(String fileName)
  
  {
  
  myFileName = fileName;
  
  myErrorFlags = 0;
  
  try
  
  {
  
  myInFile = new BufferedReader(new FileReader(fileName), 1024);
  
  }
  
  catch (FileNotFoundException e)
  
  {
  
  myErrorFlags |= OPENERROR;
  
  myFileName = null;
  
  }
  
  }
  
  
  
  /**
  
  * Closes the file
  
  */
  
  public void close()
  
  {
  
  if (myFileName == null)
  
  return;
  
  try
  
  {
  
  myInFile.close();
  
  }
  
  catch (IOException e)
  
  {
  
  System.err.println("Error closing " + myFileName + "\n");
  
  myErrorFlags |= CLOSEERROR;
  
  }
  
  }
  
  
  
  /**
  
  * Checks the status of the file
  
  * @return true if en error occurred opening or reading the file,
  
  * false otherwise
  
  */
  
  public boolean bad()
  
  {
  
  return myErrorFlags != 0;
  
  }
  
  
  
  /**
  
  * Checks the EOF status of the file
  
  * @return true if EOF was encountered in the previous read
  
  * operation, false otherwise
  
  */
  
  public boolean eof()
  
  {
  
  return (myErrorFlags & EOF) != 0;
  
  }
  
  
  
  private boolean ready() throws IOException
  
  {
  
  return myFileName == null || myInFile.ready();
  
  }
  
  
  
  /**
  
  * Reads the next character from a file (any character including
  
  * a space or a newline character).
  
  * @return character read or null character
  
  * (Unicode 0) if trying to read beyond the EOF
  
  */
  
  public char readChar()
  
  {
  
  char ch = '\u0000';
  
  
  
  try
  
  {
  
  if (ready())
  
  {
  
  ch = (char)myInFile.read();
  
  }
  
  }
  
  catch (IOException e)
  
  {
  
  if (myFileName != null)
  
  System.err.println("Error reading " + myFileName + "\n");
  
  myErrorFlags |= READERROR;
  
  }
  
  
  
  if (ch == '\u0000')
  
  myErrorFlags |= EOF;
  
  
  
  return ch;
  
  }
  
  
  
  /**
  
  * Reads from the current position in the file up to and including
  
  * the next newline character. The newline character is thrown away
  
  * @return the read string (excluding the newline character) or
  
  * null if trying to read beyond the EOF
  
  */
  
  public String readLine()
  
  {
  
  String s = null;
  
  
  
  try
  
  {
  
  s = myInFile.readLine();
  
  }
  
  catch (IOException e)
  
  {
  
  if (myFileName != null)
  
  System.err.println("Error reading " + myFileName + "\n");
  
  myErrorFlags |= READERROR;
  
  }
  
  
  
  if (s == null)
  
  myErrorFlags |= EOF;
  
  return s;
  
  }
  
  
  
  /**
  
  * Skips whitespace and reads the next word (a string of consecutive
  
  * non-whitespace characters (up to but excluding the next space,
  
  * newline, etc.)
  
  * @return the read string or null if trying to read beyond the EOF
  
  */
  
  public String readWord()
  
  {
  
  StringBuffer buffer = new StringBuffer(128);
  
  char ch = ' ';
  
  int count = 0;
  
  String s = null;
  
  
  
  try
  
  {
  
  while (ready() && Character.isWhitespace(ch))
  
  ch = (char)myInFile.read();
  
  while (ready() && !Character.isWhitespace(ch))
  
  {
  
  count++;
  
  buffer.append(ch);
  
  myInFile.mark(1);
  
  ch = (char)myInFile.read();
  
  };
  
  
  
  if (count > 0)
  
  {
  
  myInFile.reset();
  
  s = buffer.toString();
  
  }
  
  else
  
  {
  
  myErrorFlags |= EOF;
  
  }
  
  }
  
  
  
  catch (IOException e)
  
  {
  
  if (myFileName != null)
  
  System.err.println("Error reading " + myFileName + "\n");
  
  myErrorFlags |= READERROR;
  
  }
  
  
  
  return s;
  
  }
  
  
  
  /**
  
  * Reads the next integer (without validating its format)
  
  * @return the integer read or 0 if trying to read beyond the EOF
  
  */
  
  public int readInt()
  
  {
  
  String s = readWord();
  
  if (s != null)
  
  return Integer.parseInt(s);
  
  else
  
  return 0;
  
  }
  
  
  
  /**
  
  * Reads the next double (without validating its format)
  
  * @return the number read or 0 if trying to read beyond the EOF
  
  */
  
  public double readDouble()
  
  {
  
  String