Question

在C＃中，在抽象类中，将method1实现和method2作为抽象提供。我可以覆盖子类中的method1和method2。那么，抽象方法和非抽象方法之间有什么区别。

 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();
        }

    }

Answer 1

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

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

您将获得输出：

基类中非抽象方法的实现
子类2中的抽象方法，带有实现

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

Answer 2

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

我可以覆盖子类中的method1和method2

没有。因为您认为“覆盖”意味着“隐藏”，您认为抽象和非抽象方法是相同的。实际上，可以覆盖抽象方法，但不能覆盖非抽象方法！只有标有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!

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

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

结论：抽象方法和非抽象方法的最大区别在于抽象方法可以隐藏或覆盖，但非抽象方法只能隐藏。并且抽象方法没有实现，甚至没有一对空花括号。

抽象方法与C＃中非抽象方法的区别？

2 个答案: