konsep OOP di Jawa

Salah satu kekuatan terbesar Java adalah pemrograman berorientasi objek (OOP). Itulah alasan mengapa bahasa ini menjadi sangat populer dan sangat cocok untuk proyek dalam berbagai ukuran. Apa itu pemrograman berorientasi objek? Ini bukan sihir, tetapi bisa terlihat ajaib jika Anda benar-benar melakukannya. OOP adalah tentang bagaimana membangun perangkat lunak Anda. Ini adalah sebuah konsep, atau lebih tepatnya sekumpulan konsep oop di Java, yang memungkinkan Anda membuat beberapa interaksi dan hubungan spesifik antara objek Java untuk mengembangkan dan menggunakan perangkat lunak secara efektif. OOP klasik mencakup 3 + 1 konsep utama. Mari kita mulai dengan yang klasik.

Enkapsulasi

Enkapsulasi data menyembunyikan data internal dari dunia luar, dan mengaksesnya hanya melalui metode yang terbuka untuk umum. Maksudnya itu apa? Data apa? Bersembunyi dari siapa? Menyembunyikan berarti membatasi akses langsung ke anggota data (bidang) kelas.

Cara kerjanya di Jawa:

1. Bidang dibuat pribadi
2. Setiap bidang dalam kelas mendapatkan dua metode khusus: pengambil dan penyetel. Metode pengambil mengembalikan nilai bidang. Metode penyetel memungkinkan Anda mengubah nilai bidang secara tidak langsung tetapi diperbolehkan.

Contoh enkapsulasi dalam kode Java:

public class Student {
private int age;
private String name;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class Test{
public static void main(String[] args) {
Student firstStudent = new Student();
firstStudent.setName("John");
// The name field is private, so you can no longer do this:  firstStudent.name = "John"; 
}
}

Mengapa Anda harus menggunakan enkapsulasi?

Alasan utamanya adalah untuk mempermudah mengubah kode Anda. Bayangkan Anda memiliki aplikasi untuk sekolah hoki dan ada kelas Siswa Hoki dengan dua bidang yang menyimpan nama dan usia siswa saat dia mendaftar di sekolah tersebut. Sesuatu seperti ini:

public class HockeyStudent {
public String name;
public  int ageOfEnrollment;
}

Bidang ageOfEnrollment bersifat publik, tidak ada pengambil atau penyetel… Kelas ini digunakan oleh banyak kelas lain, dan semuanya baik-baik saja sampai beberapa pengembang memutuskan bahwa satu bidang int saja tidak cukup. Beberapa pemain hoki dalam kelompok hampir satu tahun lebih tua dari teman sebayanya, jadi akan lebih mudah untuk membagi mereka menjadi dua kelompok tergantung pada bulan kelahiran mereka. Jadi bidang ageOfEnrollment harus diubah menjadi array int (int[][]) : angka pertama untuk tahun penuh dan yang kedua untuk bulan. Sekarang Anda perlu memfaktorkan ulang semua kode yang menggunakan kelas Siswa ! Tetapi jika Anda ageOfEnrollmentbidang bersifat pribadi dan Anda memiliki getter dan setter, maka semuanya lebih mudah. Jika persyaratan untuk menyetel usia siswa berubah, cukup perbarui logika dalam metode setter setAgeOfEnrollment() dan kelas Anda dapat terus menggunakan Siswa tanpa masalah! Contoh ini agak dibuat-buat, tapi saya harap ini menjelaskan mengapa menggunakan enkapsulasi adalah ide yang bagus.

Warisan

Prinsip ini lebih mudah dipahami bahkan tanpa pengalaman praktis. Jangan ulangi dirimu sendiri (KERING) bisa menjadi moto untuk konsep warisan. Warisan memungkinkan Anda membuat kelas anak yang mewarisi bidang dan metode kelas induk tanpa mendefinisikannya kembali. Tentu, Anda bisa mengganti bidang dan metode kelas induk di kelas anak, tetapi itu bukan keharusan. Terlebih lagi, Anda dapat menambahkan status dan perilaku baru di kelas anak. Kelas induk terkadang disebut superclass atau kelas dasar, dan kelas anak dikenal sebagai subclass. Kata kunci extends Java digunakan untuk mengimplementasikan prinsip pewarisan dalam kode.

Cara kerjanya di Jawa:

1. Buat kelas induk.
2. Buat kelas anak menggunakan kata kunci extends .
3. Di konstruktor kelas Anak, gunakan metode super(parentField1, parentField2, ...) untuk menyetel bidang induk.

Beberapa peraturan:

1. Satu kelas hanya dapat memiliki satu orang tua.
2. Satu kelas induk dapat memiliki banyak kelas anak.
3. Kelas anak dapat memiliki kelas anak sendiri.

Contoh pewarisan dalam kode Java

Mari buat kelas Telepon .

public class Phone {
    int price;
    double weight;

// Constructor
public Phone(int price, double weight) {
        this.price = price;
        this.weight = weight;
    }

