Java Example to Demonstrate the use of Package.

Put both the Following Examples classes in a package called Measures.
Define a class to represent a weight in tons, kilograms, and grams
Define a class to represent a length measured in meters, centimeters, and millimeters

Import this package into a program that calculates and displays the total weight of the following:
200 carpets—size: 4 meters by 2 meters 9 centimeters, that weigh 1.25 kilograms per square meter;
and 60 carpets—size: 3 meters 57 centimeters by 5 meters, that weigh 1.05 kilograms per square meter.

Make sure that the source and class files for mcmLength and tkgWeight Are not in the same directory as this file. Otherwise those classes will beused rather than the ones in the Measures package

To compile this program the compiler needs to know where the Measures packages is. If the current directory contains Carpets.java and Measures is a subdirectory of this, you can compile Carpets by using the -classpath option like this:

javac -classpath . Carpets.java

If Measures is not a subdirectory of the current directory, you just need to add the path to the directory that contains Measures to -classpath. Note that you still need the period in the classpath, otherwise the compiler will not be able to find Carpets.java.

import Measures.tkgWeight;
import Measures.mcmLength;

public class Carpets {
  public static void main(String args[]) {
    mcmLength[] carpetLengths = { new mcmLength(4,0,0), new mcmLength(3,57,0) };
    mcmLength[] carpetWidths = { new mcmLength(2,9,0), new mcmLength(5,0,0) };
    double[] carpetWtPerSqM = { 1.25, 1.05 };                          // Weight per sq m of carpets
    int[] carpetCounts = { 200, 60 };


    tkgWeight carpetWeight = null;                                    // Store for reference to weight of a carpet
    double carpetArea = 0.0;                                          // Store for area of a carpet


    for(int i = 0 ; i < carpetLengths.length ; ++i) {
      // Since we want areas in square meters it is easiest to calculate them directly
      carpetArea = carpetLengths[i].toMeters()*carpetWidths[i].toMeters();

      carpetWeight = new tkgWeight(carpetWtPerSqM[i]*carpetArea);

      System.out.println("\nCarpet " + (i + 1) + ": Size = " + carpetLengths[i] + " by "+ carpetWidths[i]);
      System.out.println("        " + "  Weight per sq. m. = " + carpetWtPerSqM[i]);
      System.out.println("        " + "  Area = " + carpetArea + " sq. m.");
      System.out.println("        " + "  Weight = " + carpetWeight);

      System.out.println("        " + "  Weight of " + carpetCounts[i] + " carpets = " + carpetWeight.multiply(carpetCounts[i]));

    }
  }
}

[ Read More ]

Java Exampls to outputting the two values stored as integers

Write a console program to declare and initialize a double variable with some value such as 1234.5678. Retrieve the integral part of the value and store it in a variable of type long, and retrieve the first four digits of the fractional part and store them in an integer of type short.Display the value of the double variable by outputting the two values stored as integers.

public class DisplayParts {
  public static void main(String args[]) {
    // Initialize a double variable to some value (1234.5678):
    double myNumber = 1234.5678;
    long integPart = 0;
    short fracPart = 0;
    int decPlaces = 4;

    // Find the integer part:
    integPart = (long)myNumber;

    // Find the number of Decimal places:
    fracPart = (short)((myNumber - integPart)*Math.pow(10, decPlaces));
/*
     This works by subtracting the integral part from the original leaving
     just the fractional part, and then multiplying this by 10 to the power
     of the number of decimal places required. This result in a double value
     that has an integral part with decPlaces decimal digits.
     Finally this result is cast to type short to get the digits
     of the fractional part.

     This is OK as far as it goes. If decPlaces had a value that was greater
     that 4 this would not be satisfactory. Type short just won't accommodate
     enough digits. The exercise said to use type short just because that fits
     the result in this case. In general though it would be better to make fracPart
     type long.

     A further thought is that this approach just chops off the digits beyond the
     number of decimal places required in the fractional part. It would be better
     to round to the nearest digit. This is equivalent to adding 0.5 to the double
     value after we have used the pow() method to multiply by 10 to the appropriate
     power. We could do this explicitly like this:

      fracPart = (short)(0.5+(myNumber-integPart)*Math.pow(10,decPlaces));

      Alternatively we could use the round() method that is defined in the Math
      class, like this:

      fracPart = (short)Math.round((myNumber-integPart)*Math.pow(10,decPlaces));

      This does exactly the same as the previous statement.
*/

    System.out.println("The integral part of " + myNumber + " is " + integPart);
    System.out.println("The fractional part to " + decPlaces + " decimal places is " + fracPart);

/*
     There is also something wrong with this approach for numbers in general. Can
     you see what it is?

     If the fractional part starts with a zero digit, 123.0456 say, the result will
     be incorrect. The integral part will be 123, which is fine, but the fractional
     part will be 456, so the output for the fractional will be 456, which is not so fine!
     We want 0456, but to get that you need a decision process that will allow you to insert
     leading zeroes in the fractional part when necessary. You will learn how to make
     such decisions later in the book.
*/
  }
}

[ Read More ]