To demonstrate the difference between public and private

Here is a Java Program demonstrates the difference between public and private.

class Test {
  int a; // default access
  public int b; // public access
  private int c; // private access

  // methods to access c
  void setc(int i) { // set c's value
    c = i;
  }
  int getc() { // get c's value
    return c;
  }
}

Here is a Main Class to run above Class

class AccessTest {
  public static void main(String args[]) {
    Test ob = new Test();

    // These are OK, a and b may be accessed directly
    ob.a = 10;
    ob.b = 20;

    // This is not OK and will cause an error
//  ob.c = 100; // Error!

    // You must access c through its methods
    ob.setc(100); // OK
   
    System.out.println("a, b, and c: " + ob.a + " " +
                       ob.b + " " + ob.getc());
  }
}

Output of Above Java Program
a, b, and c: 10 20 100

[ Read More ]

To Demonstrate the Simple Recursion

Here is a Java Program to Demonstrate the Simple Recursion

class RecTest {
  int values[];

  RecTest(int i) {
    values = new int[i];
  }

  // display arrary -- recursively
  void printArray(int i) {
    if(i==0) return;
    else printArray(i-1);
    System.out.println("[" + (i-1) + "] " + values[i-1]);
  }
}

Here is a Main Class to Run above Class

class Recursion {
  public static void main(String args[]) {
    RecTest ob = new RecTest(10);
    int i;

    for(i=0; i<10; i++) ob.values[i] = i;
    
    ob.printArray(10);
  }
}

Output of Above Java Program
[0] 0
[1] 1
[2] 2
[3] 3
[4] 4
[5] 5
[6] 6
[7] 7
[8] 8
[9] 9

[ Read More ]

To find the Factorial of a number Using Recursion

Here is a Java Program to find the Factorial of a number Using Recursion

class Factorial {
  // this is a recusive function
  int fact(int n) {
    int result;

    if(n==1) return 1;
    result = fact(n-1) * n;
    return result;
  }
}

Here is a Main Class to Run the Above Java Class

class Recursion {
  public static void main(String args[]) {
    Factorial f = new Factorial();

    System.out.println("Factorial of 3 is " + f.fact(3));
    System.out.println("Factorial of 4 is " + f.fact(4));
    System.out.println("Factorial of 5 is " + f.fact(5));
  }
}

Output of Above Java Program
Factorial of 3 is 6
Factorial of 4 is 24
Factorial of 5 is 120

[ Read More ]

Java Program to Demonstrate the Passed by Value

Here is a Java Program to Demonstrate the Passed by Value

class Test {
  void meth(int i, int j) {
    i *= 2;
    j /= 2;
  }
}

This is a Main Class to run Above Java Class.

class CallByValue {
  public static void main(String args[]) {
    Test ob = new Test();
    int a = 15, b = 20;
    
    System.out.println("a and b before call: " +
                       a + " " + b);

    ob.meth(a, b); 

    System.out.println("a and b after call: " +
                       a + " " + b);
  }
}

Output of Above Java Program
a and b before call: 15 20
a and b after call: 15 20

[ Read More ]

To Demonstrate that Objects may be passed to methods

Here is a Java Program to Demonstrate that Objects may be passed to methods.

class Test {
  int a, b;

  Test(int i, int j) {
    a = i;
    b = j;
  }

  // return true if o is equal to the invoking object
  boolean equals(Test o) {
    if(o.a == a && o.b == b) return true;
    else return false;
  }
}

Here is a Java Program to Execute Above Java Class

class PassOb {
  public static void main(String args[]) {
    Test ob1 = new Test(100, 22);
    Test ob2 = new Test(100, 22);
    Test ob3 = new Test(-1, -1);
    
    System.out.println("ob1 == ob2: " + ob1.equals(ob2));

    System.out.println("ob1 == ob3: " + ob1.equals(ob3));
  }
}

Output of Above Java Program
ob1 == ob2: true
ob1 == ob3: false

[ Read More ]

To Automatic type conversions apply to overloading

Here is a Java Program to Automatic type conversions apply to overloading.

class OverloadDemo {
  void test() {
    System.out.println("No parameters");
  }

  // Overload test for two integer parameters.
  void test(int a, int b) {
    System.out.println("a and b: " + a + " " + b);
  }

  // overload test for a double parameter and return type
  void test(double a) {
    System.out.println("Inside test(double) a: " + a);
  }
}

Here is a Main Program to Run above Java Class

class Overload {
  public static void main(String args[]) {
    OverloadDemo ob = new OverloadDemo();
    int i = 88;

    ob.test(); 
    ob.test(10, 20);

    ob.test(i); // this will invoke test(double)
    ob.test(123.2); // this will invoke test(double)
  }
}

