access specifiers in java
TRANSCRIPT
Access Specifiers in Java
There are 3 access specifiers in Java: public, private, protected. There is a <no-access-specifier> i.e a method or class defined without any access specifier.
An access specifier tells us which entity cannot be accessed from where in a program.
Access modifiers can be defined at two levels, Class level and member level.
Class level: There are two access specifiers that are valid at the class level. They are Public and <none>. So, when we define a class, we can do it either of the ways:
Public class a{
}
OR
Class a{
}
If a class is defined as public, it can be accessed from outside world i.e from different packages.If a class is defined w/o any access specifier, it cannot be accessed from different packages.
Member Level: Member level means for class variables or class methods level.
Class a{
<access-specifier> int var;
}
class a{
<access-specifier> void method(){
}}
Examples:
1. Class a{private int number1;public int number2;}
2. class a{
private int number1;public int number2;
private void method1(){
}
public void method2(){
}
}
Private Access specifier : We will be seeing several examples to illustrate the usage of private access specifier.Private access specifier can be used with variables and methods in a class.
Case 1: In case of variables, we will see what happens if a variable is declared as “Private”. We use the keyword ‘Private’ in front of the variable to declare it as a private variable.
Example:
Class Test{
private int number;
public void Testmethod(){
System.out.println(“I want to print the private variable within this class:”+number);
}}
public class mainClass {public static void main(String[] args){
Test t = new Test();t.Testmethod();
}
We have a class defined ‘Test’. That class has a private variable defined ‘number’. When a variable is declared as private, it can be accessed only from within that class. So, the variable number can only be accessed by the method Testmethod() belonging to class Test.
In our main method of class mainClass, we are creating an instance of the class Test, because this is how we access instance methods.
Another example to illustrate the difference between a variable declared as public Vs private.
Class Test{
private int number = 4;public int number1 = 3;
public void Testmethod(){
System.out.println(“I want to print the private variable within this class:”+number);
}}
public class mainClass {public static void main(String[] args){
Test t = new Test();System.out.println(t.number);System.out.println(t.number1);
}
We see a compile time error with the above program, since it is a private variable and cannot be accessed outside the class.
If a variable is declared as public as in case of ‘number1’ in the above example, we can access it from outside the class, i.e mainClass. This example clearly illustrates the difference between variables declared as ‘public’ and ‘private’.
Case 2: Private access specifier can also be used with methods in a class. Below example illustrates how it can declared and where can it be accessed from.Example:
Class Test{
private int number;
private void Testmethod(){
System.out.println(“I want to print the private variable within this class:”+number);
}}
public class mainClass {public static void main(String[] args){
Test t = new Test();t.Testmethod();
}}
In the above example, the method ‘Testmethod’ is declared as private. When we try to execute this program, we see an error saying ‘method has private access in class Test’. So, how can we use the private methods, infact how can we access them? We can do so using a method declared as ‘public’ or method with no access specifier.
Example:
Class Test{
private int number;public int number1;private void Testmethod(){
System.out.println(“I want to print the private variable within this class:”+number);
}
public void AccessPrivateMethod()
{System.out.println(“We can access private method declared in this class here:”);Testmethod();
}void noSpecifierMethod(){
System.out.println(“I can access private method from a non specifier method too:”);Testmethod();
}
}
public class mainClass {public static void main(String[] args){
Test t = new Test();t.AccessPrivateMethod();System.out.println(“ I can print the class variable:”+t.number1);
}}
Also note that a private variable can be accessed by a private method defined in the same class. So, anything declared as ‘private’ means only can be accessed in that class and not from anywhere else.
We covered both ‘public’ and ‘private’ access specifiers in above examples. The other specifier remaining is ‘protected’ and ‘no access specifier’. We cover ‘protected’ access specifier when we do Inheritance concept in OOP.
No access specifier: We look into member level access specifier i.e at both variables and methods level in a class. We would want to look into situations where in no access modifier is specified.
Example:
Class Test{
int number;private void Testmethod(){
System.out.println(“I want to print the variable with no specifier within this class:”+number);
}
}
public class mainClass {public static void main(String[] args){
Test t = new Test();System.out.println(“ I can print the class variable:”+t.number);
}}
When a variable’s access specifier is not specified, it can be accessed from with the same class, from within another class in same package, but not from anywhere outside of this package.