Coffee break #111. Polimorfisme dan pengikatan dinamik di Jawa. Untuk gelung dalam Java + untuk setiap contoh sintaks gelung

Polimorfisme dan pengikatan dinamik di Jawa

Sumber: DZone Polymorphism ialah salah satu konsep teras pengaturcaraan berorientasikan objek. Sama ada anda baru dalam pengaturcaraan Java atau pembangun yang berpengalaman, anda harus tahu apa itu polimorfisme dan cara ia berfungsi. Kebanyakan pembangun mendakwa mereka mahir dalam topik ini, tetapi apabila ia berkaitan dengan ciri kompleks lain seperti pengikatan statik dan dinamik, ramai daripada mereka kehilangan keyakinan mereka.

Apakah polimorfisme dalam Java?

Polimorfisme bermaksud mempunyai banyak bentuk. Dalam pengaturcaraan, ini merujuk kepada keupayaan isyarat atau mesej untuk muncul dalam lebih daripada satu bentuk.

Contoh kehidupan sebenar

Seseorang boleh mempamerkan banyak ciri pada masa yang sama. Sebagai contoh, seorang ibu boleh menjadi isteri, anak perempuan, kakak, pekerja syarikat, dan sebagainya. Oleh itu, seseorang mungkin menunjukkan ciri-ciri yang berbeza dalam keadaan yang berbeza. Ini dikenali sebagai polimorfisme.

Kepentingan Polimorfisme

Polimorfisme ialah salah satu ciri terpenting bagi mana-mana bahasa pengaturcaraan berorientasikan objek (contohnya, Java). Dengan bantuan polimorfisme, tugas yang sama boleh dilakukan dengan cara yang berbeza.

Jenis polimorfisme

Di Jawa, polimorfisme boleh dibahagikan kepada dua kategori:

1. Polimorfisme masa kompilasi (pautan statik)
2. Polimorfisme masa jalan (Waktu Jalan, pengikatan dinamik)

Polimorfisme masa kompilasi

Polimorfisme masa kompilasi juga dikenali sebagai pemautan statik. Jenis polimorfisme ini boleh dicapai melalui lebihan fungsi atau lebihan beban operator. Tetapi di Jawa, ini terhad kepada lebihan fungsi kerana Java tidak menyokong lebihan beban pengendali. Overloading Fungsi Apabila terdapat sekurang-kurangnya dua fungsi atau kaedah dengan nama fungsi yang sama, tetapi sama ada bilangan parameter yang terkandung di dalamnya berbeza, atau sekurang-kurangnya satu jenis data parameter yang sepadan adalah berbeza (atau kedua-duanya), maka ia dipanggil fungsi atau kaedah terlebih beban, dan fungsi ini dikenali sebagai fungsi terlampau beban. Contoh 1 Setakat ini kita telah mengkaji apakah fungsi lebihan beban. Sekarang mari kita cuba menunjukkan kelebihan beban fungsi perisian.

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    // Method 2
    // having the same name but with 2 double parameters
    static double Addition(double a, double b)
    {
        // Returns sum of double numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Anda boleh menjalankan program di atas di sini . Penerangan program:

• Program di atas terdiri daripada dua fungsi statik dengan nama yang sama: Penambahan .

• Di sini, kedua-dua fungsi mengandungi bilangan parameter yang sama, tetapi parameter sepadannya berbeza.

• Kaedah 1 menerima dua parameter integer, manakala Kaedah 2 menerima dua parameter berganda .

• Daripada fungsi utama, kita mula-mula memanggil fungsi Penambahan(12, 14) . Parameter yang diluluskan ialah integer (12 dan 14), jadi Kaedah 1 akan dipanggil di sini.

• Kemudian kami memanggil fungsi Penambahan(15.2, 16.1) . Memandangkan parameter yang diluluskan adalah daripada jenis data berganda (15.2 dan 16.1), Kaedah 2 akan dipanggil kali ini .

• Beginilah cara pemuatan fungsi dicapai dalam Java berdasarkan jenis data parameter yang berbeza.

Contoh 2 Pertimbangkan program di bawah:

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }

    // Method 2
    // having the same name but with 3 integer parameters
    static double Addition(double a, double b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Anda boleh menjalankan program di atas di sini . Penerangan program:

• Program di atas terdiri daripada dua fungsi statik dengan nama yang sama: Penambahan .

• Di sini, kedua-dua fungsi mengandungi bilangan parameter yang berbeza, tetapi jenis data bagi dua parameter pertama yang sepadan adalah sama (integer).

• Kaedah 1 mengambil dua parameter integer, dan Kaedah 2 mengambil tiga parameter jenis data integer.

• Daripada fungsi utama, kita mula-mula memanggil fungsi Penambahan(2, 3) . Memandangkan parameter yang diluluskan ialah integer (2 dan 3), mereka akan memanggil Kaedah 1 di sini .

• Kemudian kami memanggil fungsi Penambahan(4, 5, 6) . Parameter yang diluluskan ialah jenis data berganda (4, 5, 6), jadi mereka akan memanggil Kaedah 2 kali ini .

• Beginilah cara fungsi dibebankan dalam Java berdasarkan bilangan parameter yang berbeza.

Contoh 3

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {
        // Return the sum
        return a + b;
    }
    // Method 2
    // having the same name but with 3 parameters
    // 1st parameter is of type double and other parameters
    // are of type integer
    static double Addition(double a, int b,  int c)
    {
        // Return the sum
        return a + b + c;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(2, 4));
        System.out.println(Addition(4.2, 6, 10));

    }
}

