Johdanto ohittamiseen C #: ssä
C #: n ohittaminen on perusluokan menetelmän uudelleen toteutus johdetussa luokassa. Tässä luokkamenetelmä ohitetaan lapsiluokassa. Johdetulla luokan menetelmällä on sama nimi ja allekirjoitus kuin perusluokan menetelmällä. Ohittaminen on hyödyllistä Runtime-polymorfismin saavuttamiseksi.
On olemassa joitain avainsanoja, joita käytetään menetelmien ohittamisessa.
1. Virtuaali - tätä avainsanaa käytetään perusluokan kanssa, joka tarkoittaa, että kantaluokan menetelmä voidaan ohittaa.
public virtual void Method()
(
// implementation
)
2. Ohitus - Tätä avainsanaa käytetään johdetun luokan kanssa, joka tarkoittaa, että johdettu luokka ohittaa perusluokan menetelmän.
public override void Method()
(
// implementation
)
3. Perusosa - Tätä avainsanaa käytetään johdetussa luokassa kutsuttamaan perusluokan menetelmää.
public override void Method()
(
base.Method();
// implementation
)
Kuinka ohittaminen toimii C #: ssä?
Alla on esimerkki siitä, kuinka voimme toteuttaa ohituksen C #: ssä.
class Parent
(
public virtual void Demo() // base class
(
Console.WriteLine(“This is parent”);
)
)
class Child: Parent
(
public override void Demo() // derived class
(
Console.WriteLine(“This is child”);
)
)
Yllä olevassa esimerkissä on kaksi luokkaa, toinen on perusluokka tai vanhempi luokka ja toinen johdettu luokka tai voidaan sanoa lastenluokka. Perusluokan menetelmä johdetaan lapsiluokassa. Tässä vanhemman menetelmä on virtuaalinen, mikä tarkoittaa sitä, että lapsiluokka voi ohittaa sen. Ohitus lapsessa tarkoittaa, että tämä menetelmä on sama kuin vanhemman luokan menetelmä samalla menetelmän allekirjoituksella.
Tyypit ohittamisessa C #
Alla on esimerkkejä, jotka osoittavat eri avainsanojen ohittamisen.
Esimerkki 1 - ilman virtuaalisia avainsanoja
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public new void fly() // derived class method
(
Console.WriteLine("Peacock is flying");
)
)
class Program
(
// main method
static void Main(string() args)
(
Bird b = new Peacock();
b.fly();
Console.ReadLine();
)
)
)
Yllä olevassa esimerkissä mitään avainsanaa ei käytetä molemmissa emäksissä samoin kuin johdetuissa menetelmissä.
Myös päämenetelmässä vanhemman viittausta käytetään lapsimenetelmän kutsumiseen. Joten tässä tapauksessa, kun avainsanaa ei käytetä, vanhempaa menetelmää kutsutaan lapsimenetelmän sijasta. Joten lähtö on
Tulos:
Esimerkki 2 (a) - virtuaalisilla ja ohittavilla avainsanoilla
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public virtual void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public override void fly() // derived class method
(
Console.WriteLine("Peacock is flying");
)
)
class Program
(
// main method
static void Main(string() args)
(
Bird b = new Peacock();
b.fly();
Console.ReadLine();
)
)
)
Tässä esimerkissä virtuaalista käytetään perusluokassa, mikä tarkoittaa, että se antaa lapsiluokalle valtuudet toteuttaa menetelmä omalla tavallaan. Johdetussa luokassa käytetään ohitusta, mikä tarkoittaa, että lapsimenetelmä on ohitusmenetelmä. Molemmat menetelmät ovat samat samalla nimellä ja samalla menetelmän allekirjoituksella, mutta toteutusosa on erilainen. Myös tässä esimerkissä vanhemman viittausta käytetään lapsimenetelmän kutsumiseen. Mutta koska vanhempi on menetelmä, se on virtuaalinen, joten lapsimenetelmää kutsutaan ensin vanhemman menetelmän sijasta. Joten lähtö on
Tulos:
Esimerkki 2 (b) - Virtuaali- ja ohitusavaimet
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public virtual void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public override void fly() // derived class method
(
Console.WriteLine("Peacock is flying");
)
)
class Program
(
//main method
static void Main(string() args)
(
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
)
)
)
Tämä esimerkki on sama kuin edellinen esimerkki, mutta tätä alamenetelmää käytetään referenssinä.
Tulos:
Esimerkki 3 - perusavaimella
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public virtual void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public override void fly() // derived class method
(
base.fly(); // base is use to call parent method
Console.WriteLine("Peacock is flying");
)
)
class Program
(
static void Main(string() args)
(
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
)
)
)
Yllä olevassa esimerkissä tukia käytetään johdetussa luokassa kutsuttamaan kantaluokan menetelmää. Joten tässä perusmenetelmässä kutsutaan ensin ja sitten johdettu menetelmä.
Tulos:
Esimerkki 4 - abstraktit luokat ohittamalla
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
abstract class Calculate
(
public abstract int sum();
)
class Values : Calculate // derived class
(
int val1;
int val2;
public Values(int a = 0, int b = 0)
(
val1 = a;
val2 = b;
)
public override int sum()
(
Console.WriteLine("sum of two values");
return (val1 + val2);
)
)
class Program
(
static void Main(string() args)
(
Values v = new Values(10, 20);
int a = v.sum();
Console.WriteLine(a);
Console.ReadLine();
)
)
)
Yllä olevassa esimerkissä käytetään abstraktia menetelmää. Abstrakti luokka toteutetaan johdetulla luokalla, joka sisältää abstraktin menetelmän.
Tulos:
Menetelmän ohittamista koskevat säännöt
- Johdetun luokan menetelmän allekirjoituksen tulisi olla sama kuin perusluokan.
- Ohittaminen ei ole mahdollista samassa luokassa.
- Käyttöoikeuksien muokkainten on oltava samat virtuaali- ja ohitusmenetelmille.
- Virtuaalista avainsanaa käytetään perusluokan menetelmässä ja ohitusta käytetään johdetussa luokan menetelmässä.
- Perusluokan menetelmän ei tulisi olla staattinen.
johtopäätös
Ohittaminen on hyödyllistä ajonaikaisessa polymorfismissa. Se antaa johdetulle luokalle mahdollisuuden toteuttaa perusluokan menetelmä omalla tavallaan. Joten menetelmän toteutus on erilainen johdettu luokka kuin sen perusluokka. Ohitettu menetelmä voi olla virtuaali, ohittaa tai abstrakti.
Suositellut artikkelit
Tämä on opas ohittamiseen C #: ssä. Tässä keskustellaan siitä, kuinka käyttää ohittavia ja erilaisia avainsanoja ohittamiseen C # -merkinnässä, sekä esimerkkejä. Voit myös käydä läpi muiden ehdottamiemme artikkeleidemme -
- Poikkeusten käsittely C #: ssä
- Ryhmät C #
- Menetelmän ohittaminen C #: ssä
- Muuttujat C #: ssä
- Pääsy muokkaimet PHP
- Polymorfismi Java
- Abstraktit luokat JavaScript-muodossa
- Esimerkkejä avainsanasta