Access modifiers in Java are keywords used to determine the level of access or visibility of a class, method, or variable. Access modifiers are essential in enforcing encapsulation, which is the principle of keeping an object's state private and providing controlled access to its behavior.

Access Modifiers in Java

There are two types of modifiers in Java: 

1. Access modifiers.
2. Non-access modifiers.

What is Access Modifiers in Java?

Access specifiers or access modifiers in Java are keywords that determine the accessibility of classes, fields, and methods in a program. They are also known as visibility specifiers. Access specifiers regulate the access to data and information in a class by other classes. They help determine whether a field or method in a class can be invoked or used by another method in another class or sub-class. 

They can also be used to restrict access to certain data or methods. Access specifiers are essential in object-oriented programming as they help in controlling the access of data and methods, thereby maintaining data security and integrity.

Types of Access Modifiers in Java

There are four Access Modifier in Java:

1. Public
2. Private
3. Default
4. Protected

Public Access Modifier in Java:

The public access modifier in Java is represented by the keyword 'public'. When a class, field, method, or constructor is declared as public, it can be accessed from anywhere in the program, i.e., inside and outside of its package. This access modifier is the least restrictive of all the access modifiers in Java.

Example 1: Public Class

Let's start with an example of a public class. In this example, we will create a class named 'Person' and declare it as public. The 'Person' class has two fields, 'name' and 'age', and two methods, 'setName' and 'setAge', which are used to set the values of the 'name' and 'age' fields.

public class Person { 
public String name; 
public int age; 
public void setName(String name) { 
this.name = name; 
 } 
public void setAge(int age) { 
this.age = age; 
 } 
}

In this example, we have declared the 'Person' class as public, which means it can be accessed from anywhere in the program. The 'name' and 'age' fields are also declared as public, which means they can be accessed and modified from anywhere in the program.

Example 2: Public Method

Now, let's look at an example of a public method. In this example, we will create a public method named 'sum' that takes two integers as parameters and returns their sum.

public class Calculator {
    public int sum(int a, int b) {
        return a + b;
    }
}

In this example, we have declared the 'sum' method as public, which means it can be accessed from anywhere in the program. We have also declared it to return an integer value, which is the sum of the two integers passed as parameters.

Example 3: Public Field

Finally, let's take a look at an example of a public field. In this example, we will create a public field named 'PI' in a class named 'MathConstants'. The 'PI' field will hold the value of the mathematical constant pi.

public class MathConstants {
    public static final double PI = 3.14159265359;
}

In this example, we have declared the 'PI' field as public, which means it can be accessed from anywhere in the program. We have also declared it as static and final, which means it is a constant and cannot be modified. The value of the 'PI' field is set to the mathematical constant pi.

The public access modifier in Java allows unrestricted access to the class, field, method, or constructor it is applied to. It is the least restrictive of all the access modifiers in Java. We can use the public access modifier to declare classes, fields, methods, and constructors that can be accessed from anywhere in the program. However, it is important to note that using the public access modifier should be done with caution as it can lead to security issues if not used properly.

Private Access Modifier in Java:

The private access modifier in Java is used to declare a field or method as accessible only within the same class. This means that the field or method cannot be accessed from outside of the class in which it is declared. The private access modifier is commonly used to implement encapsulation, which is one of the fundamental concepts of object-oriented programming.

Example:

Let's take an example to understand the concept of private access modifier in Java. Consider the following class:

public class Person { 
private String name; 
private int age; 
public Person(String name, int age) { 
this.name = name;
        this.age = age; 
 } 
public void setName(String name) {
this.name = name; 
 }

    public String getName() {
return name; 
 }
public int getAge() { 
return age; 
 } 
public void displayInfo() { 
 System.out.println("Name: " + name);
 System.out.println("Age: " + age);
 } 
}

In this example, the Person class has two private fields: name and age. These fields can only be accessed within the same class, which means that they cannot be accessed directly from outside the class.

To access the private fields, we need to use public methods provided by the class. In this example, we have provided public setter and getter methods for the name field. These methods can be used to set and get the value of the name field from outside the class.

The displayInfo() method is a public method that can be used to display the values of the private fields. This method can be called from outside the class and it can access the private fields using the getter methods.

Benefits of Private Access Modifier:

1. Encapsulation: The private access modifier is used to implement encapsulation in Java. Encapsulation helps in protecting the fields and methods of a class from being accessed by other classes, thereby ensuring data security and preventing unauthorized access.
2. Flexibility: The private access modifier provides flexibility in terms of changing the implementation details of a class. If we change the implementation of a private method or field, it will not affect the other parts of the program that use the class.
3. Code Maintenance: Using private access modifier helps in maintaining the code easily. If we change the implementation of a private method or field, we only need to update the code within the same class. This avoids making changes to other parts of the code that use the class.

The private access modifier in Java is used to restrict the accessibility of fields and methods to within the same class. This helps in implementing encapsulation, which is an important concept of object-oriented programming. The private access modifier provides flexibility and code maintenance benefits and it is widely used in Java programming.

Default Access Modifier in Java:

In Java, the default access modifier is also known as package-private or default package access. It is a type of access modifier used to restrict the visibility of a method or field within the same package. If no access modifier is specified for a class, method, or field, it is by default considered as package-private.

 Example :

