@1 Access Modifiers in Java

There are two types of modifiers in Java: access modifiers and non-access modifiers.

The access modifiers in Java specifies the accessibility or scope of a field, method,
constructor, or class. We can change the access level of fields, constructors, methods, and
class by applying the access modifier on it.

There are four types of Java access modifiers:

1. Private: The access level of a private modifier is only within the class. It
cannot be accessed from outside the class.
2. Default: The access level of a default modifier is only within the package. It
cannot be accessed from outside the package. If you do not specify any access
level, it will be the default.
3. Protected: The access level of a protected modifier is within the package and
outside the package through child class. If you do not make the child class, it
cannot be accessed from outside the package.
4. Public: The access level of a public modifier is everywhere. It can be accessed
from within the class, outside the class, within the package and outside the
package.

There are many non-access modifiers, such as static, abstract, synchronized, native,
volatile, transient, etc. Here, we are going to learn the access modifiers only.

Advertisement

Understanding Java Access Modifiers

Let's understand the access modifiers in Java by a simple table.

Access Modifier within class within package outside package outside package
by subclass only

Private Y N N N

Default Y Y N N

Protected Y Y Y N

Public Y Y Y Y

1) Private

The private access modifier is accessible only within the class.

Simple example of private access modifier

In this example, we have created two classes A and Simple. A class contains private data
member and private method. We are accessing these private members from outside the
class, so there is a compile-time error.

. class A{
. private int data=40;
. private void msg(){System.out.println("Hello java");}
. }
.
. public class Simple{
. public static void main(String args[]){
. A obj=new A();
. System.out.println(obj.data);//Compile Time Error
. obj.msg();//Compile Time Error
. }
. }

Role of Private Constructor

If you make any class constructor private, you cannot create the instance of that class from
outside the class. For example:

. class A{
. private A(){}//private constructor
. void msg(){System.out.println("Hello java");}
. }
. public class Simple{
. public static void main(String args[]){
. A obj=new A();//Compile Time Error
. }
. }

Note: A class cannot be private or protected except nested class.

2) Default

If you don't use any modifier, it is treated as default by default. The default modifier is
accessible only within package. It cannot be accessed from outside the package. It
provides more accessibility than private. But, it is more restrictive than protected, and
public.

Example of default access modifier

In this example, we have created two packages pack and mypack. We are accessing the A
class from outside its package, since A class is not public, so it cannot be accessed from
outside the package.

. //save by A.java
. package pack;
. class A{
. void msg(){System.out.println("Hello");}
. }
. //save by B.java
. package mypack;
. import pack.*;
. class B{
. public static void main(String args[]){
. A obj = new A();//Compile Time Error
. obj.msg();//Compile Time Error
. }
. }
In the above example, the scope of class A and its method msg() is default so it cannot be
accessed from outside the package.

3) Protected

The protected access modifier is accessible within package and outside the package but
through inheritance only.

The protected access modifier can be applied on the data member, method and
constructor. It can't be applied on the class.

It provides more accessibility than the default modifer.

Example of protected access modifier

In this example, we have created the two packages pack and mypack. The A class of pack
package is public, so can be accessed from outside the package. But msg method of this
package is declared as protected, so it can be accessed from outside the class only
through inheritance.

. //save by A.java
. package pack;
. public class A{
. protected void msg(){System.out.println("Hello");}
. }

. //save by B.java
. package mypack;
. import pack.*;
.
. class B extends A{
. public static void main(String args[]){
. B obj = new B();
. obj.msg();
. }
. }

Output:Hello
 4) Public

The public access modifier is accessible everywhere. It has the widest scope among all
other modifiers.

Example of public access modifier

. //save by A.java
.
. package pack;
. public class A{
. public void msg(){System.out.println("Hello");}
. }

. //save by B.java
.
. package mypack;
. import pack.*;
.
. class B{
. public static void main(String args[]){
. A obj = new A();
. obj.msg();
. }
. }

Output:Hello

Java Access Modifiers with Method Overriding

If you are overriding any method, overridden method (i.e. declared in subclass) must not
be more restrictive.

. class A{
. protected void msg(){System.out.println("Hello java");}
. }
.
. public class Simple extends A{
. void msg(){System.out.println("Hello java");}//C.T.Error
. public static void main(String args[]){
. Simple obj=new Simple();
. obj.msg();
. }
. }
The default modifier is more restrictive than protected. That is why, there is a compile-time
error.

@2 Inheritance in Java
Inheritance in Java is a mechanism in which one object acquires all the properties and
behaviors of a parent object. It is an important part of OOPs (Object Oriented programming
system).

The idea behind inheritance in Java is that you can create new classes that are built upon
existing classes. When you inherit from an existing class, you can reuse methods and fields
of the parent class. Moreover, you can add new methods and fields in your current class
also.

Inheritance represents the IS-A relationship which is also known as a parent-

child relationship.

Why use inheritance in java

o For Method Overriding (so runtime polymorphism can be achieved).

o For Code Reusability.

Terms used in Inheritance

o Class: A class is a group of objects which have common properties. It is a