Output of Above Java Program
No parameters
a and b: 10 20
Inside test(double) a: 88.0
Inside test(double) a: 123.2

[ Read More ]

Java Class to Calculate the Volume of Box

Here is a Java Class to Calculate the Volume of Box.

class Box {
  double width;
  double height;
  double depth;

  // This is the constructor for Box.
  Box(double w, double h, double d) {
    width = w;
    height = h;
    depth = d;
  }

  // compute and return volume
  double volume() {
    return width * height * depth;
  }
}

This is a  Main Class to run the Above Java Class

class BoxDemo {
  public static void main(String args[]) {
    // declare, allocate, and initialize Box objects
    Box mybox1 = new Box(10, 20, 15);
    Box mybox2 = new Box(3, 6, 9);

    double vol;

    // get volume of first box
    vol = mybox1.volume();
    System.out.println("Volume is " + vol);

    // get volume of second box
    vol = mybox2.volume();
    System.out.println("Volume is " + vol);
  }
}

Output of Above Java Program
Volume is 3000.0
Volume is 162.0

[ Read More ]

Demonstrate the operation of Stack implementation

Define a generic Stack<> type with a method push() that adds the object that is passed as an argument to the top of the stack, and with a method pop() that removes and returns the object that is currently at the top of the stack. The pop() method should return null when the stack is empty. Demonstrate the operation of your Stack<> implementation by storing and retrieving 10 strings and 10 Double objects in stacks of a suitable type.

 A stack is a container that stores objects in a manner indicated by its name in a vertical stack where only the object at the top of the stack is accessible. It works rather like a sprung stack of plates in a cafeteria. Only the top plate is at counter level and, therefore, is the only one you can access. When you add a plate to the stack, the existing plates are pushed down so the new plate is now the one that you can access.

public class Stack<T> {
  public Stack() {
    items = new Object[initialCapacity];
  }

  // Push an item onto the stack
  public void push(T item) {
    if(itemCount==items.length) {
      Object[] newItems = new Object[items.length + increment];
      for(int i = 0 ; i < items.length ; ++i) {
        newItems[i] = items[i];
      }
      items = newItems;
    }
    items[itemCount++] = item;
  }

  // Pop an item off the top of the stack
  @SuppressWarnings("unchecked")
  public T pop() {
    if(itemCount == 0) {
      return null;
    }
    // Note: the annotation ensures this cast to type T will not result
    // in a warning from the compiler.
    T item = (T)items[--itemCount];
    items[itemCount] = null;                                           // Erase the object from the stack
    return item;
  }

  // Test for empty stack
  public boolean isEmpty() {
    return itemCount == 0;
  }

  // You cannot define an array of a parametric type T.
  // To store items in the stack of an arbitrary you can use type Object[]
  private Object[] items;                                              // Array to store items in the stack
  private int itemCount;                                               // Number of items in the stack

  private final static int initialCapacity = 10;                       // Initial stack capacity
  private final static int increment = 5;                              // Capacity increment when full
}

This is main Class to Test Above Java Class "Stack".

public class TryStack {
  public static void main(String[] args) {
    // Values to be stored in stack and then retrieved
    double[] values = { 1.0, 1.4142 , 1.732 , 2.0, 2.236, 2.449, 2.646, 2.828, 3.0, 3.162 };

    Stack<Double> data = new Stack<Double>();

    // Store the values on the stack
    System.out.println("Data pushed onto the stack in sequence is:");
    for(double v : values) {
      System.out.println(v);
      data.push(v);
    }

    double back = 0;
    System.out.println("\nData retrieved from the stack in sequence is:");
    while(!data.isEmpty()) {
      System.out.println(data.pop());
    }

    System.out.println("The stack should now be empty. Popping an item produces: " + data.pop());
  }
}

Output of Above Java Program
Data pushed onto the stack in sequence is:
1.0
1.4142
1.732
2.0
2.236
2.449
2.646
2.828
3.0
3.162

Data retrieved from the stack in sequence is:
3.162
3.0
2.828
2.646
2.449
2.236
2.0
1.732
1.4142
1.0
The stack should now be empty. Popping an item produces: null

[ Read More ]

Create a Class defining an Object that Parses Each line of Input

Create a class defining an object that parses each line of input from the keyboard that contains items separated by an arbitrary delimiter (for example, a colon, or a comma, or a forward slash, and so on) and return the items as an array of type String[]. For example, the input might be

1/one/2/two

The output would be returned as an array of type String[] containing "1", "one", "2", "two".

