Encapsulation in Java

 Difficulty Level : Easy

 Last Updated : 18 Feb, 2021

Encapsulation is defined as the wrapping up of data under a single unit. It is the

mechanism that binds together code and the data it manipulates. Another way to think
about encapsulation is, it is a protective shield that prevents the data from being accessed
by the code outside this shield. 
 
 Technically in encapsulation, the variables or data of a class is hidden from any
other class and can be accessed only through any member function of its own class in
which it is declared.
 As in encapsulation, the data in a class is hidden from other classes using the data
hiding concept which is achieved by making the members or methods of a class
private, and the class is exposed to the end-user or the world without providing any
details behind implementation using the abstraction concept, so it is also known as
a combination of data-hiding and abstraction.
 Encapsulation can be achieved by Declaring all the variables in the class as private
and writing public methods in the class to set and get the values of variables

The program to access variables of the class EncapsulateDemo is shown below:  

 Java

// Java program to demonstrate encapsulation

class Encapsulate {
    // private variables declared

    // these can only be accessed by

    // public methods of class

    private String geekName;

    private int geekRoll;

    private int geekAge;

    // get method for age to access

    // private variable geekAge

    public int getAge() { return geekAge; }

    // get method for name to access

    // private variable geekName

    public String getName() { return geekName; }

    // get method for roll to access

    // private variable geekRoll

    public int getRoll() { return geekRoll; }

 
    // set method for age to access

    // private variable geekage

    public void setAge(int newAge) { geekAge = newAge; }

    // set method for name to access

    // private variable geekName

    public void setName(String newName)

    {

        geekName = newName;

    }

    // set method for roll to access

    // private variable geekRoll

    public void setRoll(int newRoll) { geekRoll = newRoll; }

public class TestEncapsulation {

    public static void main(String[] args)

    {
         Encapsulate obj = new Encapsulate();

        // setting values of the variables

        obj.setName("Harsh");

        obj.setAge(19);

        obj.setRoll(51);

        // Displaying values of the variables

        System.out.println("Geek's name: " + obj.getName());

        System.out.println("Geek's age: " + obj.getAge());

        System.out.println("Geek's roll: " + obj.getRoll());

        // Direct access of geekRoll is not possible

        // due to encapsulation

        // System.out.println("Geek's roll: " +

        // obj.geekName);

    }

Output
Geek's name: Harsh
Geek's age: 19
 Geek's roll: 51
In the above program, the class EncapsulateDemo is encapsulated as the variables are
declared as private. The get methods like getAge() , getName() , getRoll() are set as
public, these methods are used to access these variables. The setter methods like
setName(), setAge(), setRoll() are also declared as public and are used to set the values of
the variables.

Advantages of Encapsulation:  
 Data Hiding: The user will have no idea about the inner implementation of the
class. It will not be visible to the user how the class is storing values in the variables.
The user will only know that we are passing the values to a setter method and
variables are getting initialized with that value.
 Increased Flexibility: We can make the variables of the class as read-only or
write-know that only depending on our requirement. If we wish to make the variables
read-only then we have to omit the setter methods like setName(), setAge(), etc. from
the above program or if we wish to make the variables as write-only then we have to
omit the get methods like getName(), getAge(), etc. from the above program
 Reusability: Encapsulation also improves the re-usability and easy to change with
new requirements.
 Testing code is easy: Encapsulated code is easy to test for unit testing.
This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like
to contribute, you can also write an article using contribute.geeksforgeeks.org or mail
your article to [email protected]. See your article appearing on the
GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more
information about the topic discussed above.
 

Polymorphism in Java
 Difficulty Level : Easy
 Last Updated : 01 Dec, 2020

The word polymorphism means having many forms. In simple words, we can define
polymorphism as the ability of a message to be displayed in more than one form.
Real life example of polymorphism: A person at the same time can have different
characteristic. Like a man at the same time is a father, a husband, an employee. So the
same person posses different behavior in different situations. This is called
polymorphism.
Polymorphism is considered one of the important features of Object-Oriented
Programming. Polymorphism allows us to perform a single action in different ways. In
other words, polymorphism allows you to define one interface and have multiple
implementations. The word “poly” means many and “morphs” means forms, So it means
many forms.
In Java polymorphism is mainly divided into two types:
 Compile time Polymorphism
 Runtime Polymorphism
1. Compile-time polymorphism: It is also known as static polymorphism. This type of
polymorphism is achieved by function overloading or operator overloading. But Java
doesn’t support the Operator Overloading.

Method Overloading: When there are multiple functions with same name but different
parameters then these functions are said to be overloaded. Functions can be overloaded
by change in number of arguments or/and change in type of arguments.
Example: By using different types of arguments
// Java program for Method overloading

  

class MultiplyFun {

  

    // Method with 2 parameter

    static int Multiply(int a, int b)

    {

        return a * b;

    }

  

    // Method with the same name but 2 double parameter

    static double Multiply(double a, double b)

    {

        return a * b;

    }

  

class Main {

    public static void main(String[] args)

     {

  

        System.out.println(MultiplyFun.Multiply(2, 4));

  

        System.out.println(MultiplyFun.Multiply(5.5, 6.3));

    }

Output:
8
34.65
Example 2: By using different numbers of arguments

// Java program for Method overloading

  

class MultiplyFun {

  

    // Method with 2 parameter

    static int Multiply(int a, int b)

    {

        return a * b;

    }
   

    // Method with the same name but 3 parameter

    static int Multiply(int a, int b, int c)

