Override ve Yeni Anahtar Sözcüklerin Ne Zaman Kullanılacağını Öğrenme (C# Programlama Kılavuzu)

C# dilinde, türetilmiş bir sınıftaki bir yöntem, temel sınıftaki bir yöntemle aynı ada sahip olabilir. Yöntemlerin yeni ve geçersiz kılma anahtar sözcüklerini kullanarak nasıl etkileşim kuracağını belirtebilirsiniz. override Değiştirici, temel sınıf yöntemini virtual ve new değiştirici erişilebilir bir temel sınıf yöntemini gizler. Fark, bu konudaki örneklerde gösterilmiştir.

Konsol uygulamasında aşağıdaki iki sınıfı BaseClass ve DerivedClassbildirin. DerivedClass öğesinden BaseClassdevralır.

class BaseClass  
{  
    public void Method1()  
    {  
        Console.WriteLine("Base - Method1");  
    }  
}  
  
class DerivedClass : BaseClass  
{  
    public void Method2()  
    {  
        Console.WriteLine("Derived - Method2");  
    }  
}

Main yönteminde, bc, dc ve bcdc değişkenlerini bildirin.

bc türündedir ve BaseClass olup değeri BaseClass türündedir.
dc türündedir ve DerivedClass olup değeri DerivedClass türündedir.
bcdc türündedir ve BaseClass olup değeri DerivedClass türündedir. Bu, dikkate alınacak değişkendir.

Çünkü bc ve bcdcBaseClass türündedir, atama kullanmadığınız sürece yalnızca doğrudan Method1 erişebilirler. Değişken dc hem Method1 hem de Method2 öğesine erişebilir. Bu ilişkiler aşağıdaki kodda gösterilmiştir.

class Program  
{  
    static void Main(string[] args)  
    {  
        BaseClass bc = new BaseClass();  
        DerivedClass dc = new DerivedClass();  
        BaseClass bcdc = new DerivedClass();  
  
        bc.Method1();  
        dc.Method1();  
        dc.Method2();  
        bcdc.Method1();  
    }  
    // Output:  
    // Base - Method1  
    // Base - Method1  
    // Derived - Method2  
    // Base - Method1  
}

Ardından, aşağıdaki Method2 yöntemi öğesine BaseClassekleyin. Bu yöntemin imzası Method2 içindeki DerivedClass yönteminin imzası ile eşleşir.

public void Method2()  
{  
    Console.WriteLine("Base - Method2");  
}

Artık BaseClass bir Method2 metot olduğu için, aşağıdaki kodda gösterildiği gibi BaseClass ve bc değişkenleri için ikinci bir çağırma deyimi bcdc eklenebilir.

bc.Method1();  
bc.Method2();  
dc.Method1();  
dc.Method2();  
bcdc.Method1();  
bcdc.Method2();

Yeni Anahtar Sözcük

Projeyi oluşturduğunuzda, Method2 içindeki BaseClass yöntemini eklediğinizde bir uyarıya neden olduğunu görürsünüz. Uyarı, Method2 içindeki yöntemin DerivedClass içindeki Method2 yöntemini gizlediğini söyler. O sonuca neden olmak istiyorsanız new tanımda Method2 anahtar sözcüğünü kullanmanız tavsiye edilir. Alternatif olarak, uyarıyı Method2 çözümlemek için yöntemlerden birini yeniden adlandırabilirsiniz, ancak bu her zaman pratik değildir.

new eklemeden önce, ek çağrı deyimleri tarafından üretilen çıkışı görmek için programı çalıştırın. Aşağıdaki sonuçlar görüntülenir.

// Output:  
// Base - Method1  
// Base - Method2  
// Base - Method1  
// Derived - Method2  
// Base - Method1  
// Base - Method2

new anahtar sözcüğü, bu çıkışı oluşturan ilişkileri korur, ancak uyarıyı gizler. Türü BaseClass olan değişkenler, üyelerine BaseClasserişmeye devam eder ve türü DerivedClass olan değişken ilk olarak üyelere DerivedClass erişmeye ve ardından öğesinden BaseClassdevralınan üyeleri dikkate almaya devam eder.

Uyarıyı bastırmak için, aşağıdaki kodda gösterildiği gibi new içindeki Method2 tanımına DerivedClass değiştiricisini ekleyin. Değiştirici, öncesinde veya sonrasında publiceklenebilir.

public new void Method2()  
{  
    Console.WriteLine("Derived - Method2");  
}

Çıkışın değişmediğini doğrulamak için programı yeniden çalıştırın. Ayrıca uyarının artık görünmediğini doğrulayın. new kullanarak, değiştirdiği üyenin temel sınıftan devralınan bir üyeyi gizlediğinin farkında olduğunuzu onaylarsınız. Devralma yoluyla isim gizleme hakkında daha fazla bilgi için bkz. new Modifier.

Sanal ve Geçersiz Kılma Anahtar Sözcükleri

Bu davranışı kullanmanın override etkileriyle karşılaştırmak için, DerivedClass öğesine aşağıdaki yöntemi ekleyin. Değiştirici, override öncesinde veya sonrasında publiceklenebilir.

public override void Method1()  
{  
    Console.WriteLine("Derived - Method1");  
}

virtual değiştiricisini Method1 içindeki BaseClass tanımına ekleyin. Değiştirici, virtual öncesinde veya sonrasında publiceklenebilir.

public virtual void Method1()  
{  
    Console.WriteLine("Base - Method1");  
}

Projeyi yeniden çalıştırın. Özellikle aşağıdaki çıkışın son iki satırına dikkat edin.

// Output:  
// Base - Method1  
// Base - Method2  
// Derived - Method1  
// Derived - Method2  
// Derived - Method1  
// Base - Method2

override değiştiricisinin kullanılması, bcdc içinde tanımlanan Method1 yöntemine DerivedClass erişim sağlar. Genellikle, devralma hiyerarşilerinde istenen davranış budur. Türetilmiş sınıftan oluşturulan değerlere sahip nesnelerin türetilmiş sınıfta tanımlanan yöntemleri kullanmasını istiyorsunuz. Temel sınıf yöntemini genişletmek için kullanarak override bu davranışı elde edebilirsiniz.

Aşağıdaki kod, tam örneği içerir.

using System;  
using System.Text;  
  
namespace OverrideAndNew  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            BaseClass bc = new BaseClass();  
            DerivedClass dc = new DerivedClass();  
            BaseClass bcdc = new DerivedClass();  
  
            // The following two calls do what you would expect. They call  
            // the methods that are defined in BaseClass.  
            bc.Method1();  
            bc.Method2();  
            // Output:  
            // Base - Method1  
            // Base - Method2  
  
            // The following two calls do what you would expect. They call  
            // the methods that are defined in DerivedClass.  
            dc.Method1();  
            dc.Method2();  
            // Output:  
            // Derived - Method1  
            // Derived - Method2  
  
            // The following two calls produce different results, depending
            // on whether override (Method1) or new (Method2) is used.  
            bcdc.Method1();  
            bcdc.Method2();  
            // Output:  
            // Derived - Method1  
            // Base - Method2  
        }  
    }  
  
    class BaseClass  
    {  
        public virtual void Method1()  
        {  
            Console.WriteLine("Base - Method1");  
        }  
  
        public virtual void Method2()  
        {  
            Console.WriteLine("Base - Method2");  
        }  
    }  
  
    class DerivedClass : BaseClass  
    {  
        public override void Method1()  
        {  
            Console.WriteLine("Derived - Method1");  
        }  
  
        public new void Method2()  
        {  
            Console.WriteLine("Derived - Method2");  
        }  
    }  
}