import java.io.StreamTokenizer;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class ParseInput {
  private StreamTokenizer tokenizer;
  private char separator;

  // Constructor requires the separator character as the argument
  public ParseInput(char separator){
    this.separator = separator;
    tokenizer = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    setTokenizerState();
  }

  // Sets the tokenizer to accept anyhing except the separator and end-of-line as
  // part of a word
  private void setTokenizerState() {
    tokenizer.resetSyntax();
    tokenizer.wordChars('\u0000', (char)(separator - 1));                 // Everything is a word character
    tokenizer.wordChars((char)(separator + 1), '\u00ff');                 // except for the separator
    tokenizer.whitespaceChars('\n', '\n');                                // Make end-of-line whitespace(and therefore a word delimiter)
    tokenizer.whitespaceChars(separator, separator);                      // Delimiter passed to constructor seaparates words
    tokenizer.eolIsSignificant(true);                                     // End-of-line to be reported as TT_EOL

  }

  // Read tokens from the input
  public String[] readTokens() {
    int type = 0;                                                         // Store the value returned by nextToken()
    int strCount = 5;                                                     // String capacity increment
    String[] tokens = new String[strCount];                               // Will store the tokens that we find
    int nTokens = 0;                                                      // Number of tokens stored
    try {
      while((type = tokenizer.nextToken()) != StreamTokenizer.TT_EOL) {   // As long as we don'y have EOL
        // Verify we have space in the tokens array
        if(nTokens == tokens.length) {
          String[] newTokens = new String[tokens.length+strCount];        // tokens array is full so create a larger array

          // Copy old array contents to new array
          for(int i = 0 ; i < nTokens ; ++i) {
            newTokens[i] = tokens[i];
          }
          tokens = newTokens;                                             // Replace old array by new array
        }
        if(type == StreamTokenizer.TT_WORD) {                             // Check for a word
          tokens[nTokens++] = tokenizer.sval;                             // and save it in the vector
        } else {
          assert false;                                                   // We only expect words
        }

      }
      // Store tokens in array of exactly the right size
      if(nTokens < tokens.length) {
        String[] newTokens = new String[nTokens];
        // Copy old array contents to new array
        for(int i = 0 ; i < nTokens ; ++i) {
          newTokens[i] = tokens[i];
        }
        tokens = newTokens;                                               // Replace old array by new array
      }
    } catch(IOException e) {
      e.printStackTrace();
      System.exit(1);
    }

    return tokens;
  }

  // Convenience method to change the separator
  public void setSeparator(char separator) {
    this.separator = separator;
    setTokenizerState();
  }
}

This is the main Class to Test Above Java Class ' ParseInput '.

public class TestParseInput {
  public static void main(String[] args) {
    char separator = ',';
    ParseInput tokenizer = new ParseInput(separator);
    parseInputLine(tokenizer, separator);

    // Try a different separator
    separator = '/';
    tokenizer.setSeparator(separator);
    parseInputLine(tokenizer, separator);
  }

  // Reusable parse input operation
  static void parseInputLine(ParseInput tokenizer, char separator) {
    System.out.println("\nEnter items separated by " + separator + ":");
    String[] inputs = tokenizer.readTokens();

    if(inputs.length != 0) {
      System.out.println("The items that you entered are:");
      for( String input : inputs) {
        System.out.print("  " + input);
      }
    }
  }
}

Output of Above Java Program
Enter items separated by ,:
java, programs, and, examples, blog
The items that you entered are:
java programs and examples blog
Enter items separated by /:
java/programs/and/example/blog
The items that you entered are:
java programs and example blog

[ Read More ]

A Java Program that Calls a Method that Throws an Exception of type ArithmeticException

Write a program that calls a method that throws an exception of type ArithmeticException at a random iteration in a for loop. Catch the exception in the method and pass the iteration count when the exception occurred to the calling method by using an object of an exception class you define.

public class IteratedArithmeticException extends Throwable {

  // Default Constructor:
  public IteratedArithmeticException(){}

  // Standard constructor:
  public IteratedArithmeticException(String s, Throwable cause) {
    super(s, cause);                                                   // Call the base constructor.
  }

  public IteratedArithmeticException(int iteration, Throwable cause) {
    super(cause);                                                      // Call the base constructor.

    this.iteration = iteration;                                        // Set the iteration number.

  }

  public int getIteration() {                                          // Get the array index value for the error.
    return iteration;                                                  // Return the iteration number.
  }

  // The default value of -1 can be used to check whether an iteration number was stored
  private int iteration = -1;                                          // Iteration number at which exception occurred.
}

This is the Main to Test the Above Java  IteratedArithmeticException Class which Extends Throwable class. 

