Aliasing in Java

When two or more references are used in Java to refer to the same object, this is called a "alias." When a user writes to an object and its owner does not expect it to change for multiple references, aliasing becomes problematic. Here, the aliasing code can become quite complicated very quickly, and debugging it can be very time-consuming. Let's understand Java Alias's operation.

How do alias work in Java?

Aliasing happens when numerous references are linked to the same object, as we have already covered. It also indicates that a place is modified through multiple aliases, each of which has multiple types.

Let's use an example. Two variable names, a and b, correspond to the types A and B. A is extended by B.

B[] b = new B[20];
A[] a = b;
a[0] =  new A();
B[0].fun1();

They both point to the same place in memory as well.

Both a and b are pointing to the same memory address. The actual object that is saved, however, gets to decide which runtime technique to use.

Let us see another example.

Rectangle b1 = new Rectangle (0, 0, 40, 120);
Rectangle b2 = b1;

The provided item has two names, such as b1 and b2, or both b1 and b2 belong to the same object. Objects can have multiple names, just like persons can.

Changes made to one aliased variable also affect the other, as the example below shows.

System.out.println (b2.width);
b1.grow (30, 30);
System.out.println (b2.width);

You will observe that the modifications made to one rectangle also affect the second rectangle after running the code.

Some sample programs on Java Alias are listed below.

Implementation:

FileName: Alias1.java

import java.io.*;
import java.util.*;
class A 
{
    // first function
    public void fun1()
    {
        System.out.println("sample function 1 is called");
    }
}
    // Class B, which extends upon Class A
class B extends A
{
    // first fucntion
    public void fun1()
    {
        System.out.println("sample function 1 is called");
    }
    // second fucntion
    public void fun2()
    {
        System.out.println("sample function 2 is called");
    }
}
public class Alias1
{
    public static void main(String[] args) 
    {
        B[] b = new B[10];
        A[] a = b;
        a[0] =  new A();
        b[0].fun1();
    }
}

Output:

Exception in thread "main" java.lang.ArrayStoreException: A
at Alias1.main(Alias1.java:31)

Explanation:

This exception only occurs because Java handles aliases while the program is running. It won't be able to determine that the first one should be an object of B rather than A until the run time.

FileName: Alias2.java

import java.io.*;
import java.util.*;
class A 
{
    // first function
    public void fun1()
    {
        System.out.println("sample function 1 is called");
    }
}
    // Class B, which extends upon Class A
class B extends A
{
    // first fucntion
    public void fun1()
    {
        System.out.println("sample function 1 is called");
    }
    // second fucntion
    public void fun2()
    {
        System.out.println("sample function 2 is called");
    }
}
public class Alias2
{
    public static void main(String[] args) 
    {
        B[] b = new B[10];
        A[] a = b;
        a[0] =  new B();
        b[0].fun1();
    }
}

Output: