Object Oriented Programming Principles

Object-oriented programming is a programming concept that uses objects to represent real-world concepts and entities. Java is one of the most popular programming languages supporting OOP principles. 

Here are some of the principles of OOP in Java, along with code examples:

Encapsulation:

• Encapsulation is the process of hiding the details of the implementation of an object.
  Only the necessary functionality is exposed.
• In java encapsulation, this can be achieved through private, public, and protected modifiers.

public class Car {
 private String make;

 
 // getter methods
 public String getMake() {
   return make;
 }
 

 
 // setter methods
 public void setMake(String make) {
   this.make = make;
 }
 

}

Inheritance:

• Inheritance is the process where one class acquires properties and methods of another class.
• It is inheriting all traits from the parent to the child.
• The class which inherits properties is a subclass, aka a child class.
• Achieved using the "extends" keyword.

class parent{
method1{}
method2{}
}

 
Class child extends parent{
method3{}
}

child class = method1 from parent, method2 from parent and method3 from its own.

Polymorphism:

• The ability of an object to take different forms is known as polymorphism.
• This can be achieved by method overloading and method overriding.

Method Overloading: When more than one method with the same name but different parameters are declared, this is called method overloading.

package week4.day2;
public class boom {
    public int add(int x, int y) {
        return x + y;
    }
    public int add(int x, int y, int z) {
        return x + y + z;
    }
    public static void main(String[] args) {
        boom b = new boom();
        System.out.println(b.add(1, 1));
        System.out.println(b.add(1, 1, 1));
    }
}

Output:

2
3

Method Overriding: If the child class has the same method as the parent class, it is called method overriding in JavaJava.

package week4.day2;
public class boom {
    public int add(int x, int y) {
        return x + y;
    }
    public int add(int x, int y, int z) {
        return x + y + z;
    }
    public static void main(String[] args) {
        boom b = new boom();
        System.out.println(b.add(1, 1));
        System.out.println(b.add(1, 1, 1));
    }
}

package week4.day2;
Public class BoomTwo extends boom {
    @Override
    public int add(int x, int y) {
        return x + y;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}

Abstraction:

• In Java, abstraction is the process of hiding the implementation details of a class and then exposing only the essential features to the outside world. 
• Abstraction is done using abstract classes and interfaces.
• Using abstraction, you can create classes and interfaces that define a contract for their behavior without specifying the exact implementation.
• Interfaces are similar to abstract classes in that they cannot be instantiated, but they can only contain abstract methods, constant fields, and default methods (methods with a default implementation).

Abstract Example:

public abstract class Shape {
   public abstract void draw();
}
public class Circle extends Shape {
   public void draw() {
       System.out.println("Drawing a circle.");
   }
}
public class Rectangle extends Shape {
   public void draw() {
       System.out.println("Drawing a rectangle.");
   }
}

• We have an abstract class, Shape, with an abstract method, draw(). 
• The Circle and Rectangle classes extend the Shape class and provide their implementation of the draw() method.