Access Modifiers 
Tags: java, ocpjp, 100daysofocpjp, day1
Published: 2021-06-07 19:25:24

In the Java programming language, we can see two main types of modifiers which are access modifiers and non-access modifiers. 

### Access modifiers
- public
- protected
- default
- private

### Non-access modifiers
- static
- final
- abstract
- synchronized
- volatile
- transient
- native
- strictfp

In this article, I am going to talk about access modifiers.

Access modifiers are responsible to define the scope, to where elements such as methods, variables of a code are visible.

### private 

- The private access modifier is accessible only from the class.
- Private access modifier is not applicable for classes and interfaces
- Applicable to methods, properties, and constructors

```java
package temp;

class A{
	private int x;
}

class B{
	A a = new A();
	System.out.println(a.x);
}
```

The above code has a syntax error. Because cannot access `x` from class B, since it is modified as `private` in class A. So `x` is accessible only from class A.

### default

- When the developer not defined access modifiers explicitly, that member has the default access modifier.
- default access modifier is visible to all classes in the same package. So-called package-private

```java
package temp;

class A{
	int x;
}

class B{
	A a = new A();
	System.out.println(a.x);
}
```
 
Now in the above example, can access `x` from Class B. Because `x` is modified as default and `A` and `B` both classes are in the same package.

```java
package temp;

class A{
	int x;
}


package temp2;

class C extends B{
	void m(){
		System.out.println(x);
	}
}
```

In the above code, even class `C` has extended class `B`, inside the class `C` cannot access `x`. Because `x` is modified as default and class trying to access `x` from a different package. 

### Protected

- protected access modifier is visible to the same package
- protected access modifier is also visible to other packages, but only via a subclass
- applicable for constructor, method, and property

```java
package temp;

class A{
	protected int x;
}


package temp2;

class C extends B{
	void m(){
		System.out.println(x);
	}
}
```

In the above example from the `C` class of package `temp2` can access `x` which is defined in `A` class in package `temp` because x has the protected access modifier. Also, `x` will be accessible to the Child classes of C.

### public

- accessible to everywhere
- applicable to classes, interfaces, properties, methods, constructors

```java
package temp;

class A{
	public int x;
}


package temp;

class D{
	void method(){
		A a = new A();
		System.out.println(a.x);
	}
}
```

In the above code, `x` variable of the class `A` is accessible to everywhere of the code. So can access `x` from class D in the package `temp2`.

### Comparison

#### public 
- within class                          : yes
- within package                    : yes
- outside package by inherit : yes
- outside the package            : yes

#### protected 
- within class                        : yes
- within package                    : yes
- outside package by inherit : yes
- outside the package           : no

#### default
- within class                          : yes
- within package                    : yes
- outside package by inherit : no
- outside the package           : no

#### private 
- within class                          : yes
- within package                    : no
- outside package by inherit : no
- outside the package           : no