Bevezetés a túlterheléshez és a felülbíráláshoz a C # -ben
A polimorfizmus a C # egyik fontos fogalma. Kétféle polimorfizmus létezik: az összeállítási és a futási idő. Ennek elérése érdekében a túlterhelés és a felülbíráló fogalmakat alkalmazzák. A felülbírálás során a gyermekosztály más módon is megvalósíthatja a szülői osztály módszerét, de a gyermek osztály módszernek ugyanaz a neve és ugyanaz a metódus aláírása, mint a szülőnek, míg a túlterheléshez az osztályban több módszer létezik, azonos névvel és különböző paraméterekkel.
Hogyan működik a felülbírálás és a túlterhelés a C # -ben?
Az alábbiakban példákkal mutatjuk be a felülírást és a túlterhelést a C # -ben:
nyomós
Van néhány kulcsszó, amelyeket felülírunk, mint például a virtuális, az felülbírálás és az alap.
Szintaxis:
class Parent
(
public virtual void Example() // base class
(
Console.WriteLine(“ parent class”);
)
)
class Child: Parent
(
public override void Example() // derived class
(
base.Example();
Console.WriteLine(“Child class”);
)
)
Ebben virtuális és felülbíráló kulcsszavak kerülnek felhasználásra, ami azt jelenti, hogy az alap osztály virtuális, és a gyermek osztály végrehajthatja ezt az osztályt, és felülbírálás azt jelenti, hogy ennek a gyermek osztálynak ugyanaz a neve és ugyanaz a metódus aláírása, mint a szülő osztályhoz.
1. példa
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Subject s = new Mathematics();
s.study();
Console.ReadLine();
)
)
)
A fenti példában a módszerek neve azonos, de a végrehajtásuk eltérő. Az alap osztály virtuális, és ennek köszönhetően a gyermek osztály a szülő osztály módszert saját maga gyakorolja. A gyermekosztály-módszer kulcsszó-felülbírálással rendelkezik, ami azt mutatja, hogy ez a módszer felülbíráló módszer.
Kimenet:
2. példa
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
base.study();
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Mathematics m = new Mathematics();
m.study();
Console.ReadLine();
)
)
)
Kimenet:
Ebben a példában a származtatott osztálynak van egy alap kulcsszava, amelyet az alap osztály módszer meghívására használnak. Tehát ebben az esetben a származtatott módszert az alaposztály módszer után hívják.
Emlékeztető pontok:
- Az elsődleges koncepcióban a módszer neve, valamint a metódus aláírása és a hozzáférés módosítója mindig megegyezik a szülő és a gyermek osztályával.
- A szülő osztály módszer nem lehet statikus.
A túlterhelés
A túlterhelésnél több módszer létezik, különféle metódusú aláírással. Az alábbiakban néhány példát mutatunk be, hogyan érhetjük el a túlterhelést a paraméterek számának, a paraméterek sorrendjének és a paraméterek adattípusának megváltoztatásával.
1. példa
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y)
(
int value = x + y;
return value;
)
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
int sum2 = d.Sum(10, 20, 30);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)
A fenti példában két módszer létezik azonos névvel, de eltérő számú paraméterrel. Az első módszer két paraméterből áll, míg a második három paraméterből áll. Ezt nevezzük módszer túlterhelésnek.
Kimenet:
2. példa
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public double Sum(double x, double y, double z)
(
double value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28, 7);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
double sum2 = d.Sum(10.0, 20.0, 30.0);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)
A fenti példában két módszer létezik azonos névvel, de adattípusuk eltérő. Az első módszer egész adattípusú, míg a második kettős adattípusú. Tehát ebben az esetben a paraméterek a különböző adattípus miatt változnak.
Kimenet:
3. példa
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public void Details(String name, int id)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id); ;
)
public void Details(int id, string name)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id);
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
d.Details("John", 10);
d.Details("Joe", 20);
Console.ReadLine();
)
)
)
A fenti példában a módszerek neve azonos, de a paraméterek sorrendje eltérő. Az első módszernek neve és azonosítója van. míg a második azonosítóval és névvel rendelkezik.
Kimenet:
Emlékeztető pontok:
- A túlterhelési koncepcióban nem lehet egynél több módszert meghatározni azonos paraméterekkel, sorrend, típus és szám esetén.
- A különböző visszatérési típusokon alapuló módszert nem lehet túlterhelni.
A C # túlterhelésének és felülbírálásának előnyei
- A túlterhelés az egyik módja a statikus elérésének, és a felülbírálás az egyik módja annak, hogy a C # elérje a dinamikus polimorfizmust.
- Rugalmasságot biztosít a felhasználó számára és a kód tisztaságát.
Következtetés
A túlterhelés és a túlterhelés nagy szerepet játszik a polimorfizmus elérésében. A felülbírálás lehetővé teszi a származtatott osztály végrehajtását a saját módján, másrészt a túlterhelés azonos nevű módszerekkel és különféle típusú paraméter-megvalósításokkal kapcsolatos.
Ajánlott cikkek
Ez egy útmutató a C # túlterhelésének és felülbírálásának. Itt a példákkal és a kód megvalósításával tárgyaljuk a C # túlterhelés és felülbírálás működését, szintaxisát, előnyeit. A következő cikkeket is megnézheti további információkért -
- Objektumok a C # -ben
- 2D tömbök a C # -ben
- A C # felülbírálása
- Csere a C # -ben
- Polimorfizmus a Java-ban
- 2D grafika Java-ban
- 3 különféle tömbtípus a PHP-ben (példák)