Johdatus C #: n ylikuormitukseen ja ohittamiseen
Polymorfismi on yksi tärkeimmistä käsitteistä C #: ssä. Polymorfismia on kahta tyyppiä, kokoamisaika ja ajoaika. Tämän saavuttamiseksi käytetään ylikuormitusta ja ylenmääräisiä käsitteitä. Ohittaessaan lapsiluokka voi toteuttaa vanhemmaluokkamenetelmän eri tavalla, mutta lastenluokkamenetelmällä on sama nimi ja sama menetelmän allekirjoitus kuin vanhemmalla, kun taas ylikuormituksessa luokassa on useita menetelmiä, joilla on sama nimi ja eri parametrit.
Kuinka ohittaminen ja ylikuormitus toimii C #: ssä?
Ohittamisen ja ylikuormituksen toiminta C #: ssä selitetään alla esimerkkeinä:
ensisijainen
On joitain avainsanoja, joita käytämme ohittamisessa, kuten virtuaali, ohitus ja pohja.
Syntaksi:
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”);
)
)
Tässä käytetään virtuaalisia ja ohittavia avainsanoja, mikä tarkoittaa, että perusluokka on virtuaalinen ja lapsiluokka voi toteuttaa tämän luokan, ja ohittaa, että tällä lapsiluokalla on sama nimi ja sama menetelmä-allekirjoitus kuin vanhemmaluokalla.
Esimerkki 1
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();
)
)
)
Yllä olevassa esimerkissä menetelmien nimi on sama, mutta niiden toteutus on erilainen. Perusluokassa on virtuaalinen ja sen vuoksi lastenluokka voi toteuttaa vanhemmuusluokan menetelmän omalla tavallaan. Lapsiluokan menetelmässä on avainsanan ohitus, joka osoittaa, että tämä menetelmä on ohitusmenetelmä.
lähtö:
Esimerkki 2
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();
)
)
)
lähtö:
Tässä esimerkissä johdetulla luokalla on kanta-avainsana, jota käytetään kutsumaan kanta-luokan menetelmää. Joten siinä tapauksessa johdettua menetelmää kutsutaan perusluokan menetelmän jälkeen.
Muistuttaa:
- Ylivoimaisessa konseptissa menetelmän nimi ja menetelmän allekirjoitus sekä pääsymuokkain ovat aina samat kuin vanhempien ja lasten luokka.
- Yläluokkamenetelmä ei voi olla staattinen.
Ylikuormitus
Ylikuormituksessa on useita menetelmiä, joilla on erilainen menetelmäsignaatio. Alla on joitain esimerkkejä, jotka osoittavat, kuinka voimme saavuttaa ylikuormituksen muuttamalla parametrien lukumäärää, parametrien järjestystä ja parametrien tietotyyppejä.
Esimerkki 1
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();
)
)
)
Yllä olevassa esimerkissä on kaksi menetelmää, joilla on sama nimi, mutta eri lukumäärä parametreja. Ensimmäinen menetelmä koostuu kahdesta parametrista, kun taas toisessa menetelmässä on kolme parametria. Tätä kutsutaan menetelmän ylikuormitukseksi.
lähtö:
Esimerkki 2
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();
)
)
)
Yllä olevassa esimerkissä on kaksi menetelmää, joilla on sama nimi, mutta niiden tietotyypit ovat erilaisia. Ensimmäisessä menetelmässä on kokonaisluku datatyyppi, kun taas toisessa menetelmässä on kaksinkertainen datatyyppi. Joten tässä tapauksessa parametrit vaihtelevat eri tietotyypin vuoksi.
lähtö:
Esimerkki 3
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();
)
)
)
Yllä olevassa esimerkissä menetelmien nimi on sama, mutta parametrien järjestys on erilainen. Ensimmäisellä menetelmällä on nimi ja tunnus. kun taas toisella on tunnus ja vastaavasti nimi.
lähtö:
Muistuttaa:
- Ylikuormituskonseptissa ei ole mahdollista määritellä useampaa kuin yhtä menetelmää samoilla parametreilla järjestyksen, tyypin ja numeron tapauksessa.
- Eri paluutapoihin perustuvaa menetelmää ei ole mahdollista ylikuormittaa.
Ylikuormituksen ja ohittamisen edut C #: ssä
- Ylikuormitus on yksi tapa saavuttaa staattinen ja ohittaminen on yksi tapa, jolla C # saavuttaa dynaamisen polymorfismin.
- Se tarjoaa käyttäjälle joustavuuden ja koodin puhtauden.
johtopäätös
Ylikuormituksella ja ohittamisella on suuri merkitys polymorfismin saavuttamisessa. Ohitus antaa johdetun luokan toteuttaa omalla tavallaan, ja toisaalta ylikuormitus tarkoittaa menetelmiä, joilla on sama nimi ja erityyppiset parametrien toteutukset.
Suositellut artikkelit
Tämä on opas C #: n ylikuormitukseen ja ohittamiseen. Tässä keskustellaan C #: n ylikuormituksen ja ylikuormituksen toimivuudesta, syntaksista, eduista esimerkkeillä ja koodin toteutuksella. Voit myös katsoa seuraavia artikkeleita saadaksesi lisätietoja -
- Objektit C #: ssä
- 2D-ryhmät C #: ssä
- Ohittaminen C #: ssä
- Vaihto C #: ssä
- Polymorfismi Java
- 2D-grafiikka Java-versiossa
- 3 erityyppistä taulukkoa PHP: ssä (esimerkit)