1. Data Abstraction

Data Abstraction is the property by virtue of which only the essential details are displayed to the user. The trivial or non-essential 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 object.

abstract class Geeks {
    abstract void turnOn();
    abstract void turnOff();
}

// Concrete class implementing the abstract methods
class TVRemote extends Geeks {
    @Override
    void turnOn() {
        System.out.println("TV is turned ON.");
    }

    @Override
    void turnOff() {
        System.out.println("TV is turned OFF.");
    }
}

// Main class to demonstrate abstraction
public class Main {
    public static void main(String[] args) {
        Geeks remote = new TVRemote();
        remote.turnOn();
        remote.turnOff();
    }
}

Abstract class

• Supports abstract and non-abstract methods
• Doesn't support multiple inheritance
• Can be extended by Java classes and multiple interfaces
• Class members can be private, protected, etc

Interface

• Can have abstract methods, default methods and static methods
• Supports multiple inheritance
• Can be extended by Java interface only
• Interfaces are public by default

Interfaces

interface testInterface {
    // public, static and final
    final int a = 10;

    // public and abstract
    void display();
}

Multiple Inheritance with Interfaces

// Add interface
interface Add {
    int add(int a, int b);
}

// Sub interface
interface Sub {
    int sub(int a, int b);
}

// Calculator class implementing Add and Sub
class Cal implements Add, Sub {
    // Method to add two numbers
    public int add(int a, int b) {
        return a + b;
    }

    // Method to sub two numbers
    public int sub(int a, int b) {
        return a - b;
    }
}

Default Methods

interface TestInterface {
    final int a = 10;

    default void display() {
        System.out.println("hello");
    }
}

Static Methods

interface TestInterface {
    final int a = 10;

    static void display() {
        System.out.println("hello");
    }
}

Extending Interfaces

interface A {
    void method1();
    void method2();
}

// B now includes method1 and method2
interface B extends A {
    void method3();
}

Development Process with Interfaces and Abstract Classes

In general, the development process is step by step:

1. Level 1 - interfaces: It contains the service details.
2. Level 2 - abstract classes: It contains partial implementation.
3. Level 3 - implementation classes: It contains all implementations.
4. Level 4 - Final Code / Main Method: It have access of all interfaces data.

// Level 1
interface Bank {
    void deposit();
    void withdraw();
    void loan();
    void account();
}

// Level 2
abstract class Dev1 implements Bank {
    public void deposit() {
        System.out.println("Your deposit Amount :" + 100);
    }
}

abstract class Dev2 extends Dev1 {
    public void withdraw() {
        System.out.println("Your withdraw Amount :" + 50);
    }
}

// Level 3
class Dev3 extends Dev2 {
    public void loan() {}
    public void account() {}
}

// Level 4
class Main {
    public static void main(String[] args) {
        Dev3 d = new Dev3();
        d.account();
        d.loan();
        d.deposit();
        d.withdraw();
    }
}

2. Encapsulation

It is defined as the wrapping up of data under a single unit. It is the mechanism that binds together the code and the data it manipulates. Another way to think about encapsulation is that it is a protective shield that prevents the data from being accessed by the code outside this shield.

Technically, in encapsulation, the variables or the data in a class is hidden from any other class and can be accessed only through any member function of the class in which they are declared. In encapsulation, the data in a class is hidden from other classes, which is similar to what data-hiding does. So, the terms "encapsulation" and "data-hiding" are used interchangeably.

Encapsulation can be achieved by declaring all the variables in a class as private and writing public methods in the class to set and get the values of the variables.

class Employee {
    private int empid;
    private String ename;

    // Setter methods
    public void set_id(int empid) {
        this.empid = empid;
    }

    public void set_name(String ename) {
        this.ename = ename;
    }

    // Getter methods
    public int get_id() {
        return empid;
    }

    public String get_name() {
        return ename;
    }
}

3. Inheritance

Inheritance is an important pillar of OOP (Object Oriented Programming). It is the mechanism in Java by which one class is allowed to inherit the features (fields and methods) of another class. We are achieving inheritance by using extends keyword. Inheritance is also known as "is-a" relationship.

