[读者文库]Java Examples in a Nutshell, 3rd Edition

1. Testing the Rect Class
   
2. 
   
3. Example 2-2 is a standalone program named RectTest that puts the Rect class of Example 2-1 through its paces. Note the use of the new keyword and the Rect( ) constructor to create new Rect objects. The program uses the . operator to invoke methods of the Rect objects and to access their fields. The test program also relies implicitly on the toString( ) method of Rect when it uses the string concatenation operator (+) to create strings to be displayed to the user.
   
4. 
   
5. Example 2-2. RectTest.java
   
6. package je3.classes;
   
7. 
   
8. /** This class demonstrates how you might use the Rect class */
   
9. public class RectTest {
   
10.     public static void main(String[  ] args) {
    
11.         Rect r1 = new Rect(1, 1, 4, 4);    // Create Rect objects
    
12.         Rect r2 = new Rect(2, 3, 5, 6);
    
13.         Rect u = r1.union(r2);             // Invoke Rect methods
    
14.         Rect i = r2.intersection(r1);
    
15.         
    
16.         if (u.isInside(r2.x1, r2.y1))   // Use Rect fields and invoke a method
    
17.             System.out.println("(" + r2.x1 + "," + r2.y1 +
    
18.                                ") is inside the union");
    
19.         
    
20.         // These lines implicitly call the Rect.toString( ) method
    
21.         System.out.println(r1 + " union " + r2 + " = " + u);
    
22.         System.out.println(r1 + " intersect " + r2 + " = " + i);
    
23.     }
    
24. }

复制代码

1. A Rect Subclass
   
2. 
   
3. Example 2-3 is a simple subclass of the Rect class of Example 2-1. This DrawableRect class inherits the fields and methods of Rect and adds its own method, draw( ), that draws a rectangle using a specified java.awt.Graphics object. (We’ll see more of the Graphics object in Chapter 12.) DrawableRect also defines a constructor that simply uses the super keyword to pass its arguments up to the corresponding Rect constructor. Note the use of the extends keyword to indicate that Rect is the superclass of DrawableRect.
   
4. 
   
5. Example 2-3. DrawableRect.java
   
6. package je3.classes;
   
7. /**
   
8. * This is a subclass of Rect that allows itself to be drawn on a screen.
   
9. * It inherits all the fields and methods of Rect
   
10. * It relies on the java.awt.Graphics object to perform the drawing.
    
11. **/
    
12. public class DrawableRect extends Rect {
    
13.     /** The DrawableRect constructor just invokes the Rect( ) constructor */
    
14.     public DrawableRect(int x1, int y1, int x2, int y2) { super(x1,y1,x2,y2); }
    
15.    
    
16.     /** This is the new method defined by DrawableRect */
    
17.     public void draw(java.awt.Graphics g) {
    
18.         g.drawRect(x1, y1, (x2 - x1), (y2-y1));
    
19.     }
    
20. }

复制代码

1. Example 2-4. ColoredRect.java
   
2. package je3.classes;
   
3. import java.awt.*;
   
4. 
   
5. /**
   
6. * This class subclasses DrawableRect and adds colors to the rectangle it draws
   
7. **/
   
8. public class ColoredRect extends DrawableRect {
   
9.     // These are new fields defined by this class.
   
10.     // x1, y1, x2, and y2 are inherited from our super-superclass, Rect.
    
11.     protected Color border, fill;
    
12.    
    
13.     /**
    
14.      * This constructor uses super( ) to invoke the superclass constructor, and
    
15.      * also does some initialization of its own.
    
16.      **/
    
17.     public ColoredRect(int x1, int y1, int x2, int y2,
    
18.                        Color border, Color fill)
    
19.     {
    
20.         super(x1, y1, x2, y2);
    
21.         this.border = border;
    
22.         this.fill = fill;
    
23.     }
    
24.    
    
25.     /**
    
26.      * This method overrides the draw( ) method of our superclass so that it
    
27.      * can make use of the colors that have been specified.
    
28.      **/
    
29.     public void draw(Graphics g) {
    
30.         g.setColor(fill);
    
31.         g.fillRect(x1, y1, (x2-x1), (y2-y1));
    
32.         g.setColor(border);
    
33.         g.drawRect(x1, y1, (x2-x1), (y2-y1));
    
34.     }
    
35. }

复制代码

1. Example 2-5. ComplexNumber.java
   
2. package je3.classes;
   
3. 
   
4. /**
   
5. * This class represents complex numbers, and defines methods for performing
   
6. * arithmetic on complex numbers.
   
7. **/
   
