-3

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

    }
4

2 回答 2

0

您在代码中所做的不是覆盖非抽象和抽象方法，您只是隐藏它们。真正的覆盖应该包含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调用它们的 s 会打印什么？

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!

现在你能看出两者的区别了吗？

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

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

于 2016-03-02T05:07:24.603 回答
0

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

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

你会得到输出：

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

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

于 2016-03-02T04:36:59.437 回答