Anda boleh menjalankan program di atas di sini . Penerangan program:

• Program di atas terdiri daripada dua fungsi statik dengan nama yang sama: Penambahan .

• Kedua-dua fungsi mengandungi bilangan parameter yang berbeza dan jenis data elemen pertama yang sepadan juga berbeza.

• Kaedah 1 mengambil dua parameter integer, manakala Kaedah 2 mengambil tiga parameter - yang pertama adalah jenis berganda dan dua lagi adalah jenis data integer.

• Daripada fungsi utama, kita mula-mula memanggil fungsi Penambahan(2, 4) . Memandangkan parameter yang diluluskan ialah integer (2 dan 4), mereka akan memanggil Kaedah 1 di sini .

• Kemudian kami memanggil fungsi Penambahan(4.2, 6, 10) . Parameter pertama yang diluluskan adalah jenis integer dan parameter selebihnya adalah jenis data berganda (4.2, 6, 10), jadi Kaedah 2 akan dipanggil kali ini .

• Beginilah cara Java mencapai lebihan fungsi berdasarkan bilangan parameter yang berbeza serta jenis data yang berbeza bagi parameter yang sepadan.

Catatan. Fungsi tidak boleh terlebih beban berdasarkan jenis pemulangan fungsi semata-mata.

Polimorfisme masa larian

Pilihan ini juga dikenali sebagai pemautan dinamik. Dalam proses ini, memanggil fungsi yang dicipta untuk fungsi lain hanya dibenarkan pada masa jalan. Kita boleh mencapai pengikatan dinamik dalam Java menggunakan kaedah mengatasi.

Kaedah mengatasi

Kaedah mengatasi dalam Java berlaku apabila kaedah dalam kelas asas mempunyai definisi dalam kelas terbitan. Kaedah atau fungsi kelas asas dipanggil kaedah overridden.

// Class 1
class Parent {

    // Print method
    void Print()
    {

        // Print statement
        System.out.println("Inside Parent Class");
    }
}

// Class 2
class Child1 extends Parent {

    // Print method
    void Print() { System.out.println("Inside Child1 Class"); }
}

// Class 3
class Child2 extends Parent {

    // Print method
    void Print()
    {
        // Print statement
        System.out.println("Inside Child2 Class");
    }
}

class Main {

    public static void main(String args[]) {

        // Creating an object of class Parent
        Parent parent = new Parent();
        parent.Print();

        // Calling print methods
        parent = new Child1();
        parent.Print();

        parent = new Child2();
        parent.Print();
    }
}

Anda boleh menjalankan program di atas di sini . Penerangan program:

• Program di atas terdiri daripada tiga kelas: Ibu Bapa ( kelas 1 ), Anak1 ( kelas 2 ) dan Anak2 ( kelas 3 ). Kelas 2 dan kelas 3 mewarisi kelas 1 .

• Ibu bapa mempunyai kaedah yang dipanggil Print() . Di dalam fungsi ini kami mencetak " Kelas Induk Dalam ". Child1 dan Child2 juga mempunyai fungsi Print() , yang pada asasnya mengatasi fungsi Print() kelas Induk dan mencetak " Inside Child1 Class " dan " Inside Child2 Class " masing-masing ke konsol.

• Daripada fungsi utama, kami mula-mula mencipta objek kelas induk yang dipanggil induk. Kami kemudian menggunakan objek ini untuk memanggil kaedah cetakan kelas induk . Oleh itu " Kelas Induk Dalam " akan dicetak pada konsol.

• Selepas itu, kami memanggil pembina lalai kelas Child1 dan memanggil fungsi Print() . Ambil perhatian bahawa kaedah Print() yang ditakrifkan dalam kelas Child1 kini akan dipanggil kerana kami telah mengatasi kaedah Print() kelas induk . Oleh itu, " Inside Child1 Class " akan dicetak pada konsol.

