Eduzan

Eduzan / Java

Access Modifiers

Access Modifiers in Java

In Java, access modifiers are used to control the visibility and accessibility of classes, methods, and variables. By using these modifiers, we provide the JVM with information like whether a class can be accessed from outside its package, whether child classes can be created, and whether object instantiation is allowed.

Modifier 1: Public Access Modifier

When a class is declared as public, it can be accessed from anywhere. The same applies to methods and variables declared as public within that class.

Example:

// Creating a package
package pack1;

// Declaring a public class
public class MyClass1 {

    // Declaring a public method
    public void display() {
        System.out.println("Public Access Modifier Example");
    }
}

In another package, you can import this class and use it:

// Creating a package
package pack2;

// Importing the class from pack1
import pack1.MyClass1;

public class Main {
    public static void main(String[] args) {
        // Creating an object of class MyClass1
        MyClass1 obj = new MyClass1();
        // Calling the public method
        obj.display();
    }
}

Output:

Public Access Modifier Example

If MyClass1 was not public, you would receive a compile-time error stating that MyClass1 is not accessible from another package.

Modifier 2: Protected Access Modifier

The protected modifier is applicable to data members, methods, and constructors but not for top-level classes or interfaces. When a member is declared as protected, it is accessible within the same package and in subclasses of other packages.

Example:

package pack1;

// Declaring a parent class
class MyClass2 {

    // Declaring a protected method
    protected void show() {
        System.out.println("Protected Access Modifier Example");
    }
}

Now, in another package, we can access it through inheritance:

package pack2;

// Importing the class from pack1
import pack1.MyClass2;

class ChildClass extends MyClass2 {
    public static void main(String[] args) {
        // Creating an instance of the child class
        ChildClass obj = new ChildClass();
        // Accessing the protected method
        obj.show();
    }
}

Output:

Protected Access Modifier Example

We can access the protected method in a subclass even from a different package, but not directly from a non-child class in another package.

Modifier 3: Private Access Modifier

The private modifier restricts access to members within the same class only. Neither child classes nor other classes, even within the same package, can access private members.

Example:

// Defining a class
class MyClass3 {

    // Declaring a private method
    private void secret() {
        System.out.println("Private Access Modifier Example");
    }

    public void accessPrivate() {
        // Accessing the private method within the same class
        secret();
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass3 obj = new MyClass3();
        // Accessing the public method
        obj.accessPrivate();
    }
}

Output:

Private Access Modifier Example

Modifier 4: Default (Package) Access Modifier

When no access modifier is specified, the default access level (also called “package-private”) applies. This means that the class or its members are accessible only within the same package and not from other packages.

Example:

// Defining a class with default access
class MyClass4 {

    // Declaring a default-access method
    void displayMessage() {
        System.out.println("Default Access Modifier Example");
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating an object of MyClass4
        MyClass4 obj = new MyClass4();
        // Calling the default-access method
        obj.displayMessage();
    }
}

Output:

Default Access Modifier Example

Summary of Differences Between Access Modifiers

Access Modifiers
Modifier	Applicability	Accessibility From Same Package	Accessibility From Different Package	Accessibility from Subclass Outside Package	Accessibility from Non-subclass Outside Package
Public	Classes, Methods, Fields	Yes	Yes	Yes	Yes
Protected	Methods, Fields	Yes	No	Yes (only in subclasses)	No
Private	Methods, Fields	No	No	No	No
Default (Package)	Classes, Methods, Fields	Yes	No	No	No

Java is one of the most popular and widely-used programming languages, known for its speed, reliability, and security. Java applications can be found everywhere—from desktop software to web applications, scientific supercomputers to gaming consoles, and mobile phones to the Internet. In this guide, we’ll explore how to write a simple Java program.

Steps to Implement a Java Program

To implement a Java application, follow these key steps:

1. Creating the Program
2. Compiling the Program
3. Running the Program

If you’re looking to dive deeper into Java and gain a strong understanding of the entire development process, consider enrolling in a structured Java programming course. These courses provide hands-on experience and cover everything from basic to advanced topics, allowing you to develop efficient and scalable applications.

Example of a Simple Java Program

Here’s a basic example to illustrate the process:

// Class with multiple access modifiers
class AccessExample {

    public int publicVar = 10;
    private int privateVar = 20;
    protected int protectedVar = 30;
    int defaultVar = 40; // default access level (package-private)

    // Public method
    public void publicMethod() {
        System.out.println("Public Method");
    }

    // Private method
    private void privateMethod() {
        System.out.println("Private Method");
    }

    // Protected method
    protected void protectedMethod() {
        System.out.println("Protected Method");
    }

    // Default method
    void defaultMethod() {
        System.out.println("Default Method");
    }
}

public class MainClass {
    public static void main(String[] args) {
        AccessExample obj = new AccessExample();

        // Accessing variables
        System.out.println("Public variable: " + obj.publicVar);
        System.out.println("Protected variable: " + obj.protectedVar);
        System.out.println("Default variable: " + obj.defaultVar);

        // Accessing methods
        obj.publicMethod();
        obj.protectedMethod();
        obj.defaultMethod();
    }
}

Output:

Public variable: 10
Protected variable: 30
Default variable: 40
Public Method
Protected Method
Default Method

The private member privateVar and method privateMethod() are not accessible from the MainClass since they are declared as private.

Non-Access Modifiers

Non-access modifiers in Java provide additional functionalities beyond access control. Java has several non-access modifiers, which can be applied to classes, methods, and variables to convey specific behavior to the JVM:

1. static: The static modifier is used to declare class-level methods and variables, meaning they belong to the class rather than to instances.
2. final: The final modifier is used to declare constants (final variables), methods that cannot be overridden, and classes that cannot be subclassed.
3. abstract: This modifier applies to classes that cannot be instantiated directly and to methods that must be implemented by subclasses.
4. synchronized: The synchronized keyword is used to control access to methods by multiple threads to ensure that only one thread executes the method at a time.
transient: This modifier is used to declare that a variable should not be serialized.
5. volatile: The volatile modifier informs the JVM that a variable’s value may change in a way that is not visible to other threads.
6. native: The native keyword indicates that a method is implemented in platform-specific code, typically in C or C++.

Example: Non-Access Modifiers

// Class with non-access modifiers
class NonAccessExample {

    // Static variable
    static int staticVar = 50;

    // Final variable
    final int finalVar = 100;

    // Transient variable
    transient int transientVar = 200;

    // Static method
    static void staticMethod() {
        System.out.println("Static Method");
    }

    // Final method
    final void finalMethod() {
        System.out.println("Final Method");
    }

    // Synchronized method
    synchronized void synchronizedMethod() {
        System.out.println("Synchronized Method");
    }
}

public class MainClassNonAccess {
    public static void main(String[] args) {
        NonAccessExample obj = new NonAccessExample();

        // Accessing static members
        System.out.println("Static variable: " + NonAccessExample.staticVar);
        NonAccessExample.staticMethod();

        // Accessing final member and method
        System.out.println("Final variable: " + obj.finalVar);
        obj.finalMethod();

        // Calling synchronized method
        obj.synchronizedMethod();
    }
}

Output:

Static variable: 50
Static Method
Final variable: 100
Final Method
Synchronized Method

Key Differences Between Access and Non-Access Modifiers

Access modifiers control the visibility and access of classes, methods, and fields.
Non-access modifiers provide additional characteristics such as immutability, concurrency control, or indicate that something is platform-specific.

End of lesson.

Back to Java

Access Modifiers

Public vs Protected vs Package vs Private Access Modifier in Java