template or blueprint from which objects are created.
o Sub Class/Child Class: Subclass is a class which inherits the other class. It is
also called a derived class, extended class, or child class.
o Super Class/Parent Class: Superclass is the class from where a subclass
inherits the features. It is also called a base class or a parent class.
o Reusability: As the name specifies, reusability is a mechanism which
facilitates you to reuse the fields and methods of the existing class when you
create a new class. You can use the same fields and methods already defined
in the previous class.

The syntax of Java Inheritance

. class Subclass-name extends Superclass-name

. {
. //methods and fields
. }
The extends keyword indicates that you are making a new class that derives from an
existing class. The meaning of "extends" is to increase the functionality.

In the terminology of Java, a class which is inherited is called a parent or superclass, and
the new class is called child or subclass.

Java Inheritance Example

 As displayed in the above figure, Programmer is the subclass and Employee is the
superclass. The relationship between the two classes is Programmer IS-A Employee. It
means that Programmer is a type of Employee.

. class Employee{
. float salary=40000;
. }
. class Programmer extends Employee{
. int bonus=10000;
. public static void main(String args[]){
. Programmer p=new Programmer();
. System.out.println("Programmer salary is:"+p.salary);
. System.out.println("Bonus of Programmer is:"+p.bonus);
. }
. }

Programmer salary is:40000.0

Bonus of programmer is:10000

In the above example, Programmer object can access the field of own class as well as of
Employee class i.e. code reusability.

Types of inheritance in java

On the basis of class, there can be three types of inheritance in java: single, multilevel and
hierarchical.

In java programming, multiple and hybrid inheritance is supported through interface only.
We will learn about interfaces later.
 Note: Multiple inheritance is not supported in Java through class.
When one class inherits multiple classes, it is known as multiple inheritance. For Example:

Single Inheritance Example

When a class inherits another class, it is known as a single inheritance. In the example
given below, Dog class inherits the Animal class, so there is the single inheritance.

File: TestInheritance.java

. class Animal{
. void eat(){System.out.println("eating...");}
. }
. class Dog extends Animal{
. void bark(){System.out.println("barking...");}
. }
. class TestInheritance{
. public static void main(String args[]){
. Dog d=new Dog();
. d.bark();
. d.eat();
. }}
Output:

barking...
eating...

Multilevel Inheritance Example

When there is a chain of inheritance, it is known as multilevel inheritance. As you can see
in the example given below, BabyDog class inherits the Dog class which again inherits the
Animal class, so there is a multilevel inheritance.

File: TestInheritance2.java

. class Animal{
. void eat(){System.out.println("eating...");}
. }
. class Dog extends Animal{
. void bark(){System.out.println("barking...");}
. }
. class BabyDog extends Dog{
. void weep(){System.out.println("weeping...");}
. }
. class TestInheritance2{
. public static void main(String args[]){
. BabyDog d=new BabyDog();
. d.weep();
. d.bark();
. d.eat();
. }}
Output:

weeping...
barking...
eating...

Hierarchical Inheritance Example

When two or more classes inherits a single class, it is known as hierarchical inheritance. In
the example given below, Dog and Cat classes inherits the Animal class, so there is
hierarchical inheritance.

File: TestInheritance3.java

. class Animal{
. void eat(){System.out.println("eating...");}
. }
. class Dog extends Animal{
. void bark(){System.out.println("barking...");}
. }
. class Cat extends Animal{
. void meow(){System.out.println("meowing...");}
. }
. class TestInheritance3{
. public static void main(String args[]){
. Cat c=new Cat();
. c.meow();
. c.eat();
. //c.bark();//C.T.Error
. }}
Output:

meowing...
eating...

@3 program:
.
. // Base class
. class BaseClass {
. // Constructor of the base class
. public BaseClass() {
. System.out.println("BaseClass Constructor called.");
. }
.
. // Method in the base class
. public void baseMethod() {
. System.out.println("Method in BaseClass called.");
. }
. }
.
. // Child class that inherits from BaseClass
. class ChildClass extends BaseClass {
. // Constructor of the child class
. public ChildClass() {
. // The constructor of the base class is automatically called here
. System.out.println("ChildClass Constructor called.");
. }
.
. // Method in the child class
. public void childMethod() {
. System.out.println("Method in ChildClass called.");
. }
. }
.
. // Main class to test the inheritance
. public class Main {
. public static void main(String[] args) {
. // Create an object of ChildClass
. ChildClass childObj = new ChildClass();
.
. // Call the method from the base class using the child object
. childObj.baseMethod();
.
. // Call the method from the child class
. childObj.childMethod();
. }
. }

Explanation:

BaseClass:

Has a constructor that prints a message when it is called.

Contains a method baseMethod().

ChildClass:

Inherits from BaseClass and has its own constructor that prints a message.

Contains a method childMethod().

Main Class:

Creates an object of ChildClass.

Calls the baseMethod() from BaseClass using the child object.

Calls the childMethod() from ChildClass.

Output:

mathematica
Copy code
BaseClass Constructor called.ChildClass Constructor called.Method in BaseClass
called.Method in ChildClass called.

This example demonstrates how inheritance works in Java and how the child class can
access the methods of the parent (base) class.