Thread: toString() method

   public class Operations {  
 
    private int number;  
 
    public Operations(int num) {  
 
        setTheNumber(num);  
    }  
 
    private void setTheNumber(int number) {  
 
        this.number = number;  
    }  
 
    public int getNumber() {  
 
        return number;  
    }  
 
    public Operations add(Operations op) {  
 
        int num1,  
            num2;  
 
        num1 = this.getNumber(); // refers to the receiving objects data members  
        num2 = op.getNumber();   // refers to the argument object  
 
        Operations sum = new Operations(num1 + num2);  
 
        return sum;  
    }  
 
    public Operations subtract(Operations op) {  
 
        int num1,  
            num2;  
 
        num1 = this.getNumber();  
        num2 = op.getNumber();  
 
        Operations difference = new Operations(num1 - num2);  
 
        return difference;  
    }  
 
    // when i add this method  
    public String toString() {  
 
        return getNumber() + "" ;  
    }  
 
    public Operations divide(Operations op) {  
 
        int num1,  
            num2;  
 
        num1 = this.getNumber();  
        num2 = op.getNumber();  
 
        if (num1 == 0 || num2 == 0) {  
 
            System.err.print("Cannot Divide By Zero");  
            System.exit(1);  
        }  
 
        Operations quotient = new Operations(num1 / num2);  
 
        return quotient;  
    }  
 
    public Operations multiply(Operations op) {  
 
        int num1,  
            num2;  
 
        num1 = this.getNumber();  
        num2 = op.getNumber();  
 
        Operations product = new Operations(num1 * num2);  
 
        return product;  
    }  
 
    // Main  
    public static void main(String[] args) {  
 
        Operations num1,  
                   num2;  
 
        Operations sum,  
                   diff,  
                   quot,  
                   prod;  
 
        num1 = new Operations(10);  
        num2 = new Operations(5);  
 
        sum = num1.add(num2);  
        diff = num1.subtract(num2);  
        quot = num1.divide(num2);  
        prod = num1.multiply(num2);  
 
        System.out.println(sum);  
        System.out.println(diff);  
        System.out.println(quot);  
        System.out.println(prod);  
    }  
}

when im not yet Overriding the toString() method the output is
this:

  xxTestxx.Operations@3e25a5  
xxTestxx.Operations@19821f  
xxTestxx.Operations@addbf1  
xxTestxx.Operations@42e816

but when i include the toString() method
the output became fine:

  15  
5  
2  
50

as you can see in my program, i didnt use the method toString().
but i dont really understand how does it affects the correct string representation,


i know a bit about memory address representation, so i know the first error,
thats the only thing i want to understand , why and how does the toString() method affects the output? when im not using it...


i know this program can be done in a primitive or rather natural way, but im currently reading a chapter about returning objects, this kind of object orientation suits for a fraction program( reducing fration) ,
i made an example like this so the concern can be noticeable (the fraction program is a bit confusing),


FOLLOW UP QUESTION:
question no 2:

the book says, when you return an object, you are actually returning a REFERENCE,
now my question is this.

take a look at this part

sum = num1.add(num2);

the object sum is receiving a reference from a returned object from the .add() method,
now what is the REFERENCE?

a). Is it the address?
b) Is it the value (15) - is the value 15 the reference?

References aren't too difficult to explain. Think of your variable as a good hunting dog. He will always "point" to the target. He isn't the target (say, a fox), which is very important. If something happens to that fox, say it climbs up a tree or gets shot, the dog will still point to it. The consequences of such are this: any changes you make to that object are independent of the variable reference. So, you can do things like this:

public void sort(int[] nums)
{
     // a simple sort algorithm
     for (int i = 0; i < nums.length; i++)
     {
          for (int j = i; j < nums.length; j++)
          {
               if (nums[j] < nums[i])
               {
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = nums[i];
               }
          }
     }
}
 
public void main(String[] args)
{
     int[] numbers = {1,2,4,3,5};
     sort(numbers);
     System.out.println("The variable pointed to by numbers got changed without assigning something back the the variable!");
     System.out.println("It now contains: ");
     for (int i = 0; i < numbers.length; i++)
     {
          System.out.println(numbers[i]);
     }
}

Notice how I never assigned anything back to the variable numbers, but the object it's pointing to still changed. However, if I happen to do all those operations on a different object, nothing would happen to that original object.

public void sort(int[] nums)
{
     int[] sorted = new int[nums.size];
     // copy over values
     for (int i = 0; i < nums.length; i++)
     {
          sorted[i] = nums[i];
     }
     // a simple sort algorithm
     for (int i = 0; i < sorted.length; i++)
     {
          for (int j = i; j < sorted.length; j++)
          {
               if (sorted[j] < sorted[i])
               {
                    int temp = sorted[i];
                    sorted[i] = sorted[j];
                    sorted[j] = sorted[i];
               }
          }
     }
}
 
public void main(String[] args)
{
     int[] numbers = {1,2,4,3,5};
     sort(numbers);
     System.out.println("The variable pointed to by numbers didn't change!");
     System.out.println("It contains: ");
     for (int i = 0; i < numbers.length; i++)
     {
          System.out.println(numbers[i]);
     }
}

Referencing and pointing in programming is for the most part synonymous, but there are a few things you may have to worry about the vocabulary in other languages (Java doesn't have any of these differences).

First case is impossible in Java because they are primitive types, and primitive types can only be accessed via value, not reference/pointing. Even doing something like this wouldn't change the value:

public static void main(String[] args)
{
     int a = 0;
     changeA(a);
     System.out.println("a hasn't changed: " + a);
}
 
public static void changeA(int a)
{
     a = 5;
}

The second one is a way to swap a because it is encapsulated in a mutable object, which is passed by reference. This and directly assigning the variable to a return value are the only two ways in Java that you can change the value of a variable.

Hashing is a technique to transfer any object into an "index" that can be used to retrieve that specific object from a hash table. hashcode() just happens to be Java's method for creating a hash of an object. The hash function can pretty much be anything you want (provided it always gives the same hash code back if run on the same object), and is used in making efficient data addition/removal, and also for cryptography. It's best to have a semi-random distribution of objects for either case because that's what gives the hash table efficiency and encryption hard to crack.