Access Modifiers in Java

-

Access Modifiers in Java 

Access modifiers are crucial Java tools that specify how variables, methods, and even the class itself can be accessed from other areas of the program.

Access modifiers in Java regulate which classes, methods, and variables are visible. In summary, these are the four primary types:
  • Public: Reachable from any location inside the project.
  • Private: Only accessible by members of the same class.
  • Protected: Accessible by subclasses and within the same package (even in distinct packages).
  • Default (no modifier): Also known as package-private, it is only accessible within the same package.

Access Modifiers for Java Classes

Access modifiers in Java regulate which classes, methods, and variables are visible. In summary, these are the four primary types:

public: Any other class in any package can access the class.
             ex: public class MyClass { }

default (no modifier): Only members of the same package can access the class.
                                        ex: class MyClass { }

Private: Top-level classes are not permitted. Private classes are limited to nested classes.
                ex: private class MyClass { } (nested only)

Protected: Top-level classes are not permitted. It is only possible to protect nested classes.
                    ex: protected class MyClass { } (nested only)

Access Modifiers for Variables (and Methods)

All four access modifiers can be used by variables and methods within a class. This regulates their visibility and modification by other classes.

Public: Reachable from any location, including other packages.
              ex: public int age;

Private: Only accessible by members of the same class.
                ex: private String name;

Protected: Available to subclasses in other packages as well as within the same package.
                    ex: protected double salary;

default (no modifier): Accessible only within the same package.
                                        ex: int id;

Comparison Table of Access Modifiers in Java
















Comments

Post a Comment

Popular posts from this blog

Java Design Patterns

-
Image
Java Design Patterns Java Design Patterns are reusable, well-tested solutions to common design problems in object-oriented programming. They act as templates that guide how to structure classes, create objects, and manage interactions in a clean and efficient way. Instead of reinventing solutions, developers follow these established patterns to write flexible, maintainable, and scalable Java applications. They also improve communication by giving developers a shared vocabulary. Overall, design patterns help produce high-quality, organized, and adaptable software. Design patterns in Java are generally grouped into three main categories, 1. Creational Design Patterns These patterns deal with object creation mechanisms, improving flexibility and reuse. Singleton    Ensures only one instance of a class exists, and provides a global access point. Factory Method  Defines an interface for creating objects, but lets subclasses decide which          ...
Read more

Application Programming Interface (API)

-
Image
Application Programming Interface (API) What is Application Programming Interface ? Through an API, a program can ask another program for information or actions and get a response without having to understand the underlying workings of the other program. In the example for Application Programming Interface, a restaurant waiter is the best example. The reason for saying this is that the waiter position is similar to API. The waiter receives an order from you, the customer. Your request is communicated to the chef (the server) by the waiter (the API). After processing the request and preparing the food, the chef hands it to the waiter. It is returned to your table by the waiter (answer). In the same way, the API takes the request from the client and sends a request to the server and accordingly the response from the server is sent to the client by APL Why do We need APIs ? Building scalable, adaptable, and networked systems requires APIs. Developers depend on them for the following reaso...
Read more