package com.example.package1; 
class MyClass { 
void display() { 
System.out.println("This is a package-private method."); 
 } 
} 
public class MainClass { 
public static void main(String[] args) { 
MyClass obj = new MyClass();
        obj.display(); 
 } 
}

In the above example, the class MyClass has a method display() with default access modifier, meaning it can only be accessed within the same package. The class MainClass has public access modifier, which allows it to be accessed from outside the package.

When we run the MainClass, it creates an object of MyClass and calls the method display(), which is package-private and can only be accessed within the same package. Hence, this program will compile and run without any errors.

Default access modifier is useful when you want to restrict access to certain methods or fields within the same package. It is a way of encapsulating the implementation details of a class and making them available only to the classes within the same package.

However, it is important to note that default access modifier should not be used for classes or methods that need to be accessed from outside the package. In such cases, it is better to use public access modifier.

default access modifier is a type of access modifier in Java that restricts the visibility of a method or field within the same package. It is useful for encapsulating implementation details of a class and making them available only to the classes within the same package. However, it should not be used for classes or methods that need to be accessed from outside the package.

Protected Access Modifier in Java:

In Java, the protected access modifier is used to control the accessibility of class members within the package as well as outside the package through inheritance. The protected access modifier is more restrictive than the public access modifier, but less restrictive than the private and default access modifiers.

When a class member is declared as protected, it can be accessed by any class within the same package or any subclass of the class in any package. This is useful when we want to allow only the subclasses of a class to access certain fields or methods.

Here's an example of how to use the protected access modifier in Java:

package com.example; 
public class Vehicle { 
protected String brand = "Ford";          // protected field 
protected void honk() {                   // protected method 
 System.out.println("Tuut, tuut!"); 
 } 
} 
public class Car extends Vehicle { 
private String modelName = "Mustang"; 
public static void main(String[] args) { 
Car myCar = new Car();
      myCar.honk(); 
// protected method accessible through 
inheritance
      System.out.println(myCar.brand); 
// protected field accessible through 
inheritance
      System.out.println(myCar.modelName); 
 } 
}

In the example above, the Vehicle class has a protected field brand and a protected method honk(). The Car class, which extends the Vehicle class, can access the protected field and method through inheritance.

The main() method in the Car class creates a new Car object called myCar and then calls the honk() method of the Vehicle class using myCar.honk(). Similarly, the brand field of the Vehicle class is accessed using myCar.brand.

Protected access modifier is often used in conjunction with inheritance to provide a more restricted access to class members to the outside world while still allowing subclasses to access those members.

The protected access modifier in Java is useful when we want to restrict access to certain fields or methods to only the subclasses of a class or classes within the same package. It strikes a balance between the more restrictive private and default access modifiers and the less restrictive public access modifier.

Access Modifier	Same class	Same package subclass	Same package non-subclass	Difference Package subclass	Different package non-subclass
Default	Yes	Yes	Yes	No	No
Private	Yes	No	No	No	No
Protected	Yes	Yes	Yes	Yes	No
Public	Yes	Yes	Yes	Yes	Yes

Conclusion

Access modifiers play a crucial role in controlling the access and visibility of the members of a class in Java. While the public access modifier allows access from anywhere in the code, the private access modifier restricts access to within the class. The protected access modifier allows access within the class, its subclasses, and any other class in the same package, while the default access modifier allows access within the same package. It is important to use the appropriate access modifier to maintain the integrity and security of the code.

You Know?

1.What are the access modifiers in Java?

There are four Access Modifier in Java:

1. Public
2. Private
3. Default
4. Protected

2.What is protected vs private vs public?

1. Private: When a member of a class is marked as private, it can only be accessed from within the same class. It is not visible to any other class or object, including subclasses. This access modifier is typically used to hide the implementation details of a class and to ensure data encapsulation.
2. Protected: When a member of a class is marked as protected, it can be accessed within the same class, as well as any subclass of that class, regardless of whether the subclass is in the same package or not. However, it is not accessible to classes outside of the inheritance hierarchy. This access modifier is typically used to allow subclasses to access certain member variables or methods while still maintaining encapsulation.
3. Public: When a member of a class is marked as public, it can be accessed from any class or object, regardless of where it is located in the program. This access modifier is typically used for methods and variables that need to be accessed from outside the class or package.

3.Why private is better than protected?

Private and Protected are two access modifiers used to control the accessibility of class members. A private member can only be accessed within the same class or struct in which it is declared, while a protected member can be accessed within the same class or in any derived class. The use of these access modifiers helps to enforce encapsulation and maintain the security of the class's internal state.

4.What is the scope of access specifiers in Java?

In Java, access modifiers (also known as access specifiers) are used to control the scope or visibility of various program entities, including packages, classes, constructors, methods, variables, and other data members. These access modifiers provide a way to restrict access to certain program elements, which helps to ensure data encapsulation and maintain code security.

5.What is of access specifier used for?

An access specifier is a feature that allows developers to control which parts of a program can access a specific variable, method, or other data member. By defining access specifiers, developers can restrict access to certain program elements, thereby enforcing encapsulation and improving code security.

Next : Polymorphism in Java

Previous : Encapsulation in Java