8. public class ComplexNumber {
   
9.     // These are the instance variables.  Each ComplexNumber object holds
   
10.     // two double values, known as x and y.  They are private, so they are
    
11.     // not accessible from outside this class.  Instead, they are available
    
12.     // through the real( ) and imaginary( ) methods below.
    
13.     private double x, y;
    
14. 
    
15.     /** This is the constructor.  It initializes the x and y variables */
    
16.     public ComplexNumber(double real, double imaginary) {
    
17.         this.x = real;
    
18.         this.y = imaginary;
    
19.     }
    
20. 
    
21.     /**
    
22.      * An accessor method.  Returns the real part of the complex number.
    
23.      * Note that there is no setReal( ) method to set the real part.  This means
    
24.      * that the ComplexNumber class is "immutable".
    
25.      **/
    
26.     public double real( ) { return x; }
    
27.    
    
28.     /** An accessor method. Returns the imaginary part of the complex number */
    
29.     public double imaginary( ) { return y; }
    
30.    
    
31.     /** Compute the magnitude of a complex number */
    
32.     public double magnitude( ) { return Math.sqrt(x*x + y*y); }
    
33. 
    
34.     /**
    
35.      * This method converts a ComplexNumber to a string.  This is a method of
    
36.      * Object that we override so that complex numbers can be meaningfully
    
37.      * converted to strings, and so they can conveniently be printed out with
    
38.      * System.out.println( ) and related methods
    
39.      **/
    
40.     public String toString( ) { return "{" + x + "," + y + "}"; }
    
41.    
    
42.     /**
    
43.      * This is a static class method.  It takes two complex numbers, adds
    
44.      * them, and returns the result as a third number.  Because it is static,
    
45.      * there is no "current instance" or "this" object.  Use it like this:
    
46.      * ComplexNumber c = ComplexNumber.add(a, b);
    
47.      **/
    
48.     public static ComplexNumber add(ComplexNumber a, ComplexNumber b) {
    
49.         return new ComplexNumber(a.x + b.x, a.y + b.y);
    
50.     }
    
51. 
    
52.     /**
    
53.      * This is a non-static instance method by the same name.  It adds the
    
54.      * specified complex number to the current complex number.  Use it like
    
55.      * this:
    
56.      * ComplexNumber c = a.add(b);
    
57.      **/
    
58.     public ComplexNumber add(ComplexNumber a) {
    
59.         return new ComplexNumber(this.x + a.x, this.y+a.y);
    
60.     }
    
61. 
    
62.     /** A static class method to multiply complex numbers */
    
63.     public static ComplexNumber multiply(ComplexNumber a, ComplexNumber b) {
    
64.         return new ComplexNumber(a.x*b.x - a.y*b.y, a.x*b.y + a.y*b.x);
    
65.     }
    
66. 
    
67.     /** An instance method to multiply complex numbers */
    
68.     public ComplexNumber multiply(ComplexNumber a) {
    
69.         return new ComplexNumber(x*a.x - y*a.y, x*a.y + y*a.x);
    
70.     }
    
71. }

复制代码

1. Example 2-6. Averager.java
   
2. package je3.classes;
   
3. /**
   
4. * A class to compute the running average of numbers passed to it
   
5. **/
   
6. public class Averager {
   
7.     // Private fields to hold the current state.
   
8.     private int n = 0;
   
9.     private double sum = 0.0, sumOfSquares = 0.0;
   
10. 
    
11.     /**
    
12.      * This method adds a new datum into the average.
    
13.      **/
    
14.     public void addDatum(double x) {
    
15.         n++;
    
16.         sum += x;
    
17.         sumOfSquares += x * x;
    
18.     }
    
19.    
    
20.     /** This method returns the average of all numbers passed to addDatum( ) */
    
21.     public double getAverage( ) { return sum / n; }
    
22. 
    
23.     /** This method returns the standard deviation of the data */
    
24.     public double getStandardDeviation( ) {
    
25.           return Math.sqrt(((sumOfSquares - sum*sum/n)/n));
    
26.     }
    
27. 
    
28.     /** This method returns the number of numbers passed to addDatum( ) */
    
29.     public double getNum( ) { return n; }
    
30. 
    
31.     /** This method returns the sum of all numbers passed to addDatum( ) */
    
32.     public double getSum( ) { return sum; }
    
33. 
    
34.     /** This method returns the sum of the squares of all numbers. */
    
35.     public double getSumOfSquares( ) { return sumOfSquares; }
    
36. 
    
37.     /** This method resets the Averager object to begin from scratch */
    
38.     public void reset( ) { n = 0; sum = 0.0; sumOfSquares = 0.0; }
    
39. 
    
40.     /**
    
41.      * This nested class is a simple test program we can use to check that
    
42.      * our code works okay.
    
43.      **/
    
44.     public static class Test {
    
45.         public static void main(String args[  ]) {
    
46.             Averager a = new Averager( );
    
47.             for(int i = 1; i <= 100; i++) a.addDatum(i);
    
48.             System.out.println("Average: " + a.getAverage( ));
    
49.             System.out.println("Standard Deviation: " +
    
50.                                a.getStandardDeviation( ));
    
51.             System.out.println("N: " + a.getNum( ));
    
52.             System.out.println("Sum: " + a.getSum( ));
    
53.             System.out.println("Sum of squares: " + a.getSumOfSquares( ));
    
54.         }
    
55.     }
    
56. }

复制代码