    void orderPhone(){
        System.out.println("Ordering phone...");
    }
}

Tentu saja, ada berbagai jenis ponsel, jadi mari buat dua kelas anak: satu untuk ponsel Android dan satu lagi untuk iPhone. Kemudian kami akan menambahkan beberapa bidang dan metode yang tidak dimiliki induk. Dan kita akan menggunakan super() untuk memanggil konstruktor untuk menginisialisasi bidang yang dimiliki kelas induk.

Contoh warisan di Jawa

public class Android extends Phone {

// Some new fields     
String androidVersion;
int screenSize;

    String secretDeviceCode;

// Constructor 
    public Android(int price, double weight, String androidVersion, int screenSize, String secretDeviceCode) {
        super(price, weight); // Android inherits Phone’s fields

        //this - reference to the current object
        //super - reference to the parent object

        this.androidVersion = androidVersion;
        this.screenSize = screenSize;
        this.secretDeviceCode = secretDeviceCode;
    }

	// New Android-specific method, does not exist in the Phone class 
    void installNewAndroidVersion() {
        System.out.println("installNewAndroidVersion invoked...");

    }

}

public class IPhone extends Phone {
   
    boolean fingerPrint;

    public IPhone(int price, double weight, boolean fingerPrint) {
        super(price, weight);
        System.out.println("IPhone constructor was invoked...");
        this.fingerPrint = fingerPrint;
    }

    void deleteIPhoneFromDb() {
        System.out.println("deleteIPhoneFromDb invoked...");
    }

@Override // This is about polymorphism, see below
void orderPhone(){
        System.out.println("Ordering my new iPhone and deleting the old one...");
    }
}

Jadi, ulangi: di Java, pewarisan memungkinkan Anda memperluas kelas dengan kelas anak yang mewarisi bidang dan metode dari kelas induk. Ini cara terbaik untuk mencapai penggunaan kembali kode.

Polimorfisme

Polimorfisme adalah kemampuan objek untuk berubah, mengambil bentuk yang berbeda atau lebih tepatnya bertindak dengan cara yang berbeda. Di Jawa, polimorfisme biasanya terjadi ketika referensi kelas induk digunakan untuk merujuk ke objek kelas anak.

Apa artinya dan bagaimana cara kerjanya di Jawa:

Apa polimorfisme di Jawa? Secara umum, itu berarti Anda dapat menggunakan nama metode yang sama untuk tujuan yang berbeda. Ada dua jenis polimorfisme di Jawa: metode overriding (polimorfisme dinamis) dan metode overloading (polimorfisme statis).

Penggantian metode

Anda bisa mengganti metode kelas induk di kelas anak, memaksanya untuk bekerja dengan cara yang berbeda. Mari buat kelas induk Musisi dengan metode play() .

Contoh polimorfisme dalam kode Java

   public class Musician {
    String name;
    int age;

    // Default constructor
    public Musician() {
    }

    // Parameterized constructor
    public Musician(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void play() {
        System.out.println("I am playing my instrument...");
    }
}

Musisi yang berbeda menggunakan instrumen yang berbeda. Mari buat dua class anak: Pianist dan Violinist . Berkat polimorfisme, masing-masing akan menjalankan versinya sendiri dari metode play() . Saat mengganti, Anda dapat menggunakan anotasi @Override , tetapi tidak perlu.

public class Pianist extends Musician {
    
    String favoritePianoType;

    public Pianist(String name, int age, String favoritePianoType) {
        super(name, age);
        this.favoritePianoType = favoritePianoType;
    }


    @Override
void play(){
        System.out.println("I am playing the piano...");
    }
}

Pemain biola bisa menjadi solois atau anggota orkestra. Mari pertimbangkan itu saat mengganti metode play() kita .

public class Violinist extends Musician { 
    boolean isSoloist; 

public Violinist(String name, int age, boolean isSoloist) {
            super(name, age);
            this.isSoloist = isSoloist;
        }


