Menjelajahi polimorfisme berbasis antarmuka

10 menit

Polimorfisme berbasis antarmuka memungkinkan Anda menentukan kontrak yang harus diterapkan kelas, memungkinkan Anda untuk mencapai perilaku polimorfik tanpa mengandalkan warisan kelas. Antarmuka menentukan serangkaian metode dan properti yang harus diterapkan kelas, tetapi tidak memberikan detail implementasi apa pun. Kelas dapat menerapkan beberapa antarmuka, memungkinkannya menentukan perilaku untuk berbagai aspek aplikasi.

Untuk menjelajahi polimorfisme berbasis antarmuka, Anda dapat memulai dengan skenario yang mirip dengan skenario polimorfisme berbasis warisan dari unit sebelumnya.

Pertimbangkan sampel kode berikut yang menunjukkan polimorfisme berbasis antarmuka di C#:


// Define an interface
public interface ISound
{
    void MakeSound();
}

// Implement the interface in different classes
public class Dog : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The dog barks.");
    }
}

public class Cat : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The cat meows.");
    }
}

public class Cow : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The cow moos.");
    }
}

class Program
{
    static void Main()
    {
        // Create an array of Animal myObjects
        ISound[] myObjects = new ISound[3];

        ISound object1 = new Dog();
        ISound object2 = new Cat();
        ISound object3 = new Cow();

        myObjects[0] = object1;
        myObjects[1] = object2;
        myObjects[2] = object3;

        // Demonstrate polymorphism
        foreach (ISound currentObject in myObjects)
        {
            currentObject.MakeSound();
        }
    }
}

Dalam sampel kode ini, polimorfisme berbasis antarmuka ditunjukkan dengan mendefinisikan antarmuka ISound yang mencakup metode MakeSound. Kelas Dog, Cat, dan Cow mengimplementasikan antarmuka ISound dengan menyediakan implementasi mereka sendiri dari metode MakeSound. Metode Main membuat array objek ISound dan menetapkan instans Dog, Cat, dan Cow ke array. Perulangan foreach berulang di atas array dan memanggil metode MakeSound pada setiap objek, menunjukkan perilaku polimorfik.

Pada titik ini, polimorfisme berbasis antarmuka mungkin tampak dapat dipertukarkan dengan polimorfisme berbasis warisan. Memperbarui kode sampel dengan jenis kelas tambahan akan membantu menunjukkan perbedaannya.

Pertimbangkan sampel kode yang diperbarui berikut:


// Define an interface
public interface ISound
{
    void MakeSound();
}

// Implement the interface in different classes
public class Dog : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The dog barks.");
    }
}

public class Cat : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The cat meows.");
    }
}

public class Cow : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The cow moos.");
    }
}

public class Doorbell : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The doorbell rings.");
    }
}

public class CarHorn : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The car horn honks.");
    }
}

class Program
{
    static void Main()
    {
        // Create an array of Animal myObjects
        ISound[] myObjects = new ISound[3];

        ISound object1 = new Dog();
        ISound object2 = new Cat();
        ISound object3 = new Cow();
        ISound object4 = new Doorbell();
        ISound object5 = new CarHorn();

        myObjects[0] = object1;
        myObjects[1] = object2;
        myObjects[2] = object3;
        myObjects[3] = object4;
        myObjects[4] = object5;

        // Demonstrate polymorphism
        foreach (ISound currentObject in myObjects)
        {
            currentObject.MakeSound();
        }
    }
}

Kode sampel yang diperbarui ini mencakup dua kelas tambahan, Doorbell dan CarHorn, yang mengimplementasikan antarmuka ISound. Kelas tambahan ini membantu menunjukkan fleksibilitas polimorfisme berbasis antarmuka yang lebih besar dalam menentukan perilaku yang tidak terkait dengan hierarki kelas tertentu.

Polimorfisme berbasis antarmuka memberikan manfaat tambahan, seperti memungkinkan kelas menerapkan beberapa antarmuka dan menentukan kontrak untuk fungsionalitas tertentu. Antarmuka dapat digunakan untuk menentukan perilaku umum yang dapat dibagikan di berbagai kelas, memungkinkan polimorfisme tanpa perlu kelas dasar umum.

Pertimbangkan kode berikut yang menunjukkan objek dengan antarmuka tunggal dan beberapa:


// Define an interface for sound
public interface ISound
{
    void MakeSound();
}

// Define an interface for movement
public interface IMovable
{
    void Move();
}

// Implement the ISound and IMovable interfaces in different classes
public class Dog : ISound, IMovable
{
    public void MakeSound()
    {
        Console.WriteLine("The dog barks.");
    }

