{"id":4079,"date":"2024-09-21T11:59:45","date_gmt":"2024-09-21T06:59:45","guid":{"rendered":"https:\/\/afzalbadshah.com\/?p=4079"},"modified":"2024-09-24T08:50:26","modified_gmt":"2024-09-24T03:50:26","slug":"understanding-modifiers-in-java","status":"publish","type":"post","link":"https:\/\/afzalbadshah.com\/index.php\/2024\/09\/21\/understanding-modifiers-in-java\/","title":{"rendered":"Understanding Modifiers in Java"},"content":{"rendered":"\n

Modifiers in Java are used to control the behaviour and accessibility<\/strong> of classes, methods, and variables. They define who can access certain parts of a program and how the components of the class behave. Modifiers are categorized into two main types: Access Modifiers<\/strong> and Non-Access Modifiers<\/strong>. Access modifiers determine the visibility of classes and their members, while non-access modifiers control aspects like immutability or the necessity of subclass implementation. Visit the detailed tutorial here. <\/a><\/p>\n\n\n\n

Access Modifiers<\/h2>\n\n\n\n

In Java, access modifiers determine who can access or modify classes, attributes, and methods. These modifiers help manage access control within your program, ensuring that important data is protected while allowing access to essential functionalities. There are three primary access modifiers in Java: public<\/strong>, private<\/strong>, and protected<\/strong>.<\/p>\n\n\n\n

Let\u2019s explore these access modifiers step by step, using the Calculator<\/strong> program.<\/p>\n\n\n\n

public class Calculator {\n\n    \/\/ Attributes of the class\n    private int a;\n    private int b;\n\n    \/\/ Method for sum\n    public int sum(int a, int b) {\n        return a + b;\n    }\n\n    \/\/ Method for subtraction\n    public int subtract(int a, int b) {\n        return a - b;\n    }\n\n    \/\/ Method for multiplication\n    public int multiply(int a, int b) {\n        return a * b;\n    }\n}<\/code><\/pre>\n\n\n\n
Public Modifier<\/strong><\/h3>\n\n\n\n
\"\"<\/figure>\n\n\n\n
When you declare a class, method, or variable as public<\/strong>, it can be accessed from anywhere in your program. In the example above, the Calculator<\/code> class is declared public<\/strong>:<\/p>\n\n\n\n
public class Calculator { \n     public int a;\n     public int b;\n\npublic int sum(a, b) {\n        return a + b;\n    }\n\n}<\/code><\/pre>\n\n\n\n
This means that any other class<\/strong> can create an object of the Calculator<\/code> class and use its methods. For example, you could create an object of this class and use its methods like this:<\/p>\n\n\n\n
Calculator calc = new Calculator();\nint result = calc.sum(10, 5);<\/code><\/pre>\n\n\n\n
Here, the sum<\/code>, subtract<\/code>, and multiply<\/code> methods are also declared public<\/strong>:<\/p>\n\n\n\n
public int sum(int a, int b) { \n    return a + b; \n}<\/code><\/pre>\n\n\n\n
Since these methods are public, they are accessible from anywhere<\/strong> in your code. So, if another class wants to call any of these methods, it can do so without any restrictions. You use the public<\/strong> modifier when you want methods or attributes to be available for interaction with other classes<\/strong>.<\/p>\n\n\n\n
Private Modifier<\/strong><\/h3>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The private<\/strong> modifier is used to restrict access to certain variables or methods within the class itself. It means that anything declared private can only be accessed inside that class<\/strong> and cannot be accessed or modified directly by any other class.<\/p>\n\n\n\n
In Calculator<\/code> program, the attributes a<\/code> and b<\/code> are declared private:<\/p>\n\n\n\n
private int a;\nprivate int b;<\/code><\/pre>\n\n\n\n
These variables are only accessible<\/strong> inside the Calculator<\/code> class. No other class can directly access or modify these values. For example, this line of code would cause an error:<\/p>\n\n\n\n
Calculator calc = new Calculator();\ncalc.a = 10; \/\/ Error: 'a' has private access in 'Calculator'<\/code><\/pre>\n\n\n\n
This is important for data protection<\/strong>. By making the variables private, you ensure that other parts of the program can\u2019t change the values of a<\/code> and b<\/code> unless you explicitly allow it through public methods<\/strong>. In your program, you provide public methods like sum<\/code> and subtract<\/code> that use the values of a<\/code> and b<\/code> indirectly. This is called encapsulation<\/strong>\u2014hiding the details but exposing the necessary functionality.<\/p>\n\n\n\n
If you ever need to allow access to a<\/code> and b<\/code> (but still keep control), you can create getter<\/strong> and setter<\/strong> methods like this:<\/p>\n\n\n\n
public int getA() {\n    return a;\n}\n\npublic void setA(int value) {\n    this.a = value;\n}<\/code><\/pre>\n\n\n\n
Protected Modifier<\/strong><\/h3>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The protected<\/strong> modifier allows access to a variable or method within the same package and to subclasses<\/strong> (even if those subclasses are in different packages). This is especially useful in the context of inheritance<\/strong>.<\/p>\n\n\n\n
 For example, if you have a class that extends Calculator<\/code> and you want certain methods or variables to be accessible only to that subclass or classes in the same package, you would use the protected modifier:<\/p>\n\n\n\n
public class Calculator {\r\n\r\n    \/\/ Attributes of the class\r\n    protected int a;\r\n    protected int b;\r\n\r\n    \/\/ Method for sum\r\n    protected int sum(int a, int b) {\r\n        return a + b;\r\n    }\r\n\r\n    \/\/ Method for subtraction\r\n    protected int subtract(int a, int b) {\r\n        return a - b;\r\n    }\r\n\r\n    \/\/ Method for multiplication\r\n    protected int multiply(int a, int b) {\r\n        return a * b;\r\n    }\r\n}\r\n\r\npublic class Calculator1 extends Calculator {\r\n\r\n    public void calculate() {\r\n        \/\/ Using the protected members from the Calculator class\r\n        this.a = 10; \/\/ setting value for a\r\n        this.b = 5;  \/\/ setting value for b\r\n        \r\n        System.out.println(\"Sum: \" + sum(a, b));\r\n        System.out.println(\"Subtract: \" + subtract(a, b));\r\n        System.out.println(\"Multiply: \" + multiply(a, b));\r\n    }\r\n\r\n    public static void main(String[] args) {\r\n        Calculator1 calc = new Calculator1();\r\n        calc.calculate();\r\n    }\r\n}\r\n<\/code><\/pre>\n\n\n\n
This method can be accessed by classes in the same package or by any class that inherits<\/strong> from Calculator<\/code>. However, it cannot be accessed from a completely unrelated class.<\/p>\n\n\n\n
\n