• Akhir sekali, kami memanggil pembina lalai kelas Child2 dan memanggil fungsi Print() . Di sini kaedah Print() yang ditakrifkan dalam kelas Child2 akan dipanggil kerana kami telah mengatasi kaedah Print() kelas induk . Oleh itu, “ Inside Child2 Class ” akan dicetak pada konsol.

• Ini adalah bagaimana kaedah overriding dicapai di Jawa.

Keputusan

Dalam artikel ini, kami mempelajari apa itu polimorfisme di Jawa. Kami kemudian menyelidiki topik ini dengan lebih mendalam dan membincangkan dua jenis polimorfisme dalam Java: polimorfisme masa kompilasi dan polimorfisme masa larian. Kami telah menunjukkan melalui program bagaimana pengikatan statik dan dinamik boleh dicapai di Jawa.

Untuk gelung dalam Java + untuk setiap contoh sintaks gelung

Sumber: FreeCodeCamp A Loop dalam pengaturcaraan ialah urutan arahan yang dilaksanakan secara berterusan sehingga syarat tertentu dipenuhi. Dalam artikel ini, kita akan belajar tentang for dan forEach gelung dalam Java.

Untuk Sintaks Gelung dalam Java

Berikut ialah sintaks untuk membuat gelung for :

for (initialization; condition; increment/decrement) {
   // code to be executed
}

Mari lihat beberapa kata kunci dalam kod:

• untuk menunjukkan bahawa kita akan membuat gelung. Ia diikuti oleh kurungan, yang mengandungi semua yang kita perlukan untuk membuat gelung kita berfungsi.

• pemulaan mentakrifkan pembolehubah awal sebagai titik permulaan gelung, biasanya integer.

• keadaan menentukan berapa kali gelung harus dilaksanakan.

• increment / decrement increment / decrement nilai pembolehubah awal setiap kali gelung dijalankan. Apabila nilai pembolehubah meningkat/berkurang, ia cenderung kepada keadaan yang ditentukan.

• Ambil perhatian bahawa setiap kata kunci dipisahkan oleh koma bertitik ( ; ).

Berikut adalah beberapa contoh:

for(int x = 1; x <=5; x++) {
  System.out.println(x);
}

/*
1
2
3
4
5
*/

Dalam contoh di atas, pembolehubah permulaan ialah x dengan nilai 1. Gelung akan terus berjalan selagi nilai x kurang daripada atau sama dengan 5 - ini adalah syaratnya. x++ menambah nilai x selepas setiap larian. Kami terus mencetak nilai x yang berhenti selepas 5 kerana syarat telah dipenuhi. Meningkatkan kepada 6 tidak mungkin kerana ia lebih besar daripada dan tidak sama dengan 5. Dalam contoh berikut, kita akan menggunakan gelung for untuk mencetak semua nilai dalam tatasusunan.

int[] randomNumbers = {2, 5, 4, 7};
for (int i = 0; i < randomNumbers.length; i++) {
  System.out.println(randomNumbers[i]);
}

// 2
// 5
// 4
// 7

Ini hampir sama dengan contoh terakhir. Di sini kita telah menggunakan panjang tatasusunan sebagai syarat dan nilai awal pembolehubah sebagai sifar kerana nombor ordinal bagi elemen pertama tatasusunan ialah sifar.

untukSetiap sintaks gelung dalam Java

Gelung forEach digunakan secara khusus untuk lelaran melalui elemen tatasusunan. Inilah rupa sintaksnya:

for (dataType variableName : arrayName) {
  // code to be executed
}

Anda akan perasan bahawa sintaks di sini adalah lebih pendek daripada gelung for . Dan gelung forEach juga bermula dengan kata kunci untuk . Daripada memulakan pembolehubah dengan nilai, kami mula-mula menentukan jenis data (ia mesti sepadan dengan jenis data tatasusunan). Ini diikuti dengan nama pembolehubah kami dan nama tatasusunan , dipisahkan oleh titik bertindih. Berikut ialah contoh untuk membantu anda memahami sintaks dengan lebih baik:

int[] randomNumbers = {2, 5, 4, 7};
for (int x : randomNumbers) {
  System.out.println(x + 1);
}

/*
3
6
5
8
*/

Dalam contoh ini, kami telah mengulangi setiap elemen dan menambah nilai awalnya sebanyak 1. Secara lalai, gelung berhenti sebaik sahaja ia melelaran melalui semua elemen tatasusunan. Ini bermakna kami tidak perlu menghantar sebarang nilai kepada pembolehubah kami atau menentukan sebarang syarat untuk gelung berakhir.

Kesimpulan

Dalam artikel ini, kami mempelajari apa itu gelung dan sintaks untuk mencipta untuk dan untukSetiap gelung dalam Java. Kami juga melihat beberapa contoh yang membantu kami memahami masa dan cara menggunakannya. Selamat mengekod!