OOPs (Object-Oriented Programming System)
Java adalah bahasa pemrograman yang berorientasi pada Objek dimana segala sesuatu direpresentasikan sebagai objek. Di dunia nyata, objek sendiri dapat diartikan sebagai suatu entitas seperti sebuah meja, kursi, pena, buku dsb. Terdapat empat konsep utama OOP pada Java yaitu sebagai berikut:
1. Polymorphism
2. Inheritance
3. Encapsulation
4. Abstraction
 

1. Polymorphism
Secara bahasa kata "poly" artinya banyak dan "morphs" artinya bentuk, jadi polymorphism artinya banyak bentuk. Dalam konteks pemrograman Java, polimorfisme adalah suatu kemampuan untuk menampilkan pesan dalam berbagai bentuk. Polimorfisme memungkinkan kita untuk melakukan satu tindakan dengan cara yang berbeda. Dengan kata lain polimorfisme memungkinkan kita untuk mendefinisikan satu antarmuka (interface) memiliki banyak implementasi.
 Contoh nyata polimorfisme:
     Seseorang pada saat yang sama dapat memiliki karakteristik yang berbeda. Contohnya adalah sesorang laki-laki pada saat yang sama berperan sebagai seorang ayah, seorang suami dan seorang pegawai. Meskipun orangnya sama perilakunya akan berbeda-beda tergantung pada situasi dan keperluan.

Di dalam Java polymorphism dibagi menjadi dua tipe:

  • Compile time Polymorphism (Overloading)
  • Runtime Polymorphism (Overriding)
Metode Overloading: Jika ada beberapa fungsi dengan nama yang sama tetapi parameter yang berbeda, maka fungsi ini dikatakan kelebihan beban. Fungsi dapat dibebani oleh perubahan jumlah argumen atau / dan perubahan tipe argumen.
 
// Java program untuk metode overloading
class MultiplyFun {

    // Metode dengan 2 parameter
    static int Multiply(int a, int b)
    {
        return a * b;
    }

    // Metod dengan nama sama tetapi 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 
 
Metode Overriding: Metode ini dikenal sebagai Pengiriman Metode Dinamis yaitu proses di mana panggilan fungsi ke metode yang akan diganti diselesaikan pada saat proses. Jenis polimorfisme ini dicapai dengan Metode Penimpaan. Metode ini terjadi ketika kelas turunan memiliki definisi untuk salah satu fungsi anggota kelas dasar dan fungsi dasar tersebut akan diganti (overrriden). 
 
// 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

2. Inheritance
Pewarisan (inheritance) adalah mekanisme di dalam Java dimana satu kelas diijinkan untuk mewarisi fitur (field dan metode) dari kelas lain. Istilah penting yang perlu diketahui dalam pewarisan adalah sebagai berikut.
a. Super Class: 
Kelas yang mana semua fiturnya diwariskan ke dalam kelas lain disebut dengan super class (atau base class atau parent class).
b. Sub Class: 
Kelas yang mewarisi fitur, atribut dan metod dari kelas lain dinamakan dengan sub class. Bisa juga disebut sebagai kelas turunan (derivied class),  perpanjangan kelas (extended class), atau anak kelas (child class). Subclass dapat menambahkan field dan metodenya sendiri selain field dan metodenya superclass.
Kata kunci yang digunakan dalam pewarisan adalah extends.
Sintak:
class derived-class extends base-class  
{  
   //methods and fields  
}
Contoh: Di bawah ini adalah contoh dari konsep pewarisan. Class induk nya adalah Sepeda, kelas turunannya SepedaGunung dan kelas untuk menjalankan program adalah kelas Tes.
 
 //Program Java untuk mengilustraikan konsep pewarisan
 

// kelas induk
class Sepeda {
    // kelas sepeda memiliki dua atribut (fields)
    public int gear;
    public int speed;
       
    // kelas sepeda memiliki satu konstruktor
    public Sepeda(int gear, int speed) {
        this.gear = gear;
        this.speed = speed;
    }
       
    // kelas sepeda memiliki tiga metode
    public void applyBrake(int decrement) {
        speed -= decrement;
    }
       
    public void speedUp(int increment) {
        speed += increment;
    }
    
    // toString() adalah metode untuk cetak info dari sepeda
    public String toString() {
        return("nomor gear adalah "+gear
                +"\n"
                + "kecepatan sepeda adalah "+speed);
    }
}

// kelas turunan
class SepedaGunung extends Sepeda {
    
    //pada subclass SepedaGunung ditambahkan lagi satu field
    public int seatHeight;

