Konsep OOP dalam Java

Salah satu kekuatan terbesar Java ialah pengaturcaraan berorientasikan objek (OOP). Itulah sebab mengapa bahasa ini menjadi begitu popular dan sangat sesuai untuk projek dalam sebarang saiz. Apakah pengaturcaraan berorientasikan objek? Ia bukan sihir, tetapi ia boleh kelihatan ajaib jika anda benar-benar memahaminya. OOP adalah mengenai cara membina perisian anda. Ia adalah konsep, atau lebih tepatnya sekumpulan konsep oop dalam Java, yang membolehkan anda mencipta beberapa interaksi dan hubungan khusus antara objek Java untuk membangunkan dan menggunakan perisian dengan berkesan. OOP klasik merangkumi 3 + 1 konsep utama. Mari kita mulakan dengan klasik.

Enkapsulasi

Enkapsulasi data menyembunyikan data dalaman daripada dunia luar, dan mengaksesnya hanya melalui kaedah yang terdedah kepada umum. Apakah maksudnya? Data apa? Bersembunyi daripada siapa? Menyembunyikan bermaksud menyekat akses terus kepada ahli data (medan) kelas.

Bagaimana ia berfungsi di Jawa:

1. Medan dijadikan peribadi
2. Setiap medan dalam kelas mendapat dua kaedah khas: pengambil dan penetap. Kaedah Getter mengembalikan nilai medan. Kaedah penetap membolehkan anda menukar nilai medan dengan cara tidak langsung tetapi dibenarkan.

Contoh enkapsulasi dalam kod 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 perlu menggunakan enkapsulasi?

Sebab utama adalah untuk memudahkan anda menukar kod anda. Bayangkan anda mempunyai permohonan untuk sekolah hoki dan terdapat kelas HockeyStudent dengan dua bidang yang menyimpan nama dan umur pelajar semasa dia mendaftar di sekolah tersebut. Sesuatu seperti ini:

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

Medan ageOfEnrollment adalah awam, tiada getter atau setter... Kelas ini digunakan oleh banyak kelas lain dan semuanya ok sehingga sesetengah pembangun memutuskan bahawa satu medan int tidak mencukupi. Sesetengah pemain hoki dalam kohort hampir setahun lebih tua daripada rakan sebaya mereka, jadi adalah lebih mudah untuk membahagikan mereka kepada dua kumpulan bergantung pada bulan mereka dilahirkan. Jadi medan ageOfEnrollment hendaklah ditukar kepada tatasusunan int (int[][]) : nombor pertama adalah untuk tahun penuh dan yang kedua adalah untuk bulan. Kini anda perlu memfaktorkan semula semua kod yang menggunakan kelas Pelajar ! Tetapi jika ageOfEnrollment andamedan adalah peribadi dan anda mempunyai getter dan setter, maka semuanya lebih mudah. Jika keperluan untuk menetapkan umur pelajar berubah, cuma kemas kini logik dalam kaedah setAgeOfEnrollment() dan kelas anda boleh terus menggunakan Pelajar tanpa sebarang masalah! Contoh ini agak direka-reka, tetapi saya harap ia menjelaskan mengapa menggunakan enkapsulasi adalah idea yang bagus.

Warisan

Prinsip ini lebih mudah difahami walaupun tanpa pengalaman praktikal. Jangan ulangi diri sendiri (KERING) boleh menjadi moto untuk konsep pewarisan. Warisan membolehkan anda membuat kelas anak yang mewarisi medan dan kaedah kelas induk tanpa mentakrifkannya semula. Sudah tentu, anda boleh mengatasi medan dan kaedah kelas induk dalam kelas anak, tetapi ini bukan satu keperluan. Apatah lagi, anda boleh menambah keadaan dan gelagat baharu dalam kelas kanak-kanak. Kelas induk kadangkala dipanggil superclass atau kelas asas, dan kelas anak dikenali sebagai subclass. Kata kunci lanjutan Java digunakan untuk melaksanakan prinsip pewarisan dalam kod.

Bagaimana ia berfungsi di Jawa:

1. Buat kelas induk.
2. Buat kelas kanak-kanak menggunakan kata kunci extends .
3. Dalam pembina kelas Kanak-kanak, gunakan kaedah super(parentField1, parentField2, ...) untuk menetapkan medan induk.

Beberapa peraturan:

1. Satu kelas hanya boleh mempunyai seorang ibu bapa.
2. Satu kelas induk boleh mempunyai banyak kelas kanak-kanak.
3. Kelas kanak-kanak boleh mempunyai kelas kanak-kanak sendiri.

Contoh pewarisan dalam kod Java

Mari buat kelas Telefon .

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...");
    }
}

Sudah tentu, terdapat jenis telefon yang berbeza, jadi mari kita buat dua kelas kanak-kanak: satu untuk telefon Android dan satu kedua untuk iPhone. Kemudian kami akan menambah beberapa medan dan kaedah yang tidak dimiliki oleh ibu bapa. Dan kami akan menggunakan super() untuk memanggil pembina untuk memulakan medan yang ada pada kelas induk.

Contoh pewarisan 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, untuk mengulangi: dalam Java, warisan membolehkan anda melanjutkan kelas dengan kelas anak yang mewarisi medan dan kaedah kelas induk. Ia merupakan cara terbaik untuk mencapai kebolehgunaan semula kod.

Polimorfisme

Polimorfisme ialah keupayaan objek untuk berubah, mengambil bentuk yang berbeza atau bertindak dengan cara yang berbeza. Di Jawa, polimorfisme biasanya berlaku apabila rujukan kelas induk digunakan untuk merujuk kepada objek kelas anak.

Apakah maksudnya dan cara ia berfungsi di Jawa:

Apakah polimorfisme dalam Java? Secara umum, ini bermakna anda boleh menggunakan nama kaedah yang sama untuk tujuan yang berbeza. Terdapat dua jenis polimorfisme dalam Java: kaedah overriding (polimorfisme dinamik) dan kaedah terlebih beban (polimorfisme statik).

Kaedah mengatasi

Anda boleh mengatasi kaedah kelas induk dalam kelas anak, memaksanya berfungsi dengan cara yang berbeza. Mari buat kelas induk Pemuzik dengan kaedah play() .

Contoh polimorfisme dalam kod 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...");
    }
}

Pemuzik yang berbeza menggunakan instrumen yang berbeza. Mari buat dua kelas kanak-kanak: Pemain Piani dan Pemain Violinis . Terima kasih kepada polimorfisme, masing-masing akan melaksanakan versi kaedah play() nya sendiri . Apabila mengatasi, anda boleh menggunakan anotasi @Override , tetapi ia 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 boleh menjadi pemain solo atau ahli orkestra. Mari kita pertimbangkan perkara itu apabila mengatasi kaedah play() kami .

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 kita cipta kelas Demo , di mana kita akan mencipta tiga objek, satu contoh bagi setiap kelas yang dibuat sebelum ini. Kita lihat apa keputusan yang kita dapat.

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 dapat:

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 pemain piano adalah seorang pemuzik, tetapi tidak setiap pemuzik adalah pemain biola atau pemain piano. Ini bermakna anda boleh menggunakan kaedah permainan pemuzik jika anda tidak perlu mencipta kaedah baharu. Atau anda boleh memanggil kaedah ibu bapa daripada anak menggunakan kata kunci super . Mari kita lakukan itu dalam kod 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 kaedah main() kami dalam 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...

Kaedah terlebih beban

Kaedah terlebih beban bermaksud menggunakan pelbagai kaedah dengan nama yang sama dalam kelas yang sama. Ia mestilah berbeza dari segi bilangan, susunan atau jenis parameternya. Katakan seorang pemain piano boleh memainkan piano akustik dan piano elektrik. Untuk bermain elektrik, pemuzik memerlukan elektrik. Mari kita cipta dua kaedah play() yang berbeza . Yang pertama tanpa parameter, untuk piano akustik, dan yang kedua dengan parameter yang menunjukkan sama ada elektrik tersedia.

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.");
    }
}

