Scope determines where a variable can be used within your code.

Variables declared inside a method or constructor have local scope; accessible only within that block.

Variables declared outside any method or constructor have global scope; accessible throughout the class.

Access modifiers control the visibility and accessibility of variables and methods from outside the class.

Private members are only accessible within the class where they are declared.

Accessible by other classes within the same package (folder).

Accessible by classes in the same package and by subclasses in other packages.

Public members are accessible from any class.

A non-static variable belonging to an object.

Bundling data (variables) and methods that operate on the data into a single unit (class), and hiding the internal details from the outside world.

It limits variable access, preventing unintended modifications and promoting modularity.

It allows variables to be accessed from anywhere in the class, but can increase the risk of unintended side effects.

To encapsulate data and control access to the object's state.

To control the visibility and accessibility of class members, enforcing encapsulation and abstraction.

Restricting access to the internal representation of an object, preventing direct manipulation from outside the class.

The local variable takes precedence within its scope, shadowing the global variable.

Protected members are accessible by subclasses, enabling inheritance while still providing some level of encapsulation.

It defines the interface of the class, specifying which methods and constructors are accessible from other classes.

Knowing the scope of variables helps identify where a variable's value might be unexpectedly changed or accessed.

Static variables have class-level scope and are shared by all instances of the class. Their access is controlled by access modifiers.

By declaring instance variables as `private` and providing `public` getter and setter methods.

For constants or counters that should only be accessed and modified within the class.

By restricting access to internal data and implementation details, preventing external classes from directly manipulating them.

When you want to allow subclasses in other packages to access a member but prevent access from non-related classes.

By limiting the visibility of variables, reducing the chance of accidentally using the same name for different variables in different parts of the code.

Method parameters have local scope within the method, allowing the method to operate on specific inputs without affecting variables outside the method.

By defining a clear interface with `public` members and hiding implementation details with `private` members, changes to the internal implementation do not affect external code that uses the API.

By making the constructor `private` and providing a `public` static method to access the single instance, controlling instantiation and access.

By declaring all instance variables as `private` and not providing any setter methods, preventing modification of the object's state after creation.

By creating well-defined interfaces and encapsulating implementation details, classes can be reused in different contexts without unintended side effects or dependencies.