Introducing Radical.sh

Forget Code launches a powerful code generator for building API's

Access Specifiers(Public,Protected,Private) ,Static and Non Stating Member Functions and Variables in Java

  1. Forget Code
  2. Java
  3. Access Specifiers(Public,Protected,Private) ,Static and Non Stating Member Functions and Variables
Access Specifiers:
In order to Restrict the access over the programs we have 3 types of access specifiers
1.Public
2.Private
3.Protected
Access Specifier Table

specifier/modifierlocal variableinstance variablemethodclass
publicNAAAA
protectedNAAANA
defaultAAAA
privateNAAANA
finalAAAA
staticNAAANA
synchronizedNANAANA
nativeNANAANA
volatileNAANANA
transientNAANANA
strictfpNANAAA

A: Allowed NA: Not Allowed


Public:
public classes, methods, and fields can be accessed from everywhere. The only constraint is that a file with Java source code can only contain one public class whose name must also match with the filename. If it exists, this public class represents the application or the applet, in which case the public keyword is necessary to enable your Web browser or appletviewer to show the applet. You use public classes, methods, or fields only if you explicitly want to offer access to these entities and if this access cannot do any harm. An example of a square determined by the position of its upper-left corner and its size:
public class Square { // public class
public x, y, size; // public instance variables
}


Protected:
protected methods and fields can only be accessed within the same class to which the methods and fields belong, within its subclasses, and within classes of the same package, but not from anywhere else. You use the protected access level when it is appropriate for a class's subclasses to have access to the method or field, but not for unrelated classes.


default (no specifier)
If you do not set access to specific level, then such a class, method, or field will be accessible from inside the same package to which the class, method, or field belongs, but not from outside this package. This access-level is convenient if you are creating packages. For example, a geometry package that contains Square and Tiling classes, may be easier and cleaner to implement if the coordinates of the upper-left corner of a Square are directly available to the Tiling class but not outside the geometry package.


Private:
private methods and fields can only be accessed within the same class to which the methods and fields belong. private methods and fields are not visible within subclasses and are not inherited by subclasses. So, the private access specifier is opposite to the public access specifier. It is mostly used for encapsulation: data are hidden within the class and accessor methods are provided. An example, in which the position of the upper-left corner of a square can be set or obtained by accessor methods, but individual coordinates are not accessible to the user.
public class Square { // public class
private double x, y // private (encapsulated) instance variables
public setCorner(int x, int y) { // setting values of private fields
this.x = x;
this.y = y;
}
public getCorner() { // setting values of private fields
return Point(x, y);
}
}


Static and Non Static Member Functions:
Static Functions:
It is a method which belongs to the class and not to the object(instance)
A static method can access only static data. It can not access non-static data (instance variables)
A static method can call only other static methods and can not call a non-static method from it.
A static method can be accessed directly by the class name and doesn’t need any object
Syntax : <class-name>.<method-name>
A static method cannot refer to “this” or “super” keywords in anyway


Non-Static Function:
It is a method which belongs to the class and it cannot be accessed without the object of the class.


Static and Non Static member variable:
Static Variable:
It is a variable which belongs to the class and not to object(instance)
Static variables are initialized only once,at the start of the execution.These variables will be initialized first, before the initialization of any instance variables
A single copy to be shared by all instances of the class
A static variable can be accessed directly by the class name and doesn’t need any object
Syntax : <class-name>.<variable-name>


Non -Static Variable:
It doesnt retain/update the value .
It doesnt have the global scope because its usually act as local variable.


  1.  
  2. import java.io.*;
  3.  
  4. class student {
  5.  
  6.     static int count;//Does not Require initialization.
  7.     int count1 = 0;//Non Static Member Variable must to be initialized
  8.  
  9.     student() {
  10.         acc_details();//Accessed only within the class
  11.     }
  12.  
  13.     public static void stu_details()//static method can be called without the object
  14.     {
  15.         System.out.println("Name:XXXX");
  16.         System.out.println("Roll No:123456");
  17.         count++;
  18.         //count1++;here it cannot be used because non static member could not be used in the static function
  19.     }
  20.  
  21.     private void acc_details()//non static method can be called only with the object
  22.     {
  23.         System.out.println("Entered into Private Access Specifiers");
  24.         System.out.println("Password:*******");
  25.         count++;
  26.         count1++;
  27.     }
  28.  
  29.     protected void att_details()//non static method can be called only with the object
  30.     {
  31.         System.out.println("Attendance Details");
  32.         count++;
  33.         count1++;
  34.  
  35.     }
  36. }
  37.  
  38. class staff extends student {
  39.  
  40.     protected static void sta_details()//static method can be called without the object
  41.     {
  42.         count++;
  43.         //count1++;here it cannot be used because non static member could not be used in the static function
  44.         System.out.println("Name:YYYY");
  45.  
  46.     }
  47. }
  48.  
  49. class hod extends staff {
  50.  
  51.     protected static void hod_details()//static method can be called without the object
  52.     {
  53.         count++;
  54.  
  55.         //count1++;here it cannot be used because non static member could not be used in the static function
  56.  
  57.         System.out.println("Name:ZZZ");
  58.  
  59.     }
  60. }
  61.  
  62. class college extends hod {
  63.  
  64.     public static void main(String a[]) {
  65.  
  66.  
  67.         stu_details();//College can view the student details because it is in public mode 
  68.         /*
  69.          * static method can be called without the object .If you didnt specify
  70.          * as static during the declaration of this function you will get an
  71.          * error message during the calling of this function
  72.          */
  73.  
  74.         sta_details();//College can view the staff details because it is in public mode
  75.         /*
  76.          * static method can be called without the object .If you didnt specify
  77.          * as static during the declaration of this function you will get an
  78.          * error message during the calling of this function
  79.          */
  80.  
  81.         hod_details();//College can view the hod details because it is in public mode
  82.         /*
  83.          * static method can be called without the object .If you didnt specify
  84.          * as static during the declaration of this function you will get an
  85.          * error message during the calling of this function
  86.          */
  87.  
  88.  
  89.         staff s1 = new staff();
  90.         s1.stu_details();//staff can also view the student details because it is in public mode
  91.  
  92.  
  93.         hod s2 = new hod();
  94.         s2.stu_details();//hod can also view the student details because it is in public mode
  95.  
  96.         s1.att_details();//staff can also view the student attendance details because it is inherited so it has an access over protected details.
  97.  
  98.  
  99.         s2.att_details();//staff can also view the student attendance details because it is inherited so it has an access over protected details.
  100.  
  101.  
  102.         //acc_details() cannot not be viewed by any of the classes like staff,hod and college becuase it is in private mode.
  103.         student s = new student();
  104.         //s.acc_details(); it cannot be called because private mode function only accessed within the function.
  105.         s.stu_details();
  106.         s.att_details();
  107.  
  108.         System.out.println("Count value without object:" + count);//count variable can be called without an object
  109.         //System.out.println("Count1 Value:" + count1); count1 variable cannot be called without an object because it is non-static
  110.         System.out.println("Count value with object of class student:" + s.count);
  111.         System.out.println("Count value with object of class staff:" + s1.count);
  112.         System.out.println("Count value with object of class hod:" + s2.count);
  113.         System.out.println("Count1 value with object of class student:" + s.count1);
  114.         System.out.println("Count1 value with object of class staff:" + s1.count1);
  115.         System.out.println("Count1 value with object of class hod:" + s2.count1);
  116.     }
  117. }