Key Terminologies:

• Superclass: The class whose features are inherited is known as superclass (also known as base or parent class).
• Subclass: The class that inherits the other class is known as subclass (also known as derived or extended or child class). The subclass can add its own fields and methods in addition to the superclass fields and methods.
• Reusability: Inheritance supports the concept of "reusability", i.e. when we want to create a new class and there is already a class that includes some of the code that we want, we can derive our new class from the existing class. By doing this, we are reusing the fields and methods of the existing class.

class Bicycle {
    // the Bicycle class has two fields
    public int gear;
    public int speed;

    // the Bicycle class has one constructor
    public Bicycle(int gear, int speed) {
        this.gear = gear;
        this.speed = speed;
    }

    // the Bicycle class has three methods
    public void applyBrake(int decrement) {
        speed -= decrement;
    }

    public void speedUp(int increment) {
        speed += increment;
    }

    // toString() method to print info of Bicycle
    public String toString() {
        return ("No of gears are " + gear + "\n"
                + "speed of bicycle is " + speed);
    }
}

// derived class
class MountainBike extends Bicycle {
    // the MountainBike subclass adds one more field
    public int seatHeight;

    // the MountainBike subclass has one constructor
    public MountainBike(int gear, int speed, int startHeight) {
        // invoking base-class(Bicycle) constructor
        super(gear, speed);
        seatHeight = startHeight;
    }

    // the MountainBike subclass adds one more method
    public void setHeight(int newValue) {
        seatHeight = newValue;
    }

    // overriding toString() method of Bicycle to print more info
    @Override public String toString() {
        return (super.toString() + "\nseat height is " + seatHeight);
    }
}

4. Polymorphism

It refers to the ability of object-oriented programming languages to differentiate between entities with the same name efficiently. This is done by Java with the help of the signature and declaration of these entities. The ability to appear in many forms is called polymorphism.

sleep(1000); //millis
sleep(1000, 2000); //millis,nanos

1. Method Overloading

Also, known as compile-time polymorphism, is the concept of Polymorphism where more than one method share the same name with different signature(Parameters) in a class. The return type of these methods can or cannot be same.

2. Method Overriding

Also, known as run-time polymorphism, is the concept of Polymorphism where method in the child class has the same name, return-type and parameters as in parent class. The child class provides the implementation in the method already written.

class Parent {
    // Can't be overridden
    final void show() {}
}

class Child extends Parent {
    // This would produce error
    void show() {}
}

class Parent {
    // Static method in base class which will be hidden in subclass
    static void m1() {
        System.out.println("From parent static m1()");
    }

    // Non-static method which will be overridden in derived class
    void m2() {
        System.out.println("From parent non-static(instance) m2()");
    }
}

class Child extends Parent {
    // This method hides m1() in Parent
    static void m1() {
        System.out.println("From child static m1()");
    }

    // This method overrides m2() in Parent
    @Override public void m2() {
        System.out.println("From child non-static(instance) m2()");
    }
}

// Driver class
class Geeks {
    public static void main(String[] args) {
        Parent obj1 = new Child();

        // here parents m1 called because static method cannot be overridden
        obj1.m1();

        // Here overriding works and Child's m2() is called
        obj1.m2();
    }
}

/* Output:
From parent static m1()
From child non-static(instance) m2() */

Calling Parent Class Method

We can call the parent class method in the overriding method using the super keyword.

class Parent {
    void show() { System.out.println("Parent's show()"); }
}

// Inherited class
class Child extends Parent {
    // This method overrides show() of Parent
    @Override void show() {
        super.show();
        System.out.println("Child's show()");
    }
}

// Driver class
class Geeks {
    public static void main(String[] args) {
        Parent o = new Child();
        o.show();
    }
}

Overriding and Exception-handling

// Java program to demonstrate overriding when
// superclass method does not declare an exception

class Parent {
    void m1() { System.out.println("From parent m1()"); }
    void m2() { System.out.println("From parent m2()"); }
}

class Child extends Parent {
    @Override
    // no issue while throwing unchecked exception
    void m1() throws ArithmeticException {
        System.out.println("From child m1()");
    }