public class TestIterated {
  public static void main(String args[]) {
    try {
      loopy();                                                         // Call the method that will throw the exception.
    } catch(IteratedArithmeticException e) {
      System.out.println("Originating exception was: " + e.getCause());
      int iteration = e.getIteration();
      if(iteration < 0) {
      System.out.println("Iteration count not recorded");
      } else {
        System.out.println("Iteration count when exception occurred: " + iteration);
      }
    }
  }

  // This method throws an exception - eventually:
  static void loopy() throws IteratedArithmeticException {
    int iteration = 0;                                                 // Iteration counter.
    int result = 0;                                                    // Stores a result.
    int divisor = 0;                                                   // Random divisor.

    // Loop will continue until an exception is thrown:
    for(iteration = 0 ; ; ++iteration)
      try {
        divisor = (int)(100*Math.random());                            // Generate a random divisor.
        result = 1000/divisor;                                         // If we hit zero - bingo!
      } catch(ArithmeticException e) {
        throw new IteratedArithmeticException(iteration, e);
      }
  }
}

Output of Above Java Program
Originating exception was: java.lang.ArithmeticException: / by zero
Iteration count when exception occurred: 18

[ Read More ]

A Java Example to Create your own Exception.

Add an exception class to the last example that differentiates between the index-out-of-bounds error possibilities, rethrows an appropriate object of this exception class in divide(), and handles the exception in main().

This is an Example to define your own Exception we will use this Class in Main Class to Catch Divided by Zero Error.

public class ZeroDivideException extends Exception {
  private int index = -1;                                              // Index of array element causing error

  // Default Constructor
  public ZeroDivideException(){ }

  // Constructor that can be chained
  public ZeroDivideException(String s, Throwable cause) {
    super(s, cause);                                                   // Call the base constructor
  }

  // Contructor recording an index value & can be chained
  public ZeroDivideException(int index, Throwable cause) {
    super(cause);                                                      // Call the base constructor
    this.index = index;                                                // Set the index value
  }

  // Get the array index value for the error
  public int getIndex() {
    return index;                                                      // Return the index value
  }
}

This is an another Example to define your own Exception we will use this Class in Main Class to indentify  'IndexOutOfBounds'  Exception.

public class IdentifyIndexOutOfBoundsException extends Exception {
  // Default Constructor
  public IdentifyIndexOutOfBoundsException(){ }

  // Constructor that can be chained
  public IdentifyIndexOutOfBoundsException(String s, Throwable cause) {
    super(s, cause);                                                   // Call the base constructor
  }

  // Contructor recording an index value & can be chained
  public IdentifyIndexOutOfBoundsException(int index, Throwable cause) {
    super(cause);                                                      // Call the base constructor
    this.index = index;                                                // Set the index value
    gotIndex = true;                                                   // Set index flag
  }

  // Text for when an index value is available
  boolean hasIndex() {
    return gotIndex;
  }
  // Get the array index value for the error
  public int getIndex() {
    return index;                                                      // Return the index value
  }

  private boolean gotIndex = false;                                    // True indicates an index value is available
  private int index = 0;                                               // In index in error
}

This is the main Class to Test Above Classese

public class TryChainedExceptions {

  public static void main(String[] args) {
    int[] x = {10, 5, 0, 3, 12, 0, 6};                                 // Array of  integers
    System.out.print("Values: ");
    for(int xValue : x) {
      System.out.print("  " + xValue);
    }
    System.out.println();

    for(int i = 0 ; i < x.length ; ++i) {
      // This block only throws an exception if method divide() does
      try {
        System.out.println("First try block in main()entered");
        System.out.println("result = " + divide(x,i));
      } catch(ZeroDivideException e) {
        System.out.println("\nZeroDivideException caught in main()");
        int index = e.getIndex();                                      // Get the index for the error
        if(index > 0) {                                                // Verify it is valid and now fix the array
          x[index] = 1;                                                // ...set the divisor to 1...
          x[index + 1] = x[index - 1];                                 // ...and set the result
          e.printStackTrace();
          System.err.println("Zero divisor at x[" + index + "] corrected to " + x[index]);
        }
      } catch(ArithmeticException e) {
        System.out.println("Arithmetic exception caught in main()");
      } catch(IdentifyIndexOutOfBoundsException e) {
        System.out.println("Precise-index-out-of-bounds exception caught in main()");

        Throwable original = e.getCause();
        if(original != null) {
          System.out.println("Original exception was: " + original);
        }

        if(e.hasIndex()){
        System.out.println("Index value out of bounds is: " + e.getIndex());
        }
      }
      System.out.println("Outside first try block in main()");
    }
    System.out.print("Values: ");
    for(int xValue : x) {
      System.out.print("  " + xValue);
    }
    System.out.println();
  }

