Access and Non Access Modifiers in Java

Java provides a rich set of modifiers. They are used to control access mechanisms and also provide information about class functionalities to the JVM. They are divided into two categories, namely:

Access Modifiers

Java access modifiers are used to control the visibility and accessibility of classes, methods, and variables in a program. They help achieve encapsulation and secure access control by defining where a member can be accessed from. They are following:

1. public:

• Accessible from anywhere
• No restrictions across packages or classes

public int count;

2. private:

• Accessible only within the same class
• Commonly used for encapsulation

private int salary;

3. default (Package-Private):

• No keyword is used
• Accessible within the same package only
• Not accessible from outside the package (even in subclasses)

int age; // default access

4. protected:

Accessible:

• Within the same package
• In subclasses, even if they are in different packages
• Strongly associated with inheritance

protected String name;

Non-access Modifiers

In java, we have 7 non-access modifiers. They are used with classes, methods, variables, constructors, etc to provide information about their behavior to JVM. They are as follows:

1. static

The static modifier in Java indicates that a member belongs to the class itself rather than any specific object. All instances of the class share the same static variable or method, allowing common access without creating an object.

Syntax:

static int count;
static void display() { }

2. final

The final modifier in Java prevents modification of the element it is applied to. It can be used with variables (constant values), methods (cannot be overridden), and classes (cannot be subclassed).

Syntax:

final int MAX = 100;
final void show() { }
final class Vehicle { }

3. abstract

The abstract modifier in Java is used with classes and methods to define incomplete implementations. An abstract method has no body and must be implemented by a subclass, while an abstract class cannot be instantiated directly.

Syntax:

abstract class Shape {

abstract void draw();

}

4. synchronized

The synchronized modifier in Java is used in multithreading to control access to critical sections. It ensures that only one thread can execute a method or block at a time, preventing race conditions.

Syntax:

synchronized void update() { }

5. transient

The transient modifier in Java prevents a variable from being serialized when an object is converted to a byte stream. It is useful for excluding sensitive or non-essential data from serialization.

Syntax:

transient int password;

6. volatile

The volatile keyword in Java ensures that updates to a variable by one thread are immediately visible to other threads. It prevents threads from caching the variable locally, guaranteeing consistent and up-to-date values across all threads.

Syntax:

volatile boolean flag;

7. native

The native keyword in Java is used to declare a method whose implementation is provided in platform-specific code, typically using C or C++. It allows Java programs to interact with non-Java libraries via JNI (Java Native Interface).

Syntax:

native void loadLibrary();