    @Override
    // compile-time error
    // issue while throwing checked exception
    void m2() throws Exception {
        System.out.println("From child m2");
    }
}

Exceptions

An Exception is an unwanted or unexpected event that occurs during the execution of a program (i.e., at runtime) and disrupts the normal flow of the program's instructions. It occurs when something unexpected things happen, like accessing an invalid index, dividing by zero, or trying to open a file that does not exist.

Java Exception Hierarchy

All exception and error types are subclasses of the class Throwable, which is the base class of the hierarchy. One branch is headed by Exception. This class is used for exceptional conditions that user programs should catch. NullPointerException is an example of such an exception. Another branch, Error is used by the Java run-time system(JVM) to indicate errors having to do with the run-time environment itself(JRE). StackOverflowError is an example of such an error.

1.1 Checked Exceptions

Checked exceptions are called compile-time exceptions because these exceptions are checked at compile-time by the compiler. Examples of Checked Exception are listed below:

• ClassNotFoundException: Throws when the program tries to load a class at runtime but the class is not found because its not present in the correct location or it is missing from the project.
• InterruptedException: Thrown when a thread is paused and another thread interrupts it.
• IOException: Throws when input/output operation fails
• InstantiationException: Thrown when the program tries to create an object of a class but fails because the class is abstract, an interface, or has no default constructor.
• SQLException: Throws when there's an error with the database.
• FileNotFoundException: Thrown when the program tries to open a file that doesn't exist

1.2 Unchecked Exceptions

The unchecked exceptions are just opposite to the checked exceptions. The compiler will not check these exceptions at compile time. In simple words, if a program throws an unchecked exception, and even if we didn't handle or declare it, the program would not give a compilation error. Examples of Unchecked Exception are listed below:

• ArithmeticException: It is thrown when there's an illegal math operation.
• ClassCastException: It is thrown when you try to cast an object to a class it does not belongs to.
• NullPointerException: It is thrown when you try to use a null object (e.g. accessing its methods or fields)
• ArrayIndexOutOfBoundsException: It occurs when we try to access an array element with an invalid index.
• ArrayStoreException: It happens when you store an object of the wrong type in an array.
• IllegalThreadStateException: It is thrown when a thread operation is not allowed in its current state

Default Exception Handling

When an Exception occurs, the JVM Creates an exception object containing the error name, description, and program state. Creating the Exception Object and handling it in the run-time system is called throwing an Exception. There might be a list of the methods that had been called to get to the method where an exception occurred. This ordered list of methods is called Call Stack. Now the following procedure will happen.

1. The run-time system searches the call stack for an Exception handler
2. It starts searching from the method where the exception occurred and proceeds backward through the call stack.
3. If a handler is found, the exception is passed to it.
4. If no handler is found, the default exception handler terminates the program and prints the stack trace.

class DivideByZeroException extends RuntimeException {
    public DivideByZeroException(String m) {
        super(m);
    }
}

Lambda Expressions

You can implement interfaces with lambda

interface FuncInterface {
    // An abstract function
    void abstractFun(int x);

    // A non-abstract (or default) function
    default void normalFun() {
        System.out.println("Hello");
    }
}

class Test {
    public static void main(String args[]) {
        // lambda expression to implement above
        // functional interface. This interface
        // by default implements abstractFun()
        FuncInterface fobj = (int x)->System.out.println(2*x);

        // This calls above lambda expression and prints 10.
        fobj.abstractFun(5);
    }
}

arraylist.forEach(n -> System.out.println(n));

arraylist.forEach(n -> {
    if (n % 2 == 0)
        System.out.println(n);
});

@FunctionalInterface
interface Functional {
    int operation(int a, int b);
}

public class Test {
    public static void main(String[] args) {
        // Using lambda expressions to define the operations
        Functional add = (a, b) -> a + b;
        Functional multiply = (a, b) -> a * b;

        // Using the operations
        System.out.println(add.operation(6, 3));  // Output: 9
        System.out.println(multiply.operation(4, 5));  // Output: 20
    }
}