by Dinesh Thakur

When you compile this program, you will find that two class files have been created, one for Rectangle and one for RectangleArea. The Java compiler automatically puts each class into its own class file.

To run this program, you must execute RectangleArea class. This is because the main () method is in this RectangleArea class and not in Rectangle class.

class Rectangle

{
      int length;
      int breadth;
      //method to intialize length and breadth of rectangle
      void setData(int l, int b)
      {
        length =l;
        breadth=b;
      }
      //method to calculate area of rectangle
      int area()
      {
        int rectArea;
        rectArea = length * breadth;
        return rectArea;
      }
}
//Class to Create Rectangle Objects and Calculate Area
class RectangleArea
{
         public static void main(String[] args)
     {
           //Creating objects
           Rectangle firstRect = new Rectangle();
           firstRect.setData(5,6);
           int result = firstRect.area();
           System.out.println("Area of Rectangle = "+ result);
     }
}

Java Class Rectangle

In this Example, we have declared two classes: Rectangle and RectangleArea. The Rectangle class contains two fields length and breadth of type int that correspond to the length and breadth of the rectangle respectively. In addition, the Rectangle class also contains two methods named setData () and area ().The method setData () initializes length and breadth fields of an object and area ()calculates the area of the rectangle. It does not have a main () method and therefore cannot be run. It is merely a definition used to define and create Rectangle objects. So we define another class named RectangleArea that contains the main () method from where the program execution actually begins.

In the main (), the statement

Rectangle firstRect = new Rectangle();

creates a Rectangle object in memory and assign it to the reference variable firstRect

The statement,

firstRect.setData(5,6);

invokes the method setData () on the object firstRect, and copies the arguments 5 and 6 to the parameters l and b respectively. The flow of control is now within the body of the setData () method. Here, the values in l and b are assigned to length and breadth instance variables respectively. After executing the body of the setData () method, the control now shifts back to the main () method and continues with the next statement,

int result = firstRect.area();

Here, the area () method is invoked on the firstRect object, causing flow of control to jump to the area () method. In this method, we declare the variable rectArea which exist only within the body of the method. This variable will be created each time you the method are executed and will be destroyed when execution of method ends. All the variables you declare within the body of the method are local to the method and are only around while the method is being executed. These variables are known as local variables.

In this variable, we store the area of the rectangle using the statement,

rectArea = length*breadth;

After this, the return statement is reached, which in this example returns the value 30 and also causes the flow of control to jump back to the calling method, main (). The value is 30 is then substituted for the method name from where it is called which is then assigned to the variable result. This value is then displayed using the

Systerm.out.println () method.