  public static int divide(int[] array, int index) throws ZeroDivideException, IdentifyIndexOutOfBoundsException {
    try {
      System.out.println("\nFirst try block in divide() entered");
      array[index] = array[index+2]/array[index + 1];
      System.out.println("Code at end of first try block in divide()");
      return array[index + 2];

    } catch(ArithmeticException e) {
      System.out.println("Arithmetic exception caught in divide()");
      ZeroDivideException zde = new ZeroDivideException(index + 1, e);
      System.out.println("Throwing ZeroDivideException");
      throw zde;                                                       // Throw the new exception
    } catch(ArrayIndexOutOfBoundsException e) {
      System.out.println("Index-out-of-bounds index exception caught in divide()");

      // We need to figure which of the three index values caused the problem
      int errorIndex = 0;                                              // Record the index value in error
      if(index < 0 || index >= array.length) {                         // Check for negative index or index greater than array length
        errorIndex = index;
      } else {
        // Two possibilities remain. The error index value was either
        // index+1 or index+2
        errorIndex = index + 1 > array.length ? index + 1 : index + 2;
      }
      throw new IdentifyIndexOutOfBoundsException(errorIndex, e);
    }
    // Because we now throw an exception in the previous catch block,
    // the following code annot be reached so it is commented out.
//    System.out.println("Executing code after try block in divide()");
//    return array[index];
  }
}

Output of Above Java Program
Values: 10 5 0 3 12 0 6
First try block in main()entered

First try block in divide() entered
Code at end of first try block in divide()
result = 0
Outside first try block in main()
First try block in main()entered

First try block in divide() entered
Arithmetic exception caught in divide()
Throwing ZeroDivideException

ZeroDivideException caught in main()
ZeroDivideException: java.lang.ArithmeticException: / by zero
at test.divide(test.java:109)
at test.main(test.java:67)
Caused by: java.lang.ArithmeticException: / by zero
at test.divide(test.java:103)
... 1 more
Zero divisor at x[2] corrected to 1
Outside first try block in main()
First try block in main()entered

First try block in divide() entered
Code at end of first try block in divide()
result = 12
Outside first try block in main()
First try block in main()entered

First try block in divide() entered
Code at end of first try block in divide()
result = 0
Outside first try block in main()
First try block in main()entered

First try block in divide() entered
Arithmetic exception caught in divide()
Throwing ZeroDivideException

ZeroDivideException caught in main()
ZeroDivideException: java.lang.ArithmeticException: / by zero
at test.divide(test.java:109)
at test.main(test.java:67)
Caused by: java.lang.ArithmeticException: / by zero
at test.divide(test.java:103)
... 1 more
Zero divisor at x[5] corrected to 1
Outside first try block in main()
First try block in main()entered

First try block in divide() entered
Index-out-of-bounds index exception caught in divide()
Precise-index-out-of-bounds exception caught in main()
Original exception was: java.lang.ArrayIndexOutOfBoundsException: 7
Index value out of bounds is: 7
Outside first try block in main()
First try block in main()entered

First try block in divide() entered
Index-out-of-bounds index exception caught in divide()
Precise-index-out-of-bounds exception caught in main()
Original exception was: java.lang.ArrayIndexOutOfBoundsException: 8

Index value out of bounds is: 8
Outside first try block in main()
Values: 0 5 2 0 12 1 12

[ Read More ]

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 ]

Define a class to represent a weight in tons, kilograms, and grams | Java Program

Define a class, tkgWeight, to represent a weight in tons, kilograms, and grams and Demonstrate this class by creating and combining some class objects.

public class tkgWeight {
  public static final int KG_PER_TON = 1000;
  public static final int GRAMS_PER_KG = 1000;
  public static final int GRAMS_PER_TON = GRAMS_PER_KG*KG_PER_TON;

  // private member variables
  private int tons = 0;
  private int kilograms = 0;
  private int grams = 0;

  // Constructors:
  public tkgWeight(double kg) {
    this((int)Math.round(kg*GRAMS_PER_KG));
  }

  public tkgWeight(int g) {
    tons = g/GRAMS_PER_TON;
    kilograms = (g - tons*GRAMS_PER_TON)/GRAMS_PER_KG;
    grams = g - tons*GRAMS_PER_TON - kilograms*GRAMS_PER_KG;
  }

  public tkgWeight(int t, int kg, int g) {
    this(t*GRAMS_PER_TON + kg*GRAMS_PER_KG + g);
  }

  public tkgWeight(){}

  // Methods
  public String toString()  {
    return Integer.toString(tons) + "t " + kilograms + "kg " + grams + "g";
  }

  public int toGrams() {
    return tons*GRAMS_PER_TON + kilograms*GRAMS_PER_KG + grams;
  }

  public double toKilograms() {
    return ((double)toGrams())/GRAMS_PER_KG;
  }

