Polimorfisme dalam C#

Polymorphism ialah konsep yang dicapai dalam bahasa pengaturcaraan berorientasikan objek seperti C#, di mana pengendali atau kaedah berfungsi boleh mengambil lebih daripada satu bentuk sepanjang proses pelaksanaan. Ia digunakan secara meluas untuk pelaksanaan pewarisan dalam program, dan ini dikategorikan kepada dua kaedah, iaitu operator overloading dan function overloading. Dalam perkataan mudah, Polimorfisme boleh dijelaskan sebagai teknik untuk mengubah kelas asas menggunakan kelas terbitan, di mana kedua-dua kelas mempunyai sifat yang berbeza.

Rajah berikut menggambarkan kerja polimorfisme:

Angka ini menerangkan bahawa tanah liat ialah objek induk dari mana periuk, mangkuk dan objek mainan dibuat. Semua objek ini berbeza antara satu sama lain, tetapi mereka mempunyai sifat tanah liat. Ketiga-tiga objek ini mempunyai bentuk yang berbeza dan digunakan dengan cara yang berbeza walaupun ia diperbuat daripada bahan yang sama iaitu tanah liat.

Bentuk Polimorfisme

Di bawah ialah 2 bentuk Polimorfisme:

1. Operator Lebih Muatan

Seseorang Operator boleh memberikan output yang berbeza berdasarkan jenis operan yang ia beroperasi. Ini dipanggil Operator Overloading. Contohnya, operator '+' boleh melakukan penambahan pada dua integer, manakala ia boleh menggabungkan dua rentetan. Oleh itu operator yang sama boleh digunakan dalam 2 cara yang berbeza. Operator penambahan biasanya menambah dua nombor. Walau bagaimanapun, dalam kes nombor kompleks, penambahan adalah sedikit berbeza, di mana bahagian nyata dan bahagian khayalan yang sepadan ditambah secara berasingan. Berikut ialah contoh kod yang menunjukkan cara pengendali ‘+’ boleh dibebankan untuk menambah nombor kompleks.

Kod:

using System;
namespace Overload {
class Complex
{
public double x;
public double y;
// no-argument constructor
public Complex() {}
// parameterized constructor
public Complex(double real, double img)
{
x = real;
y = img;
}
// Overloading of Binary "+" operator
public static Complex operator + (Complex c1,
Complex c2)
{
Complex c3 = new Complex();
c3.x = c1.x + c2.x;
c3.y = c1.y + c2.y;
return c3;
}
// function to display result
public void display()
{
Console.WriteLine("{0} + {1}i", x,y);
}
}
class CalNum {
// Driver Code
static void Main(string[] args)
{
Complex num1 = new Complex(2.5,3.5);
Complex num2 = new Complex(1.2,6.5);
Complex num3 = num1 + num2;
Console.Write("c1 = ");
num1.display();
Console.Write("c2 = ");
num2.display();
Console.Write("c3 = ");
num3.display();
}
}
}

Output:

Output ini menggambarkan operator lebih muatan untuk menambah dua nombor kompleks. Kod menunjukkan operator terlebih muatan serta lebihan fungsi.

2. Berlebihan Fungsi

Fungsi boleh memberikan output yang berbeza berdasarkan bilangan parameter serta jenis pulangannya dan jenis pulangan fungsi. Kod yang disebutkan di atas juga merangkumi lebihan fungsi menggunakan pembina. Terdapat 2 pembina dalam kod; satu ialah pembina lalai yang dibiarkan kosong manakala satu lagi ialah pembina berparameter yang digunakan untuk memulakan nombor kompleks dengan nilai yang disebut sebagai parameter.

Mengambil contoh yang digambarkan dalam rajah, fungsinya adalah membentuk tanah liat dan arah lejang ialah anggota yang disediakan untuk membentuk tanah liat. Berdasarkan arah lejang yang berbeza, tanah liat masing-masing berubah menjadi periuk, mangkuk dan mainan.

Kod:

using System;
using System.Collections.Generic;
public class Clay
{
// A few example members
public int Height { get; set; }
public int strokeDirection { get; set; }
// Virtual method
public virtual void Mould()
{
Console.WriteLine("Beginning to mould the clay");
}
}
class Pot : Clay
{
public override void Mould()
{
// Code to make a pot Console.WriteLine("Making a pot");
base.Mould();
}
}
class Bowl : Clay
{
public override void Mould()
{
// Code to make a bowl
Console.WriteLine("Making a bowl");
base.Mould();
}
}
class Toy : Clay
{
public override void Mould()
{
// Code to make a toy
Console.WriteLine("Making a toy");
base.Mould();
}
}
class Program
{
static void Main(string[] args)
{
// Illustrating Polymorphism #1: a Pot, Bowl and Toy
// can all be used wherever Clay is expected. No cast is
// needed because an implicit conversion exists from a derived
// class to its base class.
var items = new List<Clay>
{
new Pot(),
new Bowl(),
new Toy()
};
// Polymorphism at work #2: the virtual method Mould is
// invoked on each of the derived classes, not the base class.
foreach (var item in items)
{
item.Mould();
}
}
}

Output:

Seperti yang mungkin anda nyatakan dalam kod, kelas tanah liat ialah kelas induk yang kelas anak-anaknya ialah kelas periuk, mainan dan mangkuk. Kaedah 'Mould' ditakrifkan dalam kelas induk serta kelas anak dengan tandatangan fungsi yang sama. Oleh itu, apabila objek kelas kanak-kanak dicipta dan ia memanggil kaedah Mould, kaedah kelas asas akan ditindih oleh kaedah kelas kanak-kanak. Oleh itu, kita melihat output kaedah kelas kanak-kanak. Kod di atas menunjukkan kaedah mengatasi dan tidak membebankan untuk menggambarkan polimorfisme.

Perkara yang Perlu Diingati untuk Polimorfisme dalam C#

Mata yang perlu diingat untuk polimorfisme dalam C#:

• Melebihi muatan adalah berbeza daripada Mengatasi. Overloading mempunyai tandatangan fungsi yang berbeza manakala overriding mempunyai tandatangan fungsi yang sama.
• Polymorphism merujuk kepada mengubah gelagat superclass dalam subclass.
• Warisan merujuk kepada penggunaan struktur dan gelagat kelas super dalam subkelas.

Berikut ialah beberapa perkara penting:

• Polymorphism ialah salah satu paradigma utama pengaturcaraan Berorientasikan Objek.
• Lebihan beban fungsi mengubah suai fungsi mengikut jenis pengembalian dan parameter fungsi dalam kelas yang diwarisi.
• Lebih muatan pengendali mengubah suai definisi operator mengikut parameter yang diberikan.
• Polymorphism digunakan untuk melaksanakan pewarisan. Ia memutuskan pada masa berjalan untuk memanggil kaedah kelas kanak-kanak menggunakan kaedah mengatasi.

Atas ialah kandungan terperinci Polimorfisme dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!