    //kelas SepedaGunung memiliki satu konstruktor
    public SepedaGunung(int gear,int speed,
                        int startHeight)
    {
        // memanggil konstruktor dari kelas induk (Sepeda)
        super(gear, speed);
        seatHeight = startHeight;
    }
       
    //ditambahakan lagi satu metod baru
    public void setHeight(int newValue)
    {
        seatHeight = newValue;
    }
    
    // overriding toString() method  
    @Override
    public String toString()
    {
        return (super.toString()+
                "\n tinggi kursi adalah "+seatHeight);
    }
    
}

// driver class
public class Tes
{
    public static void main(String args[])
    {
       
       SepedaGunung sg= new SepedaGunung(3, 100, 25);
        System.out.println(sg.toString());
           
    }
}

Output: 
nomor gear adalah 3
kecepatan sepeda adalah 100
tinggi kursi adalah 25
 
3. Encapsulation
Enkapsulasi didefinisikan sebagai proses pembungkusan data di dalam class. Mekanisme ini mengikat variabel dan data yang telah dimanipulasi. Tujuan dari enkapsulasi adalah adalah perisai pelindung yang mencegah data diakses oleh kode di luar.
 

 

 

// Java program untuk demo enkapsulasi
public class Encapsulate
{
    // private variables declared
    // these can only be accessed by
    // public methods of class
    private String Name;
    private int Age;

    // get method for age to access
    // private variable Age
    public int getAge()
    {
    return Age;
    }

    // get method for name to access
    // private variable Name
    public String getName()
    {
    return Name;
    }  

    // set method for age to access
    // private variable age
    public void setAge( int newAge)
    {
    Age = newAge;
    }

    // set method for name to access
    // private variable Name
    public void setName(String newName)
    {
    Name = newName;
    }
   
}

Dalam program di atas kelas Encapsulate dienkapsulasi saat variabel dideklarasikan sebagai privat. Metode getter seperti getAge (), getName () diatur sebagai publik, metode ini digunakan untuk mengakses variabel ini. Metode setter seperti setName (), setAge (), juga dideklarasikan sebagai publik dan digunakan untuk melakukan setting nilai variabel.

 Program untuk mengakses variable kelas dari Encapsulate adalah seperti di bawah ini:

 public class TestEncapsulation
{    
    public static void main (String[] args)
    {
        Encapsulate obj = new Encapsulate();
        
        // setting values of the variables
        obj.setName("Munarso");
        obj.setAge(25);
        
        // Displaying values of the variables
        System.out.println("Name: " + obj.getName());
        System.out.println("Age: " + obj.getAge());  
        
    }

 

4. Abstraction
Abstraksi Data adalah proses menyembunyikan properti/variabel yang tidak penting dan hanya menampilkan detail penting kepada pengguna. Unit sepele atau tidak penting tidak ditampilkan kepada pengguna. Contoh: Mobil dipandang sebagai mobil daripada komponen individualnya. 
Abstraksi Data juga dapat didefinisikan sebagai proses mengidentifikasi hanya karakteristik yang diperlukan dari suatu objek dan mengabaikan detail yang tidak relevan.
Perhatikan contoh kehidupan nyata seorang pria yang mengendarai mobil. Pria hanya tahu bahwa menekan pedal gas akan menambah kecepatan mobil atau menginjak rem akan menghentikan mobil tetapi dia tidak tahu bagaimana dengan menginjak pedal gas kecepatan bertambah, dia tidak tahu tentang mekanisme bagian dalam mobil atau penerapan akselerator, rem dll di dalam mobil. Inilah yang dimaksud dengan abstraksi. 
Di java, abstraksi diperoleh dari kelas interface dan kelas abstrak. Kita dapat mencapai 100% abstraksi dengan menggunakan kelas interface. 
Sebagai contoh sebuah kelas "shape". Bentuk dasarnya adalah "shape" dan setiap bentuk memiliki warna, ukuran, dan sebagainya. Dari sini, jenis bentuk tertentu diturunkan (diwariskan) menjadi bentuk -lingkaran, persegi, segitiga, dan sebagainya - yang masing-masing mungkin memiliki karakteristik dan perilaku tambahan. Misalnya, bentuk tertentu bisa dibalik. Beberapa perilaku mungkin berbeda, seperti saat Anda ingin menghitung luas suatu bentuk. Hierarki tipe mewujudkan persamaan dan perbedaan antara bentuk.
 
 
 
// 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.color +
                    "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.color +
                        "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 Red and area is : 15.205308443374602

Rectangle color is Yellow and area is : 8.0