    public void Move()
    {
        Console.WriteLine("The dog runs.");
    }
}

public class Cat : ISound, IMovable
{
    public void MakeSound()
    {
        Console.WriteLine("The cat meows.");
    }

    public void Move()
    {
        Console.WriteLine("The cat jumps.");
    }
}

public class Cow : ISound, IMovable
{
    public void MakeSound()
    {
        Console.WriteLine("The cow moos.");
    }

    public void Move()
    {
        Console.WriteLine("The cow walks.");
    }
}

public class Doorbell : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The doorbell rings.");
    }
}

public class CarHorn : ISound
{
    public void MakeSound()
    {
        Console.WriteLine("The car horn honks.");
    }
}

class Program
{
    static void Main()
    {
        // Create an array of ISound objects
        ISound[] soundObjects = new ISound[5];

        ISound object1 = new Dog();
        ISound object2 = new Cat();
        ISound object3 = new Cow();
        ISound object4 = new Doorbell();
        ISound object5 = new CarHorn();

        soundObjects[0] = object1;
        soundObjects[1] = object2;
        soundObjects[2] = object3;
        soundObjects[3] = object4;
        soundObjects[4] = object5;

        // Demonstrate polymorphism with ISound
        Console.WriteLine("Demonstrating ISound polymorphism:");
        foreach (ISound currentObject in soundObjects)
        {
            currentObject.MakeSound();
        }

        // Create an array of IMovable objects
        IMovable[] movableObjects = new IMovable[3];

        IMovable movableObject1 = new Dog();
        IMovable movableObject2 = new Cat();
        IMovable movableObject3 = new Cow();

        movableObjects[0] = movableObject1;
        movableObjects[1] = movableObject2;
        movableObjects[2] = movableObject3;

        // Demonstrate polymorphism with IMovable
        Console.WriteLine("\nDemonstrating IMovable polymorphism:");
        foreach (IMovable currentObject in movableObjects)
        {
            currentObject.Move();
        }

        // Demonstrate objects with single and multiple interfaces
        Console.WriteLine("\nDemonstrating objects with single and multiple interfaces:");
        Dog dog = new Dog();
        Cat cat = new Cat();
        Cow cow = new Cow();
        Doorbell doorbell = new Doorbell();
        CarHorn carHorn = new CarHorn();

        dog.MakeSound();
        dog.Move();

        cat.MakeSound();
        cat.Move();

        cow.MakeSound();
        cow.Move();

        doorbell.MakeSound();

        carHorn.MakeSound();
    }
}

Hindari jebakan umum saat menerapkan polimorfisme berbasis antarmuka

Ketika tujuan Anda adalah polimorfisme berbasis antarmuka, berikut adalah beberapa hal yang harus dihindari dan beberapa hal untuk memastikan:

Hindari menerapkan antarmuka yang tidak terkait.
Hindari implementasi default dalam antarmuka. Meskipun C# memungkinkan implementasi default dalam antarmuka, hal ini dapat menyebabkan kebingungan dan mengurangi kejelasan tujuan antarmuka. Lebih suka kelas abstrak untuk implementasi bersama.
Hindari hierarki antarmuka yang terlalu rumit. Jaga hierarki antarmuka tetap sederhana dan hindari rantai pewarisan mendalam. Hierarki yang kompleks dapat membuat kode lebih sulit dipahami dan dikelola.
Pastikan Anda mengikuti prinsip pemisahan antarmuka (ISP). ISP menyatakan bahwa tidak ada klien yang harus dipaksa untuk bergantung pada metode yang tidak digunakannya. Buat antarmuka yang lebih kecil dan lebih spesifik daripada satu antarmuka besar.

Ringkasan

Polimorfisme berbasis antarmuka memungkinkan Anda menentukan kontrak yang harus diterapkan kelas, memungkinkan Anda untuk mencapai perilaku polimorfik tanpa mengandalkan warisan kelas. Dengan menerapkan antarmuka, Anda dapat membuat kode fleksibel dan dapat dipertahankan yang mempromosikan kopling longgar dan penggunaan kembali kode. Antarmuka menyediakan cara untuk menentukan perilaku umum yang dapat dibagikan di berbagai kelas, memungkinkan Anda untuk bekerja dengan objek dari berbagai jenis melalui antarmuka umum. Dengan memahami polimorfisme berbasis antarmuka, Anda dapat merancang aplikasi modular dan dapat diperluas yang lebih mudah dipertahankan dan berkembang dari waktu ke waktu.

Saran dan Komentar

Apakah halaman ini membantu?