Türetilmiş Sınıflarda Geçersiz Kılma ve Yeni

Aşağıdaki örnekte farklı bir bağlamda benzer davranışlar gösterilmektedir. Örnek üç sınıf tanımlar: adlı Car bir temel sınıf ve ondan ConvertibleCar türetilen iki sınıf ve Minivan. Temel sınıf bir DescribeCar yöntem içerir. Metot, bir arabanın temel açıklamasını görüntüler ve daha sonra ek bilgi sağlamak için ShowDetails çağırır. Üç sınıfın her biri bir ShowDetails yöntem tanımlar. new değiştirici, ShowDetails sınıfında ConvertibleCar tanımlamak için kullanılır. override değiştirici, ShowDetails sınıfında Minivan tanımlamak için kullanılır.

// Define the base class, Car. The class defines two methods,  
// DescribeCar and ShowDetails. DescribeCar calls ShowDetails, and each derived  
// class also defines a ShowDetails method. The example tests which version of  
// ShowDetails is selected, the base class method or the derived class method.  
class Car  
{  
    public void DescribeCar()  
    {  
        System.Console.WriteLine("Four wheels and an engine.");  
        ShowDetails();  
    }  
  
    public virtual void ShowDetails()  
    {  
        System.Console.WriteLine("Standard transportation.");  
    }  
}  
  
// Define the derived classes.  
  
// Class ConvertibleCar uses the new modifier to acknowledge that ShowDetails  
// hides the base class method.  
class ConvertibleCar : Car  
{  
    public new void ShowDetails()  
    {  
        System.Console.WriteLine("A roof that opens up.");  
    }  
}  
  
