<b>Java面向对象编程实例详解</b>[Java编程]

Java是一种面向对象的语言,是实现面向对象编程的强盛工具.但如安在编程中实际应用并施展其最大效能呢?本文通过一个实际Java程序的开辟历程,具体阐明了若何利用面向对象实现Java编程.

我们要实现的Java利用程序是:当用户输入一个球体的半径,程序将显示该球体的体积与表面积.在您阅读下文从前,请您自己考虑一分钟,您将若何计划该Java利用程序.

1、普通实现办法

我相信大大都程序员要实现上述功效的程序,非常疾速地、自大地将采取下面的实现代码:

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 <code>null</code> 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 s = readWord();
if (s != null)
return Double.parseDouble(s);
// in Java 1, use: return Double.valueOf(s).doubleValue();
else
return 0.0;
}
}

　　以上是“<b>Java面向对象编程实例详解</b>[Java编程]”的内容，如果你对以上该文章内容感兴趣，你可以看看七道奇为您推荐以下文章：