C# 中抽象方法和非抽象方法之间的区别

本文关键字：抽象方法 区别 之间 | 更新日期: 2023-09-27 18:37:02

在C#中，在一个抽象类中，提供了方法1实现和方法2作为抽象。我可以在子类中覆盖方法 1 和方法2。那么，抽象方法和非抽象方法有什么区别。

 abstract class baseclass
    {
        public void nonabstract_method()
        {
            Console.WriteLine("non abstract method in base class with implementation");
        }
        public abstract void abstract_method();//abstract method declaration
    }
    class childClass1: baseclass
    {
        public void nonabstract_method()
        {
            Console.WriteLine("non abstract method in child class 1 with implementation");
        }
        public override void abstract_method()
        {
            Console.WriteLine("abstract method in child class 1 with implementation");
        }
    }
    class childClass2 : baseclass
    {   

        public void nonabstract_method()
        {
            Console.WriteLine("non abstract method in child class 2 with implementation");
        }
        public override void abstract_method()
        {
            Console.WriteLine("abstract method in child class 2 with implementation");
        }
        static void Main(string[] args)
        {
            childClass2 objClass2 = new childClass2();
            objClass2.nonabstract_method();
            objClass2.abstract_method();
            childClass1 objClass1 = new childClass1();
            objClass1.nonabstract_method();
            objClass1.abstract_method();
            Console.ReadLine();
        }
    }

C# 中抽象方法和非抽象方法之间的区别

您没有覆盖这些方法。你隐藏了它们（注意编译器警告！例如，如果将测试代码更改为以下内容：

baseclass objClass2 = new childClass2();
objClass2.nonabstract_method();
objClass2.abstract_method();

您将获得输出：

基类中的非抽象方法与实现
具有实现的子类 2 中的抽象方法

nonabstract_method()必须标记为虚拟，并且子类必须使用关键字 override 才能正确覆盖该方法。在这种情况下，abstract 和 non-abstract 之间没有区别，除了 abstract 方法没有实现，并且该方法没有被覆盖，而是由子类实现。

你在代码中所做的不是覆盖非抽象和抽象方法，你只是隐藏它们。真正的覆盖应包含 override 关键字。

我可以在子类中覆盖方法 1 和方法 2

不。因为你认为"覆盖"意味着"隐藏"，所以你认为抽象和非抽象方法是相同的。实际上，抽象方法可以被覆盖，但非抽象方法不能被覆盖！只能覆盖标有 virtual、override 或 abstract 的方法，但可以隐藏所有方法。

那么什么是覆盖，什么是隐藏？请考虑以下两个类：

public class Hide {
    public void method () {
        Console.WriteLine("Original");
    }
}
public class Override {
    public virtual void method() {
        Console.WriteLine("Original");
    }
}

如果你继承Hide并隐藏method，继承Override并覆盖method，这两个子类将如下所示：

public class SubHide {
    public void method () {
        Console.WriteLine("Hidden!");
    }
}
public class SubOverride {
    public override void method() {
        Console.WriteLine("Overridden!");
    }
}

现在考虑这 6 个对象，如果调用它们的method，将打印什么？

Hide hide1 = new Hide(); // Original
Hide hide2 = new SubHide(); // Original
SubHide hide3 = new SubHide(); //Hidden!
Override override1 = new Override(); // Original
Override override2 = new SubOverride(); // Overridden!
SubOverride override3 = new SubOverride(); // Overridden!

现在你能看到两者之间的区别吗？

抽象方法本身也不包含实现。实际上必须覆盖它才能正常运行。这就是为什么你不能直接实例化抽象类，你必须实例化抽象类的子类，因为抽象类包含未实现的方法。

结论：抽象方法与非抽象方法

的最大区别在于抽象方法既可以隐藏也可以被覆盖，但非抽象方法只能被隐藏。而且抽象方法没有实现，甚至没有一对空的大括号。

相关文章：