  public tkgWeight add(tkgWeight weight) {
    return new tkgWeight(toGrams() + weight.toGrams());
  }

  public tkgWeight subtract(tkgWeight weight) {
    return new tkgWeight(toGrams() - weight.toGrams());
  }

  public tkgWeight multiply(int n) {
    return new tkgWeight(n*toGrams());
  }

  public tkgWeight divide(int n) {
    return new tkgWeight(toGrams()/n);
  }

  // Compare two weights
  // Return value is 1 if current greater than arg
  //                 0 if current equal to arg
  //                -1 if current less than arg
  public int compare(tkgWeight weight) {
    return greaterThan(weight) ? 1 : (equals(weight) ? 0 : -1);
  }

  public boolean equals(tkgWeight weight) {
    return toGrams() == weight.toGrams();
  }

  public boolean lessThan(tkgWeight weight) {
    return toGrams() < weight.toGrams();
  }

  public boolean greaterThan(tkgWeight weight) {
    return toGrams() > weight.toGrams();
  }
}

This is Main Class to Test above  tkgWeight Class. 

public class TestWeights {

  public static void main(String args[]) {
   // Test the constructors
    tkgWeight[] weights = {
                             new tkgWeight(274.65) , new tkgWeight(274),
                             new tkgWeight(274,2,3), new tkgWeight()
                          };

    //Display the weights
    for(int i = 0 ; i < weights.length ; ++i)
    System.out.println("Weight " + i + " is " + weights[i]);

   // Test the operations
    System.out.println("Addition: " + weights[0] + " plus " + weights[1] + " is " + weights[0].add(weights[1]));
    System.out.println("Subtraction: " + weights[0] + " minus " + weights[1] + " is " + weights[0].subtract(weights[1]));
    System.out.println("Multiplication: "+ weights[0] + " times 10 is " + weights[0].multiply(10));
    System.out.println("Division: " + weights[0] + " divided by 10 is " + weights[0].divide(10));

    // Test comparison methods
    if(weights[0].greaterThan(weights[1])) {
      System.out.println("Weight "+ weights[0] + " is greater than length " + weights[1]);
    } else if(weights[0].lessThan(weights[1])) {
      System.out.println("Weight "+ weights[0] + " is less than length " + weights[1]);
    } else {
      System.out.println("Weight "+ weights[0] + " is the same length as length " + weights[1]);
    }

    // Compare successive weights using compare() method
    String compareStr = null;
    for(int i = 0 ; i < weights.length - 1 ; ++i) {
      switch(weights[i].compare(weights[i+1])) {
     case -1:
         compareStr = " is less than length ";
         break;
     case 0:
         compareStr = " is equal to length ";
         break;
     case 1:
         compareStr = " is greater than length ";
         break;
      }
      System.out.println("Weight " + weights[i] + compareStr + weights[i+1]);
    }
  }
}

Output of Above Java Program

Weight 0 is 0t 274kg 650g
Weight 1 is 0t 0kg 274g
Weight 2 is 274t 2kg 3g
Weight 3 is 0t 0kg 0g
Addition: 0t 274kg 650g plus 0t 0kg 274g is 0t 274kg 924g
Subtraction: 0t 274kg 650g minus 0t 0kg 274g is 0t 274kg 376g
Multiplication: 0t 274kg 650g times 10 is 2t 746kg 500g
Division: 0t 274kg 650g divided by 10 is 0t 27kg 465g
Weight 0t 274kg 650g is greater than length 0t 0kg 274g
Weight 0t 274kg 650g is greater than length 0t 0kg 274g
Weight 0t 0kg 274g is less than length 274t 2kg 3g
Weight 274t 2kg 3g is greater than length 0t 0kg 0g

[ Read More ]

Define a class to represent a length measured in meters, centimeters, and millimeters | Java Program

Define a class, mcmLength, to represent a length measured in meters, centimeters, and millimeters, each stored as integers. Include methods to add and subtract objects, to multiply and divide an object by an integer value, to calculate an area resulting from the product of two objects, and to compare objects.  Include constructors that accept three arguments—meters, centimeters, and millimeters; one integer argument in millimeters; one double argument in centimeters; and no arguments, which creates an object with the length set to zero. Check the class by creating some objects and testing the class operations.

public class mcmLength {

  public static final int CM_PER_M = 100;
  public static final int MM_PER_CM = 10;
  public static final int MM_PER_M = MM_PER_CM*CM_PER_M;

  // Private member variables:
  private int meters = 0;
  private int centimeters = 0;
  private int millimeters = 0;

  // Constructors:
  public mcmLength(double cm) {
    this((int)Math.round(cm*MM_PER_CM));
  }