// Class Minivan uses the override modifier to specify that ShowDetails  
// extends the base class method.  
class Minivan : Car  
{  
    public override void ShowDetails()  
    {  
        System.Console.WriteLine("Carries seven people.");  
    }  
}

Örnek, ShowDetails'nin hangi sürümünün çağrıldığını test ediyor. Aşağıdaki yöntem, her sınıfın bir örneğini bildirir ve ardından her bir örnekte TestCars1 yöntemini çağırır DescribeCar.

public static void TestCars1()  
{  
    System.Console.WriteLine("\nTestCars1");  
    System.Console.WriteLine("----------");  
  
    Car car1 = new Car();  
    car1.DescribeCar();  
    System.Console.WriteLine("----------");  
  
    // Notice the output from this test case. The new modifier is  
    // used in the definition of ShowDetails in the ConvertibleCar  
    // class.
  
    Car car2 = new ConvertibleCar();  
    car2.DescribeCar();  
    System.Console.WriteLine("----------");  
  
    Minivan car3 = new Minivan();  
    car3.DescribeCar();  
    System.Console.WriteLine("----------");  
}

TestCars1 aşağıdaki çıkışı üretir. Özellikle car2 ile ilgili sonuçlara dikkat edin; muhtemelen beklediğiniz gibi olmayabilirler. ConvertibleCar nesnesinin türüdür, ancak DescribeCar, ShowDetails değiştirici ile bildirildiği için ConvertibleCar değiştirici ile değil, new sınıfında tanımlanan override sürümüne erişemez. Sonuç olarak, bir ConvertibleCar nesnesi, bir Car nesnesiyle aynı açıklamayı görüntüler. car3 için olan sonuçları karşılaştırın, ki bu Minivan nesnesidir. Bu durumda, ShowDetails sınıfında bildirilen Minivan yöntemi, ShowDetails sınıfında bildirilen Car yöntemini geçersiz kılar ve görüntülenen açıklama bir minibüsü tarif eder.

// TestCars1  
// ----------  
// Four wheels and an engine.  
// Standard transportation.  
// ----------  
// Four wheels and an engine.  
// Standard transportation.  
// ----------  
// Four wheels and an engine.  
// Carries seven people.  
// ----------

TestCars2 türüne Carsahip nesnelerin listesini oluşturur. Nesnelerin değerleri Car, ConvertibleCar ve Minivan sınıflarından örneklenir. DescribeCar , listenin her öğesinde çağrılır. Aşağıdaki kod, tanımını TestCars2gösterir.

public static void TestCars2()  
{  
    System.Console.WriteLine("\nTestCars2");  
    System.Console.WriteLine("----------");  
  
    var cars = new List<Car> { new Car(), new ConvertibleCar(),
        new Minivan() };  
  
    foreach (var car in cars)  
    {  
        car.DescribeCar();  
        System.Console.WriteLine("----------");  
    }  
}

Aşağıdaki çıkış görüntülenir. tarafından görüntülenen TestCars1çıkışla aynı olduğuna dikkat edin. ShowDetails sınıfının ConvertibleCar yöntemi, nesnenin türü ConvertibleCar olarak TestCars1'de veya Car olarak TestCars2'de olsun, yine de çağrılmaz. Tersine, car3 hem ShowDetails türüne hem de Minivan türüne sahip olduğunda, her iki durumda da Minivan sınıfından Car yöntemini çağırır.

// TestCars2  
// ----------  
// Four wheels and an engine.  
// Standard transportation.  
// ----------  
// Four wheels and an engine.  
// Standard transportation.  
// ----------  
// Four wheels and an engine.  
// Carries seven people.  
// ----------

Yöntemler TestCars3 ve TestCars4 örneği tamamlar. Bu yöntemler ShowDetails'yi doğrudan çağırır; önce türü ConvertibleCar ve Minivan olarak bildirilen nesnelerden (TestCars3), sonra türü Car olarak bildirilen nesnelerden (TestCars4). Aşağıdaki kod bu iki yöntemi tanımlar.

public static void TestCars3()  
{  
    System.Console.WriteLine("\nTestCars3");  
    System.Console.WriteLine("----------");  
    ConvertibleCar car2 = new ConvertibleCar();  
    Minivan car3 = new Minivan();  
    car2.ShowDetails();  
    car3.ShowDetails();  
}  
  
public static void TestCars4()  
{  
    System.Console.WriteLine("\nTestCars4");  
    System.Console.WriteLine("----------");  
    Car car2 = new ConvertibleCar();  
    Car car3 = new Minivan();  
    car2.ShowDetails();  
    car3.ShowDetails();  
}

