Why Pointers are not Used in Java?

Hello guys, in this tutorial, we will learn and try to understand Why Pointers are not Used in Java Programming language? What is used instead of Pointers in Java, and why does Java not support Pointers with detailed explanations.

Before explaining why pointers are not used in Java, let’s first understand what exactly a Pointer is.

Contents

1 What is a Pointer?
2 Reasons Why Pointers are not Used in Java?
3 What is used instead of Pointers in Java?

What is a Pointer?

A pointer is a variable that stores the memory address of another variable as its value. Pointers are commonly used in C and C++ programming, but they can be found in other languages as well. They are useful for dynamically allocating memory, for passing parameters by reference, and for creating data structures such as linked lists and trees.

why pointers are not used in java – fig – 1

Syntax for Declaring the Pointer Variable

Datatype *pointer_name;

1	Datatype *pointer_name;

In the above syntax, the datatype can be int, char, double etc., and the pointer name is any valid identifier declared by us.
The data type of the pointer and the variable to which it is pointing must be the same.
To declare the pointer, we use the asterisk symbol(*).

Some of the examples of declaring pointers.

int *marks;
char *name;
double *salary;

int *marks;

char *name;

double *salary;

Uses of Pointers

The pointers can be used in arrays, functions and structures. By using the pointers in these, we can reduce the code, and it improves the performance.
The pointer allows us to access any memory location.

It reduces the code and improves performance.
By using pointers, we can return multiple values from function.
Pointers are used to pass arguments by reference.

Operators Used in Pointers

The pointers use two operators.

Dereference operator (*)
- The deference operator represents an asterisk symbol which is used to store the address of another variable.
- * symbol is used to get the variable value the pointer points to.
- It is also known as the indirection operator.
Address-of operator (&)
- The address-of operator allows us to see the address of a variable.
- & symbol is used to get the address of the variable.

Example Program for Pointers in C Programming Language

#include<stdio.h>
using namespace std;
int main()
{
	int *ptr,q; //declaring pointer variable
	q=50;
	ptr=&q;//initializing pointer variable
	//address of q is assigned to ptr
	printf("the address of the q is = %u\n",ptr);
	//displaying q's value using ptr variable
	printf("the value of the q is = %d\n",*ptr);
    
	return 0;
}

#include<stdio.h>

using namespace std;

int main()

{

int *ptr,q; //declaring pointer variable

q=50;

ptr=&q;//initializing pointer variable

//address of q is assigned to ptr

printf("the address of the q is = %u\n",ptr);

//displaying q's value using ptr variable

printf("the value of the q is = %d\n",*ptr);

return 0;

}

Output :

the address of the q is = 6487620
the value of the q is = 50

1 2	the address of the q is = 6487620 the value of the q is = 50

So this was the brief explanation of what a pointer is and now let’s understand why pointer is not used in Java.

Reasons Why Pointers are not Used in Java?

There are a few reasons why pointers are not used in Java, and let’s learn about them one by one.

1. Security Loss

As we know, Pointers variables refer to the memory address location of the data directly, and that’s why security will be significantly less in the case of pointers. Any modification can be made using the Memory address locations if someone gets access to it, resulting in a loss of security. But Java is a very secure programming language, so it has to provide very good security for its application data, and that is why Pointers are not supported in Java.

2. Complex Nature of Pointers

Under C and C++ programming languages, Pointers are somewhat confusion-oriented features. They increase confusion among the programmers. Not only the single-level pointers but when we go for multi-level pointers, which means one pointer is pointing to another pointer, another pointer is referring to some another pointer and some another pointer is referring to some another pointer, thus creating a chain of pointers.

Multi-level pointers automatically create confusion and complexity for the developers. They complicate the language and make it more difficult to learn and to use. And due to the complex nature of pointers and hard-to-understand, Java has eliminated the feature of pointers because Java is a very simple language. It focuses on code simplicity, and the usage of pointers can make it challenging.

3. Pointer Arithmetic is Unsafe

Memory access via pointer arithmetic is known to be insecure. By manipulating pointers using pointer arithmetic, one could potentially access sensitive information or jeopardize the security of a system. It is fundamentally unsafe and can lead to memory corruption or vulnerabilities. Java has a robust security model, which is why it disallows pointer arithmetic for this reason.

4. Platform-Dependent

Pointers are primarily suitable in platform-dependent programming languages such as C, C++ etc. But Java is a platform-independent programming language, and one of its major features. Allowing pointers would make it much less platform-independent, which would be a severe drawback, which is why pointers are not used in Java.

5. Manipulation of Pointers can be Dangerous

Manipulation of pointers can be dangerous if you’re not careful. If you try to access a pointer that’s not been initialized, you can end up with all sorts of undefined behavior. Dereferencing a null pointer can cause your program to crash. Trying to write to a read-only memory location can also cause undefined behavior.

Bottom line: Manipulating pointers can be dangerous. If you’re not careful, you can easily create a situation where your program crashes or behaves unexpectedly.

6. Manual Memory Management

Pointes can be used to allocate and deallocate blocks of memory which is a great feature. But sometimes, it can be a pain for programmers who have to manage memory manually. If memory isn’t managed carefully, it can lead to headaches in the form of leaks and other memory-related issues.

To solve this problem, Java provides built-in Garbage Collection(GC), one of the language’s most lauded features. This allows developers to focus on creating new objects instead of worrying about memory allocation and deallocation. The garbage collector automatically reclaims memory for reuse, which Java developers appreciate because it enables faster development with less boilerplate code. Additionally, it eliminates memory leaks and other memory-related problems.

7. Pointers can be used for Hacking and Viruses

The use of pointers is a common technique for hacking and viruses. By using a pointer, hackers and viruses can change the value of a data item without changing the data item itself. It can be used to hack into systems and create viruses, as the pointer can access memory that is not normally accessible. It can also be used to point to sensitive data, such as passwords or credit card numbers, which can be stolen by a hacker.

So these were some of the reasons why pointers are not used in Java. Overall, they are not necessary for general-purpose OOP programming and adding them in Java Programming Language can actually compromise security and lead to more complexity

What is used instead of Pointers in Java?

In Java, References are used instead of pointers. A reference variable is a value that points to an object. A reference can be thought of as a pointer to memory, but it is not possible to manipulate a reference directly. Java uses the concept of pointers implicitly for the manipulation of references, and they are not available for outside use.

The reference variable stores the reference value of an object. The reference value is nothing but the hexadecimal form of hash code. Hash code is a unique identity for the object prepared by the heap manager in the form of an integer value.

Employee empVariable = new Employee();

1	Employee empVariable = new Employee();

So guys, here I am wrapping up this tutorial about why pointers are not used in Java. I hope you got to understand why Pointer is not supported in Java. Still, if you have any query, don’t forget to drop your queries in the comment section.

People Are Also Reading…

Java Swing Password Field