  public mcmLength(int mm) {
    meters = mm/MM_PER_M;
    centimeters = (mm - meters*MM_PER_M)/MM_PER_CM;
    millimeters = mm - meters*MM_PER_M - centimeters*MM_PER_CM;
  }

  // If we were to just store the argument values, we could
  // end up with invalid mm and cm values in the object if the
  // values passed as arguments are not valid.
  // With the approach here we guarantee all values are valid
  // in the object that is created.
  public mcmLength(int m, int cm, int mm) {
    this(m*MM_PER_M + cm*MM_PER_CM + mm);
  }

  public mcmLength(){}

  // Methods
  // Replaces the default toString method in Object:
  public String toString() {
    return Integer.toString(meters) + "m " + centimeters + "cm " + millimeters + "mm";
  }

  public int toMM() {
    return meters*MM_PER_M + centimeters*MM_PER_CM + millimeters;
  }


  public double toMeters() {
    return meters + ((double)(centimeters))/CM_PER_M + ((double)(millimeters))/MM_PER_M;
  }

  // All of the following methods use the toMM():
  public mcmLength add(mcmLength length)
  {
    return new mcmLength(toMM()+length.toMM());
  }

  public mcmLength subtract(mcmLength length)
  {
    return new mcmLength(toMM()-length.toMM());
  }

  public mcmLength multiply(int n)
  {
    return new mcmLength(n*toMM());
  }

  public mcmLength divide(int y)
  {
    return new mcmLength(toMM()/y);
  }

  //Calculate area in square mm
  public long area(mcmLength length) {
    return (toMM()*length.toMM());
  }

  // Compare two lengths
  // Return value is 1 if current greater than arg
  //                 0 if current equal to arg
  //                -1 if current less than arg
  public int compare(mcmLength length) {
    return greaterThan(length) ? 1 : (equals(length) ? 0 : -1);
  }

  public boolean equals(mcmLength length) {
   return toMM() == length.toMM();
  }

  public boolean lessThan(mcmLength length) {
   return toMM() < length.toMM();
  }

  public boolean greaterThan(mcmLength length) {
   return toMM() > length.toMM();
  }
}

This is the main Class to test mcmLength Class.

public class TestLengths {
  public static void main(String args[]) {
    mcmLength[] lengths = new mcmLength[4];

    // Test the constructors:
    lengths[0] = new mcmLength(274.65);
    lengths[1] = new mcmLength(274);
    lengths[2] = new mcmLength(274,2,3);
    lengths[3] = new mcmLength();

    //Display the figures:
    for(int i = 0 ; i < lengths.length ; ++i) {
      System.out.println("Length " + i + " is " + lengths[i]);
    }

    // Test the arithmetic and area operations
    System.out.println("Addition: " + lengths[0] + " plus " + lengths[1] + " is " + lengths[0].add(lengths[1]));
    System.out.println("Subtraction: " + lengths[0] + " minus " + lengths[1]+ " is " + lengths[0].subtract(lengths[1]));
    System.out.println("Multiplication: " + lengths[0] + " times 10 is " + lengths[0].multiply(10));
    System.out.println("Division: " + lengths[0] + " divided by 10 is " + lengths[0].divide(10));
    System.out.println("Area: "  + lengths[0] + " by " + lengths[1] + " is " + lengths[0].area(lengths[1]) + " square mm");

    // Test comparison methods
    if(lengths[0].greaterThan(lengths[1])) {
      System.out.println("Length "+ lengths[0] + " is greater than length " + lengths[1]);
    } else if(lengths[0].lessThan(lengths[1])) {
      System.out.println("Length "+ lengths[0] + " is less than length " + lengths[1]);
    } else {
      System.out.println("Length "+ lengths[0] + " is the same length as length " + lengths[1]);
    }

    // Compare successive lengths using compare() method
    String compareStr = null;
    for(int i = 0 ; i < lengths.length-1 ; ++i) {
      switch(lengths[i].compare(lengths[i+1])) {
        case -1:
         compareStr = " is less than length ";
         break;
        case 0:
         compareStr = " is equal to length ";
         break;
        case 1:
         compareStr = " is greater than length ";
         break;
      }
      System.out.println("Length " + lengths[i] + compareStr + lengths[i+1]);
    }
  }
}

