Java Alias

In Java, when multiple references are used to refer to the same object, it is commonly referred to as “alias.”The issue with aliasing is when a user writes to a particular object, and the owner, for several other references, does not expect that object to change. Here, the code that includes aliasing can get confusing fast, and it is very tedious to debug as well. Let us see how Java Alias works.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

How does an alias work in Java?

As we have previously discussed, aliasing occurs when multiple references are associated with the same object. It also means that there are several aliases for a location that can be modified, and these particular aliases have several types.

Let us take an example. x and y are two variable names that have two types, X and Y. Y extends X.

Y[] y = new Y[10];
X[] x = y;
x[0] =  new X();
Y[0].func1();

In memory as well, they both point to the same location.

The memory location which is pointed is pointed by x as well as y. However, the actual object saved chooses which method to call during runtime.

Let us see another example.

Rectangle b1 = new Rectangle (0, 0, 50, 150);
Rectangle b2 = b1;

Both b1 and b2 refer to the same object, or we can say that the given object has two names, such as b1 and b2. Similar to a person that has two names, objects can also have two names.

When two aliased variables are present, changes that cause one variable also reflect on the other, as shown below.

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

On executing the code, you will see that the changes that have been caused on one rectangle have occurred in the second rectangle as well. This is one of the main things that has to be noted for Alias in Java.

Examples of Java Alias

The following are some of the sample programs on Java Alias.

Example #1

Code:

//class X
class X {
//function 1
public void func1()
{
System.out.println("called sample function 1");
}
}
//Class Y that extends the class X
class Y extends X
{
//function 1
public void func1()
{
System.out.println("called sample function 1");
}
//function 2
public void func2()
{
System.out.println("called sample function 2");
}
}
//main class
public class AliasExample {
//main method
public static void main(String[] args) {
Y[] y = new Y[10];
X[] x = y;
x[0] =  new X();
y[0].func1();
}
}

Output:

How this occurs? What has to be changed? Is it possible to solve this?

Yes!! The only reason for this exception is that Java manages aliases during runtime. Only during the run time will it be able to know that the first one should be an object of Y instead of X.

//class X
class X {
//function 1
public void func1()
{
System.out.println("called sample function 1");
}
}
//Class Y that extends the class X
class Y extends X
{
//function 1
public void func1()
{
System.out.println("called sample function 1");
}
//function 2
public void func2()
{
System.out.println("called sample function 2");
}
}
//main class
public class AliasExample {
//main method
public static void main(String[] args) {
Y[] y = new Y[10];
X[] x = y;
x[0] =  new Y();
y[0].func1();
}
}

Output:

Example #2

Code:

//main class
public class AliasExample {
//main method
public static void main(String[] args) {
//create two different arrays with same value
int a= 87;
int b=87;
//checks whether a and b are equal
System.out.println(a == b);
//assign b equal to a
b=a;
//checks whether a and b are equal
System.out.println(a == b);
}
}

Output:

What will happen if two arrays, a and b, are used instead of integer variables?

//main class
public class AliasExample {
//main method
public static void main(String[] args) {
//create two different arrays with same value
int []a = {81, 54, 83};
int []b = {81, 54, 83};
//checks whether a and b are equal
System.out.println(a == b);
//assign b equal to a
b=a;
//checks whether a and b are equal
System.out.println(a == b);
}
}

Output:

In this program, two arrays, a and b, are created in the first step. Then, similar to the above program, a and b check whether they are equal. On executing the code, it can be seen that the output for the first check is false, and the output for the second check is true. It is because Java Alias works.

Conclusion

The drawback of alias is when a user writes to a specific object, and the owner, for some other references, does not guess that object to change.

The above is the detailed content of Java Alias. For more information, please follow other related articles on the PHP Chinese website!