    @Override
void play(){
if (isSoloist) 
        System.out.println("I am playing the violin solo...");
else 
System.out.println("I am playing the violin in an orchestra...");

    }
}

Mari buat kelas Demo , di mana kita akan membuat tiga objek, satu instance dari masing-masing kelas yang dibuat sebelumnya. Kami akan melihat hasil apa yang kami dapatkan.

public class Demo {
  public static void main(String[] args) {
  Musician musician = new Musician();
  Violinist violinist = new Violinist("John", 32, true);
  Pianist pianist = new Pianist("Glen", 30, "Acoustic"); 

  System.out.println("Musician said:");
  musician.play();
  System.out.println("Violinist said:");
  violinist.play();
  System.out.println("Pianist said:");
  pianist.play();
    }
}

Inilah yang kami dapatkan:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo…
Pianist said:
I am playing the piano...

Setiap pemain biola dan pianis adalah musisi, tetapi tidak semua musisi adalah pemain biola atau pianis. Artinya, Anda dapat menggunakan metode permainan musisi jika Anda tidak perlu membuat yang baru. Atau Anda dapat memanggil metode induk dari anak menggunakan kata kunci super . Mari kita lakukan dalam kode Pianist:

public class Pianist extends Musician {

    String favoritePianoType;
    
    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
}

Sekarang mari kita panggil metode main() kita di kelas Demo . Inilah hasilnya:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...

Kelebihan metode

Kelebihan metode berarti menggunakan berbagai metode dengan nama yang sama di kelas yang sama. Mereka harus berbeda dalam hal jumlah, urutan, atau jenis parameternya. Misalkan seorang pianis dapat memainkan piano akustik dan piano elektrik. Untuk memainkan musik elektrik, pemusik membutuhkan listrik. Mari buat dua metode play() yang berbeda . Yang pertama tanpa parameter, untuk piano akustik, dan yang kedua dengan parameter yang menunjukkan ketersediaan listrik.

public class Pianist extends Musician {

    String name;
    int age;
    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
    void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            System.out.println("I am playing the piano...");
        }
        else System.out.println("I can't play this without electricity.");
    }
}

Omong-omong, Anda bisa menggunakan metode play() pertama di dalam metode play(boolean) kedua dengan cara ini:

void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            play();
        }
        else System.out.println("I can't play this without electricity.");
    }

Mari tambahkan beberapa baris ke kelas Demo kita untuk mendemonstrasikan kelebihan muatan kita:

public class Demo {
    public static void main(String[] args) {

        Musician musician = new Musician();
        Violinist violinist = new Violinist("John", 23, true);
        Pianist pianist = new Pianist("Glen", 30, "Acoustic"); 

        System.out.println("Musician said:");
        musician.play();
        System.out.println("Violinist said:");
        violinist.play();
        System.out.println("Pianist said:");
        pianist.play();
        System.out.println("The pianist will now try the electric piano:");
        pianist.play(true);
        System.out.println("The electricity has been shut off. Now when trying the electric piano, the pianist says:");
        pianist.play(false);
    }
}

Inilah hasilnya:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...
The pianist will now try the electric piano:
The electricity is on.
I am playing my instrument...
I am playing the piano...
The electricity has been shut off. Now when trying the electric piano, the pianist says:
I can't play this without electricity.

Java mengetahui metode mana yang harus digunakan berdasarkan parameter dan tipe objeknya. Itu polimorfisme.

Abstraksi