Output of Above Java Program
Length 0 is 2m 74cm 7mm
Length 1 is 0m 27cm 4mm
Length 2 is 274m 2cm 3mm
Length 3 is 0m 0cm 0mm
Addition: 2m 74cm 7mm plus 0m 27cm 4mm is 3m 2cm 1mm
Subtraction: 2m 74cm 7mm minus 0m 27cm 4mm is 2m 47cm 3mm
Multiplication: 2m 74cm 7mm times 10 is 27m 47cm 0mm
Division: 2m 74cm 7mm divided by 10 is 0m 27cm 4mm
Area: 2m 74cm 7mm by 0m 27cm 4mm is 752678 square mm
Length 2m 74cm 7mm is greater than length 0m 27cm 4mm
Length 2m 74cm 7mm is greater than length 0m 27cm 4mm
Length 0m 27cm 4mm is less than length 274m 2cm 3mm
Length 274m 2cm 3mm is greater than length 0m 0cm 0mm

[ Read More ]

Program to Create a Rectangle objects defined by Two Points

Define a class for rectangle objects defined by two points, the top-left and bottom-right corners of the rectangle. Include a constructor to copy a rectangle, a method to return a rectangle object that encloses the current object and the rectangle passed as an argument, and a method to display the defining points of a rectangle. Test the class by creating four rectangles and combining these cumulatively to end up with a rectangle enclosing them all. Output the defining points of all the rectangles you create.

This is the Point class definition. It is used by the Rectangle class

public class Point {
  // Create a Point object from a coordinate pair
  public Point(double x, double y) {
    this.x = x;
    this.y = y;
  }

  // Create a Point object from another Point
  public Point(Point p) {
    x = p.x;
    y = p.y;
  }

  // Get the value of the x coordinate
  double getX() {
    return x;
  }

  // Get the value of the y coordinate
  double getY() {
    return y;
  }

  public String toString(){
    return x +","+y;
  }

  // Fields store the point coordinates
  private double x;
  private double y;
}

This is the Rectangle class definition. It makes use of the Point class definition that is in the same directory as this file.

public class Rectangle {
  private Point topLeft;
  private Point bottomRight;

  // Constructors
  public Rectangle(double x1, double y1, double x2, double y2) {
    // Ensure topleft uses the smaller of x1,x2 and y1,y2
    // and topright uses the larger of x1,x2 and y1,y2
    topLeft = new Point(Math.min(x1,x2),Math.min(y1,y2));
    bottomRight = new Point(Math.max(x1,x2),Math.max(y1,y2));
  }

  public Rectangle(Point tl, Point br) {
    this(tl.getX(), tl.getY(), br.getX(), br.getY());
  }

  public Rectangle(Rectangle rect) {
    topLeft = new Point(rect.topLeft);
    bottomRight = new Point(rect.bottomRight);
  }

  // Methods to create a rectangle enclosing the current rectangle and the argument
  public Rectangle encloses(Rectangle rect) {
    // Return a new rectangle defined by the minimum x,y for to left and the and maximum x,y for bottom right
    return new Rectangle(Math.min(topLeft.getX(), rect.topLeft.getX()),
                         Math.min(topLeft.getY(), rect.topLeft.getY()),
                         Math.max(bottomRight.getX(), rect.bottomRight.getX()),
                         Math.max(bottomRight.getY(), rect.bottomRight.getY()));

  }

  public String toString()  {
    return "Rectangle: " + topLeft + " : " + bottomRight;
  }
}

This is the main Class to Test the Rectangle Class.

public class TestRectangle {
  public static void main(String args[]) {
    Rectangle[] rects = new Rectangle[4];
    Rectangle enclosing;

    // Initialize the rectangles as arbitrary sizes and at arbitrary positions:
    for(int i = 0 ; i < rects.length ; ++i) {
      rects[i] = new Rectangle(Math.random()*100, Math.random()*100, Math.random()*100, Math.random()*100);
      System.out.print("Coords of rectangle " + i + " are: ");
      System.out.println(rects[i]);
    }

    // Initialize the enclosing rectangle to be first rectangle
    enclosing = rects[0];

    // Combine it with each the other rectangles in turn.
    // This will result in the rectangle that encloses them all.
    for(Rectangle rect : rects)  {
      enclosing = enclosing.encloses(rect);
    }

    System.out.println("\nCoords of Enclosing rectangle are ");
    System.out.println(enclosing);
  }
}

Output of Above Java Program
Coords of rectangle 0 are: Rectangle: 0.1903728640358593,58.04643476457927 : 0.2032621709617044,85.8337274416007
Coords of rectangle 1 are: Rectangle: 6.239529478079319,44.58944044246343 : 66.47238823570548,57.983153189860396
Coords of rectangle 2 are: Rectangle: 10.500877688164522,59.35612909169482 : 80.53072142287722,99.35041648038772
Coords of rectangle 3 are: Rectangle: 28.73052501676693,2.2641735796500972 : 44.35555027080914,11.239350082208022

Coords of Enclosing rectangle are
Rectangle: 0.1903728640358593,2.2641735796500972 : 80.53072142287722,99.35041648038772

[ Read More ]