Java Modifiers: Access and Non-Access Explained with Examples

Resposta:

In Java, modifiers are keywords that you can use to change the way classes, methods, and variables behave. They can be broadly categorized into two types: access modifiers and non-access modifiers.

1. Access Modifiers

Access modifiers control the visibility of classes, methods, and variables. There are four main access modifiers in Java:

public: The member is accessible from any other class.
protected: The member is accessible within its own package and by subclasses.
default (no modifier): The member is accessible only within its own package.
private: The member is accessible only within its own class.

Example of Access Modifiers:

class Example {
    public int publicVar;      // Accessible from anywhere
    protected int protectedVar; // Accessible within the package and subclasses
    int defaultVar;            // Accessible only within the package
    private int privateVar;    // Accessible only within this class

    public void display() {
        System.out.println("Public: " + publicVar);
        System.out.println("Protected: " + protectedVar);
        System.out.println("Default: " + defaultVar);
        System.out.println("Private: " + privateVar);
    }
}

2. Non-Access Modifiers

Non-access modifiers provide additional functionality to classes, methods, and variables. Some common non-access modifiers include:

static: Indicates that a member belongs to the class rather than instances of the class.
final: Indicates that a variable's value cannot be changed, a method cannot be overridden, or a class cannot be subclassed.
abstract: Indicates that a class cannot be instantiated or a method must be implemented by subclasses.
synchronized: Used in multi-threading to ensure that a method or block of code is accessed by only one thread at a time.
volatile: Indicates that a variable's value will be modified by different threads.

Example of Non-Access Modifiers:

class NonAccessModifiersExample {
    static int staticVar = 0; // Belongs to the class

    final int finalVar; // Cannot be changed once initialized

    // Constructor to initialize final variable
    NonAccessModifiersExample(int value) {
        this.finalVar = value;
    }

    static void staticMethod() {
        System.out.println("Static method called. Static variable: " + staticVar);
    }

    final void finalMethod() {
        System.out.println("This is a final method.");
    }
}

// Abstract class example
abstract class AbstractClass {
    abstract void abstractMethod(); // Must be implemented by subclasses
}

// Subclass implementing the abstract method
class ConcreteClass extends AbstractClass {
    void abstractMethod() {
        System.out.println("Abstract method implemented.");
    }
}

Summary