Access Modifiers in Java

Last Updated: 14 November, 2023

Access modifiers and non-access modifiers are the two types of modifiers in Java. In the tutorial, we are going to discuss all about Java access modifiers, their types, and uses in Java programs.

Access modifiers are used to control the accessibility or visibility of variables, methods, constructors, classes, and interfaces within a program.

Access modifiers play a significant role in object-oriented programming (OOP) by enforcing encapsulation and data hiding, which are vital concepts for maintaining code security and organization.

There are four types of access modifiers in Java:

1. Private
2. Default - No keyword required
3. Protected
4. Public

Now, let's understand the uses of each access modifier one by one with the given examples.

1. Private Access Modifier

The private access modifier restricts access to variables, methods, constructors, or nested classes within the class itself. Not even subclasses or other classes in the same package can access it from outside the class.

If we try to access private members outside the class, we will get a compilation time error, as given in the example below.

class Apple { // private method private void taste() { System.out.println("Apple taste is sweet."); } } public class Fruit { public static void main(String[] args) { // Creating an object of the Apple class Apple object = new Apple(); // Accessing a private method outside the class // Will get a compile-time error, if we do so. object.taste(); } }

Output

Exception in thread "main" java.lang.Error: Unresolved compilation problem: The method taste() from the type Apple is not visible at com.javabytechie.second.Fruit.main(Fruit.java:19)

How to access private members outside the class in Java

There are two main ways to access private members from outside of a class:

1. Using getter and setter methods
2. Using reflection

1. Using getter and setter methods

As private members of a class cannot access outside directly but using the class's getter and setter methods, we can access or modify them from outside the class.

The getter and setter methods are the preferred approaches as compared to reflection. This approach provides a controlled and well-defined way to interact with the class's internal state.

class Apple { // private variables private String fruit_name = "Apple"; private float price; // getter-setter methods public String getFruit_name() { return fruit_name; } public void setFruit_name(String fruit_name) { this.fruit_name = fruit_name; } public float getPrice() { return price; } public void setPrice(float price) { this.price = price; } } public class Fruit { public static void main(String[] args) { // Creating object of Apple class Apple object = new Apple(); // Setting value in private variable using setter method object.setPrice(200.50f); // Accessing private variables using getter methods System.out.println("Fruit's Name: " + object.getFruit_name()); System.out.println("Fruit's Price: " + object.getPrice()); } }

Output

Fruit's Name: Apple
Fruit's Price: 200.5

In this example, we have two private variables named fruit_name and price. We are trying to access these private variables from the other class named Fruit.

Here, we have used the getter and setter methods to access the private variables.

👉 Getter methods are known as accessor methods and Setter methods are known as mutator methods in Java.

2. Using reflection

Reflection is one of the strong features of Java that allows us to access and modify the internal structure of a class at runtime. This includes accessing private fields and methods, as well as overriding methods and creating new instances of classes.

Reflection, however, must be used carefully since it has the ability to break encapsulation and produce unexpected behavior.

import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; class Apple { // private variable private float price; // private method private void showPrice() { System.out.println("Apple Price: " + price); } } public class Fruit { public static void main(String[] args) { try { // Create an object of the Apple class Apple object = new Apple(); // create an object of the class named Class Class obj = object.getClass(); // access the private variable Field field = obj.getDeclaredField("price"); // make private field accessible field.setAccessible(true); // set value of field field.set(object, 250.6F); // get value of field and convert it in float float value = (float) field.get(object); System.out.println("Price: " + value); // access the private method Method[] methods = obj.getDeclaredMethods(); System.out.println("Method Name: " + methods[0].getName()); int modifier = methods[0].getModifiers(); System.out.println("Access Modifier: " + Modifier.toString(modifier)); } catch (Exception e) { e.printStackTrace(); } } }

Output

Price: 250.6
Method Name: showPrice
Access Modifier: private

In this example, we have a private variable named price and a private method named showPrice(). Here, we are using the reflection to access the private variable and method of the class Apple.

2. Default Access Modifier

In Java, if we don't write any access modifiers, then that is considered a default modifier. The accessibility of the default modifier is within the same package only and cannot be accessible outside of the package.

Let's understand the default modifiers through the example given below.

package com.test.package1; public class Fruit { // no access modifier is specified void taste() { System.out.println("Fruit tastes sweet."); } }

package com.test.package1; import com.test.package1.Fruit; public class Apple extends Fruit { public static void main(String[] args) { // create an object of the Apple class Apple object = new Apple(); // accessing the default method within the same package object.taste(); } }

Output

Fruit tastes sweet.

default is a keyword in Java that is used with interface methods and switch statements. For the default access modifier, we don't have to specify any keywords.

3. Protected Access Modifier

The access level of a protected modifier is within the package and outside the package through the child class. It cannot be accessed from classes in different packages unless they are subclasses of the class containing the protected member.

package com.javabytechie.first; public class Apple { // protected method - can be accessed outside the package through the child class. protected void taste() { System.out.println("Apple taste is sweet."); } // default method - cann't be accessed outside the package void price() { System.out.println("Apple price is 200 Rupees."); } }

package com.javabytechie.second; import com.javabytechie.first.Apple; // Class Fruit is subclass of Class Apple public class Fruit extends Apple { public static void main(String[] args) { // Creating object of Apple class Fruit object = new Fruit(); // accessing protected method from outside the package object.taste(); // If we try to access default method outside the package, // it will give compile time error. // object.price(); } }

Output

Apple taste is sweet.

Here, the Apple class has a protected method that is being accessed outside the package because Apple is a child class of Fruit, so using the object of Fruit class, the protected method taste() is being called.

Note: If we try to access the default method outside the package directly, we will get a compile-time error.

4. Public Access Modifier

The public access modifier allows unrestricted access to variables, methods, constructors, or nested classes from anywhere within the program. public access modifier is a global access modifier within the project. It can be accessed from within the class, outside the class, within the package, and outside the package.

package com.javabytechie.first; public class Apple { // Instance method with public access modifier public void taste() { System.out.println("Apple taste is sweet."); } // Static method with public access modifier public static void price() { System.out.println("Apple price is 200 Rupees."); } }

package com.javabytechie.second; import com.javabytechie.first.Apple; public class Fruit { public static void main(String[] args) { // Accessing static method with the class name Apple.price(); // Creating object of Apple class for accessing instance method Apple object = new Apple(); object.taste(); } }

Output

Apple price is 200 Rupees.
Apple taste is sweet.

Here, Apple is a public class, which means this class can be accessed from any different package, and this class has two public-type static and instance methods. The Apple class and its methods are being accessed in another class of a different package.

Here's a table summarizing the access levels and visibility of different access modifiers:

Access modifiers are an important part of Java because they provide an approach for managing access to various parts of a program. They help in the maintenance of code security, the prevention of unwanted access to sensitive data, and the promotion of modularity and organization. Developers can guarantee that their code is well-structured, manageable, and safe by carefully selecting the proper access modifiers.

👉 Java also supports many non-access modifiers, such as static, abstract, synchronized, native, volatile, transient, etc.