    {

        return a * b * c;

    }

  

class Main {

    public static void main(String[] args)

    {

        System.out.println(MultiplyFun.Multiply(2, 4));

  

        System.out.println(MultiplyFun.Multiply(2, 7, 3));

    }

Output:
8
42
2. Runtime polymorphism: It is also known as Dynamic Method Dispatch. It is a process
in which a function call to the overridden method is resolved at Runtime. This type of
polymorphism is achieved by Method Overriding.
Method overriding, on the other hand, occurs when a derived class has a definition for
one of the member functions of the base class. That base function is said to
be overridden.
Example:

// Java program for Method overriding

  

class Parent {

  

    void Print()

    {

        System.out.println("parent class");

    }

  

class subclass1 extends Parent {

  

    void Print()

    {

        System.out.println("subclass1");

    }

}
  

class subclass2 extends Parent {

  

    void Print()

    {

        System.out.println("subclass2");

    }

  

class TestPolymorphism3 {

    public static void main(String[] args)

    {

  

        Parent a;

  

        a = new subclass1();

        a.Print();

  

        a = new subclass2();

         a.Print();

    }

Output:
subclass1
subclass2

Abstraction in Java
 Difficulty Level : Easy
 Last Updated : 17 May, 2021

Data Abstraction is the property by virtue of which only the essential details are
displayed to the user. The trivial or the non-essentials units are not displayed to
the user. Ex: A car is viewed as a car rather than its individual components.
Data Abstraction may also be defined as the process of identifying only the
required characteristics of an object ignoring the irrelevant details. The
properties and behaviors of an object differentiate it from other objects of similar
type and also help in classifying/grouping the objects.
Consider a real-life example of a man driving a car. The man only knows that
pressing the accelerators will increase the speed of car or applying brakes will
stop the car, but he does not know about how on pressing the accelerator the
speed is actually increasing, he does not know about the inner mechanism of
the car or the implementation of the accelerator, brakes, etc in the car. This is
what abstraction is. 
In java, abstraction is achieved by interfaces and abstract classes. We can
achieve 100% abstraction using interfaces.
Abstract classes and Abstract methods :  

1. An abstract class is a class that is declared with abstract keyword.

2. An abstract method is a method that is declared without implementation.
3. An abstract class may or may not have all abstract methods. Some of
them can be concrete methods
4. A method defined abstract must always be redefined in the subclass, thus
making overriding compulsory OR either make subclass itself abstract.
5. Any class that contains one or more abstract methods must also be
declared with abstract keyword.
6. There can be no object of an abstract class. That is, an abstract class can
not be directly instantiated with the new operator.
7. An abstract class can have parameterized constructors and default
constructor is always present in an abstract class.
When to use abstract classes and abstract methods with an example
There are situations in which we will want to define a superclass that declares
the structure of a given abstraction without providing a complete implementation
of every method. That is, sometimes we will want to create a superclass that
only defines a generalization form that will be shared by all of its subclasses,
leaving it to each subclass to fill in the details.
Consider a classic “shape” example, perhaps used in a computer-aided design
system or game simulation. The base type is “shape” and each shape has a
color, size and so on. From this, specific types of shapes are derived(inherited)-
circle, square, triangle and so on — each of which may have additional
characteristics and behaviors. For example, certain shapes can be flipped.
Some behaviors may be different, such as when you want to calculate the area
of a shape. The type hierarchy embodies both the similarities and differences
between the shapes.
 
 Java

// Java program to illustrate the

// concept of Abstraction

abstract class Shape {

    String color;

    // these are abstract methods

    abstract double area();

    public abstract String toString();

 

    // abstract class can have constructor

    public Shape(String color)

    {

        System.out.println("Shape constructor called");

        this.color = color;

    }

    // this is a concrete method

    public String getColor() { return color; }

class Circle extends Shape {

    double radius;

    public Circle(String color, double radius)

    {

        // calling Shape constructor

        super(color);
        System.out.println("Circle constructor called");

        this.radius = radius;

    }

    @Override double area()

    {

        return Math.PI * Math.pow(radius, 2);

    }

    @Override public String toString()

    {

        return "Circle color is " + super.getColor()

            + "and area is : " + area();

    }

class Rectangle extends Shape {

    double length;

    double width;
 

    public Rectangle(String color, double length,

                     double width)

    {

        // calling Shape constructor

        super(color);

        System.out.println("Rectangle constructor called");

        this.length = length;

        this.width = width;

    }

    @Override double area() { return length * width; }

    @Override public String toString()

    {

        return "Rectangle color is " + super.getColor()

            + "and area is : " + area();

    }

}
 public class Test {

    public static void main(String[] args)

    {

        Shape s1 = new Circle("Red", 2.2);

        Shape s2 = new Rectangle("Yellow", 2, 4);

        System.out.println(s1.toString());

        System.out.println(s2.toString());

    }

Output
Shape constructor called
Circle constructor called
Shape constructor called
Rectangle constructor called
Circle color is Redand area is : 15.205308443374602
Rectangle color is Yellowand area is : 8.0
Encapsulation vs Data Abstraction
1. Encapsulation is data hiding(information hiding) while Abstraction is detail
hiding(implementation hiding).
2. While encapsulation groups together data and methods that act upon the
data, data abstraction deals with exposing the interface to the user and
hiding the details of implementation.
Advantages of Abstraction
1. It reduces the complexity of viewing the things.
2. Avoids code duplication and increases reusability.
3. Helps to increase security of an application or program as only important
details are provided to the user.