Dengan cara ini, anda boleh menggunakan kaedah main() pertama di dalam kaedah main(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 pada kelas Demo kami untuk menunjukkan kelebihan beban kami:

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 tahu kaedah mana yang harus digunakan berdasarkan parameternya dan jenis objek. Itulah polimorfisme.

Abstraksi

Apabila kita mentakrifkan kelas, kita cuba membina model sesuatu. Sebagai contoh, katakan kita sedang menulis permainan video yang dipanggil MyRacer dengan kereta lumba yang berbeza. Pemain boleh memilih salah satu daripadanya dan kemudian mengemas kininya atau membeli yang lain. Jadi… Apakah itu kereta? Kereta adalah perkara yang agak rumit, tetapi jika kita cuba mencipta permainan video perlumbaan (berbanding dengan simulator memandu), maka kita tidak perlu menerangkan semua beribu gear dan gasket yang terkandung di dalamnya. Kami memerlukan modelnya, kelajuan tinggi, ciri kebolehgerakan, harga, warna... Dan mungkin itu sudah cukup. Itulah model kereta untuk permainan kami. Kemudian dalam MyRacer 2, andaikan kami memutuskan untuk menambah tayar yang menjejaskan pengendalian di jalan raya. Di sini modelnya berbeza, kerana kami menambah lebih banyak butiran. mari' s mentakrifkan abstraksi data sebagai proses mengenal pasti hanya ciri-ciri penting (atau perlu) sesuatu objek dan mengabaikan sebarang butiran yang tidak berkaitan. Terdapat tahap abstraksi yang berbeza. Sebagai contoh, jika anda seorang penumpang bas, anda perlu tahu rupa bas anda dan ke mana ia pergi, tetapi anda tidak perlu tahu cara memandunya. Jika anda seorang pemandu bas, anda tidak perlu tahu cara membuat bas baharu — anda hanya perlu tahu cara memandunya. Tetapi jika anda seorang pengilang bas, anda perlu pergi ke tahap abstraksi yang lebih rendah, kerana butiran reka bentuk bas sangat penting untuk anda. Saya harap awak faham maksud saya. anda perlu tahu rupa bas anda dan ke mana ia pergi, tetapi anda tidak perlu tahu cara memandunya. Jika anda seorang pemandu bas, anda tidak perlu tahu cara membuat bas baharu — anda hanya perlu tahu cara memandunya. Tetapi jika anda seorang pengilang bas, anda perlu pergi ke tahap abstraksi yang lebih rendah, kerana butiran reka bentuk bas sangat penting untuk anda. Saya harap awak faham maksud saya. anda perlu tahu rupa bas anda dan ke mana ia pergi, tetapi anda tidak perlu tahu cara memandunya. Jika anda seorang pemandu bas, anda tidak perlu tahu cara membuat bas baharu — anda hanya perlu tahu cara memandunya. Tetapi jika anda seorang pengilang bas, anda perlu pergi ke tahap abstraksi yang lebih rendah, kerana butiran reka bentuk bas sangat penting untuk anda. Saya harap awak faham maksud saya.

Bagaimana ia berfungsi di Jawa:

Mari bina empat tahap abstraksi dalam Java, atau lebih tepatnya dalam OOP — daripada yang paling rendah (paling spesifik) kepada yang tertinggi (paling abstrak).

1. Tahap abstraksi yang paling rendah ialah objek tertentu. Ia adalah entiti dengan set ciri yang dimiliki oleh kelas tertentu. Ia mempunyai nilai medan tertentu

2. Templat untuk mencipta objek ialah kelas. Ia adalah perihalan set objek dengan sifat dan struktur dalaman yang serupa.

3. Kelas abstrak ialah penerangan abstrak tentang ciri-ciri set kelas (ia bertindak sebagai templat untuk warisan oleh kelas lain). Ia mempunyai tahap abstraksi yang tinggi, jadi mustahil untuk mencipta objek secara langsung daripada kelas abstrak. Hanya kelas kanak-kanak kelas abstrak boleh digunakan untuk mencipta objek. Kelas abstrak mungkin termasuk kaedah dengan pelaksanaan, tetapi ini bukan keperluan.

4. Antara muka ialah binaan binaan bahasa pengaturcaraan Java yang mengandungi hanya kaedah awam abstrak dan medan pemalar statik (statik akhir). Dengan kata lain, kelas abstrak mahupun antara muka tidak boleh digunakan untuk menjana objek.

BTW, dalam Java 8 atau lebih baru, antara muka boleh mempunyai bukan sahaja kaedah abstrak dan pemalar, tetapi juga kaedah lalai dan statik. Di Java, antara muka mentakrifkan tingkah laku, manakala kelas abstrak digunakan untuk mencipta hierarki. Satu antara muka boleh dilaksanakan oleh pelbagai kelas.

Contoh antara muka dalam kod Java

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

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

Anda boleh melaksanakan lebih daripada satu antara muka

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...");
}

}

Bagi pelajar permulaan, itu merangkumi semua konsep utama pengaturcaraan berorientasikan objek di Jawa. Selain 4 prinsip OOP utama, Java juga mempunyai perkaitan, pengagregatan, dan komposisi. Anda boleh memanggilnya "prinsip OOP tambahan". Mereka berhak mendapat artikel tersendiri.