Java Reference Types

In this article, we talk about the Java Reference Types. First of all, we interpret what is a reference and why we use it. Furthermore we analyze the reference types. Last but not least, we explain the difference between Pass by value and pass by reference.

1. Introduction

A reference is a value that is used to refer to another value. To do that you need an address that you can point to another address. In C++ this is called a pointer and it points to a memory address but in Java, the reference is more abstract. Reference types include: Interfaces, classes, arrays, annotations, and enums. The reference has four types: Strong, weak, soft, and phantom.

2. Technologies used

The example code in this article was built and run using:

• Java 1.8.231(1.8.x will do fine)
• Eclipse IDE for Enterprise Java Developers- Photon

3. Java Reference Types

3.1. Strong Type

The strong type is the most common type that we used in Java. We can say that we use a strong type when we point directly a variable to an object. So the developer can interact with the object through this variable. For example:

public class StrongR {
	public static class Example {
		 public void example(){
			 System.out.println("Hello world");
		 }
		}

public static void main(String args[]) {
    Example strongEx= new Example();
	strongEx=null;
}
}

public class StrongR {

    public static class Example {

         public void example(){

             System.out.println("Hello world");

         }

        }

public static void main(String args[]) {

    Example strongEx= new Example();

    strongEx=null;

}

}

There isn’t something to print.

When the object “strongEx” will be null then the object will be available for the garbage collector.

3.2. Weak Type

In different with the other types that they preserved in memory if an object has only weak reference attached to it when the garbage collector is running the weak type will reclaim the object even if the virtual machine has no more space. For example:

import java.lang.ref.WeakReference;

public class WeakR {
	public static class Example {
		 public void example(){
			 System.out.println("Hello world");
		 }
		}
	public static void main(String args[]) {
		
		Example weakEx= new Example();
		weakEx.example();
		WeakReference<Example> wr = new WeakReference<Example>(weakEx);
		weakEx=null;
		weakEx=wr.get();
	}
}

import java.lang.ref.WeakReference;

public class WeakR {

    public static class Example {

         public void example(){

             System.out.println("Hello world");

         }

        }

    public static void main(String args[]) {

        Example weakEx= new Example();

        weakEx.example();

        WeakReference<Example> wr = new WeakReference<Example>(weakEx);

        weakEx=null;

        weakEx=wr.get();

    }

}

The output is:

As we can see with “get()” we can retrieve the object because of the weak reference.

3.3. Soft Type

This type is used as a last chance for an application to stay alive. The Soft type has the ability to change the default behavior of the garbage collector and allows it to maintain the objects without strong references until JVM uses all the memory. For example:

import java.lang.ref.SoftReference;


public class SoftR {
	public static class Example {
		 public void example(){
			 System.out.println("Hello world");
		 }
		}
	public static void main(String args[]) {
		Example SoftEx=new Example();
		SoftEx.example();
		SoftReference<Example> sr = new  SoftReference<Example>(SoftEx);
		SoftEx=null;
		SoftEx=sr.get();
	}
}
 

import java.lang.ref.SoftReference;

public class SoftR {

    public static class Example {

         public void example(){

             System.out.println("Hello world");

         }

        }

    public static void main(String args[]) {

        Example SoftEx=new Example();

        SoftEx.example();

        SoftReference<Example> sr = new  SoftReference<Example>(SoftEx);

        SoftEx=null;

        SoftEx=sr.get();

    }

}

The output is:

As we can see with “get()” we can retrieve the object because of the soft reference.

3.4. Phantom Type

This type is used for two reasons. First, to determine the time that an object was removed from the memory and the second is to avoid the use of ‘finalize’ method that helps garbage collector to release memory. For example:

The output is:

In this example we can see that ReferenceQueue is used to keep the removing object before removing from memory. When we remove the object every print that has to do with this gives us runtime error.

4. Pass by value versus Pass by reference

When we want to pass by value basically it means that when we call a method the parameter values are copied to another variable and after that the copied object(variables) is passed.

When we want to pass by reference it means that when we call a method, the parameter is a reference to another variable and this parameter is passed.

5. Download the Complete Source Code

Here is the code from the examples we used.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.