Yöntemler, bu konudaki ilk örnekteki sonuçlara karşılık gelen aşağıdaki çıkışı oluşturur.

// TestCars3  
// ----------  
// A roof that opens up.  
// Carries seven people.  
  
// TestCars4  
// ----------  
// Standard transportation.  
// Carries seven people.

Aşağıdaki kod, projenin tamamını ve çıkışını gösterir.

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace OverrideAndNew2  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            // Declare objects of the derived classes and test which version  
            // of ShowDetails is run, base or derived.  
            TestCars1();  
  
            // Declare objects of the base class, instantiated with the  
            // derived classes, and repeat the tests.  
            TestCars2();  
  
            // Declare objects of the derived classes and call ShowDetails  
            // directly.  
            TestCars3();  
  
            // Declare objects of the base class, instantiated with the  
            // derived classes, and repeat the tests.  
            TestCars4();  
        }  
  
        public static void TestCars1()  
        {  
            System.Console.WriteLine("\nTestCars1");  
            System.Console.WriteLine("----------");  
  
            Car car1 = new Car();  
            car1.DescribeCar();  
            System.Console.WriteLine("----------");  
  
            // Notice the output from this test case. The new modifier is  
            // used in the definition of ShowDetails in the ConvertibleCar  
            // class.
            ConvertibleCar car2 = new ConvertibleCar();  
            car2.DescribeCar();  
            System.Console.WriteLine("----------");  
  
            Minivan car3 = new Minivan();  
            car3.DescribeCar();  
            System.Console.WriteLine("----------");  
        }  
        // Output:  
        // TestCars1  
        // ----------  
        // Four wheels and an engine.  
        // Standard transportation.  
        // ----------  
        // Four wheels and an engine.  
        // Standard transportation.  
        // ----------  
        // Four wheels and an engine.  
        // Carries seven people.  
        // ----------  
  
        public static void TestCars2()  
        {  
            System.Console.WriteLine("\nTestCars2");  
            System.Console.WriteLine("----------");  
  
            var cars = new List<Car> { new Car(), new ConvertibleCar(),
                new Minivan() };  
  
            foreach (var car in cars)  
            {  
                car.DescribeCar();  
                System.Console.WriteLine("----------");  
            }  
        }  
        // Output:  
        // TestCars2  
        // ----------  
        // Four wheels and an engine.  
        // Standard transportation.  
        // ----------  
        // Four wheels and an engine.  
        // Standard transportation.  
        // ----------  
        // Four wheels and an engine.  
        // Carries seven people.  
        // ----------  
  
        public static void TestCars3()  
        {  
            System.Console.WriteLine("\nTestCars3");  
            System.Console.WriteLine("----------");  
            ConvertibleCar car2 = new ConvertibleCar();  
            Minivan car3 = new Minivan();  
            car2.ShowDetails();  
            car3.ShowDetails();  
        }  
        // Output:  
        // TestCars3  
        // ----------  
        // A roof that opens up.  
        // Carries seven people.  
  
        public static void TestCars4()  
        {  
            System.Console.WriteLine("\nTestCars4");  
            System.Console.WriteLine("----------");  
            Car car2 = new ConvertibleCar();  
            Car car3 = new Minivan();  
            car2.ShowDetails();  
            car3.ShowDetails();  
        }  
        // Output:  
        // TestCars4  
        // ----------  
        // Standard transportation.  
        // Carries seven people.  
    }  
  
    // Define the base class, Car. The class defines two virtual methods,  
    // DescribeCar and ShowDetails. DescribeCar calls ShowDetails, and each derived  
    // class also defines a ShowDetails method. The example tests which version of  
    // ShowDetails is used, the base class method or the derived class method.  
    class Car  
    {  
        public virtual void DescribeCar()  
        {  
            System.Console.WriteLine("Four wheels and an engine.");  
            ShowDetails();  
        }  
  
        public virtual void ShowDetails()  
        {  
            System.Console.WriteLine("Standard transportation.");  
        }  
    }  
  
    // Define the derived classes.  
  
    // Class ConvertibleCar uses the new modifier to acknowledge that ShowDetails  
    // hides the base class method.  
    class ConvertibleCar : Car  
    {  
        public new void ShowDetails()  
        {  
            System.Console.WriteLine("A roof that opens up.");  
        }  
    }  
  
    // Class Minivan uses the override modifier to specify that ShowDetails  
    // extends the base class method.  
    class Minivan : Car  
    {  
        public override void ShowDetails()  
        {  
            System.Console.WriteLine("Carries seven people.");  
        }  
    }  
  
}

Ayrıca bakınız

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-06-22