Saat kita mendefinisikan sebuah kelas, kita mencoba membangun model dari sesuatu. Misalnya, kita sedang menulis video game bernama MyRacer dengan mobil balap yang berbeda. Seorang pemain dapat memilih salah satunya dan kemudian memperbaruinya atau membeli yang lain. Jadi… Apa itu mobil? Mobil adalah hal yang cukup rumit, tetapi jika kita mencoba membuat video game balapan (sebagai lawan dari simulator mengemudi), maka kita tidak perlu mendeskripsikan ribuan roda gigi dan gasket yang ada di dalamnya. Kami membutuhkan modelnya, kecepatan tertinggi, karakteristik kemampuan manuver, harga, warna… Dan mungkin itu sudah cukup. Itulah model mobil untuk permainan kami. Nanti di MyRacer 2, misalkan kita memutuskan untuk menambahkan ban yang mempengaruhi handling di jalan raya. Di sini modelnya berbeda, karena kami menambahkan lebih banyak detail. Membiarkan' s mendefinisikan abstraksi data sebagai proses mengidentifikasi hanya karakteristik penting (atau perlu) dari suatu objek dan mengabaikan detail yang tidak relevan. Ada berbagai tingkat abstraksi. Misalnya, jika Anda adalah penumpang bus, Anda perlu mengetahui seperti apa bentuk bus Anda dan kemana tujuannya, tetapi Anda tidak perlu tahu cara mengemudikannya. Jika Anda seorang pengemudi bus, Anda tidak perlu tahu cara membuat bus baru — Anda hanya perlu tahu cara mengemudikannya. Tetapi jika Anda seorang pembuat bus, Anda perlu pergi ke tingkat abstraksi yang lebih rendah, karena detail desain bus sangat penting bagi Anda. Saya harap Anda mengerti apa yang saya maksud. Anda perlu tahu seperti apa bus Anda dan ke mana arahnya, tetapi Anda tidak perlu tahu cara mengendarainya. Jika Anda seorang pengemudi bus, Anda tidak perlu tahu cara membuat bus baru — Anda hanya perlu tahu cara mengemudikannya. Tetapi jika Anda seorang pembuat bus, Anda perlu pergi ke tingkat abstraksi yang lebih rendah, karena detail desain bus sangat penting bagi Anda. Saya harap Anda mengerti apa yang saya maksud. Anda perlu tahu seperti apa bus Anda dan ke mana arahnya, tetapi Anda tidak perlu tahu cara mengendarainya. Jika Anda seorang pengemudi bus, Anda tidak perlu tahu cara membuat bus baru — Anda hanya perlu tahu cara mengemudikannya. Tetapi jika Anda seorang pembuat bus, Anda perlu pergi ke tingkat abstraksi yang lebih rendah, karena detail desain bus sangat penting bagi Anda. Saya harap Anda mengerti apa yang saya maksud.

Cara kerjanya di Jawa:

Mari membangun empat level abstraksi di Java, atau lebih tepatnya di OOP — dari yang terendah (paling spesifik) hingga tertinggi (paling abstrak).

1. Tingkat abstraksi terendah adalah objek tertentu. Ini adalah entitas dengan seperangkat karakteristik yang termasuk dalam kelas tertentu. Ini memiliki nilai bidang tertentu

2. Templat untuk membuat objek adalah kelas. Ini adalah deskripsi sekumpulan objek dengan properti dan struktur internal yang serupa.

3. Kelas abstrak adalah deskripsi abstrak dari karakteristik sekumpulan kelas (bertindak sebagai template untuk pewarisan oleh kelas lain). Ini memiliki tingkat abstraksi yang tinggi, sehingga tidak mungkin membuat objek langsung dari kelas abstrak. Hanya kelas turunan dari kelas abstrak yang dapat digunakan untuk membuat objek. Kelas abstrak dapat menyertakan metode dengan implementasi, tetapi ini bukan persyaratan.

4. Antarmuka adalah konstruksi dari konstruksi bahasa pemrograman Java yang hanya berisi metode publik abstrak dan bidang konstanta statis (statis akhir). Dengan kata lain, baik kelas abstrak maupun antarmuka tidak dapat digunakan untuk menghasilkan objek.

BTW, di Java 8 atau lebih baru, antarmuka tidak hanya memiliki metode abstrak dan konstanta, tetapi juga metode default dan statis. Di Java, antarmuka mendefinisikan perilaku, sedangkan kelas abstrak digunakan untuk membuat hierarki. Satu antarmuka dapat diimplementasikan oleh beberapa kelas.

Contoh antarmuka dalam kode Java

interface Human {
	public void struggle();
	public void protect();
}

interface Vulcan {
	int angleOfPointyEars; 
	public void turnOffEmotions(boolean isOn);
	public void telepathy();
}

Anda dapat mengimplementasikan lebih dari satu antarmuka

The Spock class implements Human and Vulcan {
public void struggle() {
System.out.println("I am struggling...");
}
	public void protect() {
System.out.println("You are under my protection!”);
}
public void turnOffEmotions(boolean isOn){
If (isOn) {
System.out.println("I am turning off my emotions.");
isOn= !isOn;
}
}
	public void telepathy() {
System.out.println("Connecting to your brain...");
}

}

Untuk siswa pemula, itu mencakup semua konsep utama pemrograman berorientasi objek di Java. Selain 4 prinsip OOP utama, Java juga memiliki asosiasi, agregasi, dan komposisi. Anda dapat menyebutnya "prinsip OOP tambahan". Mereka berhak mendapatkan artikel terpisah mereka sendiri.