接口与virtual，override，new关键字

最新推荐文章于 2024-11-13 20:41:35 发布

转载最新推荐文章于 2024-11-13 20:41:35 发布 · 93 阅读

本文探讨了C#中接口与类之间的继承机制，包括类继承接口、接口间继承及其实现细节。通过具体示例介绍了接口方法的查找顺序、多态的应用、以及子类如何重写或隐藏父类的方法。

一，类继承接口

1，首先我们定义一个简单的ITeacher接口，并定义一个Professor类继承它。

        public interface ITeacher
        {
            void Print();
        }

        public class Professor : ITeacher
        {
            public void Print()
            {
                Debug.Write("I'm Professor!");
            }
        }

然后用接口变量调用如下：

            ITeacher teacher = new Professor();
            teacher.Print();

输出结果：I'm Professor!

2，将Professor类的Print方法改为Virtual结果会怎么样？

        public class Professor : ITeacher
        {
            public virtual void Print()
            {
                Debug.Write("I'm Professor!");
            }
        }

输出结果：I'm Professor!

Virtual的加入，并没有改变接口的行为，但是有了这个关键字，我们可以在子类中重写Professor类的Print方法。

3，定义AssistantProfessor类，继承自Professor类。

        public class AssistantProfessor : Professor
        {
            public override void Print()
            {
                Debug.Write("I'm AssistantProfessor!");
            }
        }

            ITeacher teacher = new AssistantProfessor();
            teacher.Print();

结果输出：I'm AssistantProfessor!

注意，Professor继承了ITeacher接口，它的子类AssistantProfessor无需再显示继承这个接口，子类默认也实现了这个接口，如果子类AssistantProfessor类不实现Print方法，接口会调用父类Professor的Print方法。如果子类AssistantProfessor重写override父类Professor的Print方法，接口会调用子类AssistantProfessor的Print方法，这其实是和类的继承调用一致，用多态可以解释这个原理。

4，在子类AssistantProfessor中使用new关键字，结果会如何？

        public class AssistantProfessor : Professor
        {
            public new void Print()
            {
                Debug.Write("I'm AssistantProfessor!");
            }
        }

上面的代码编译没有任何问题，子类AssistantProfessor的Print方法加了new关键字，代表隐藏父类的Print方法。

而不是父类的重写，这时就没有多态了，接口会调用父类的Print方法，所以结果输出：I'm Professor!。

5，孙子类的Print方法，接口还能调用吗？

        public class Professor : ITeacher
        {
            public virtual void Print()
            {
                Debug.Write("I'm Professor!");
            }
        }

        public class AssistantProfessor : Professor
        {
            public override void Print()
            {
                Debug.Write("I'm AssistantProfessor!");
            }
        }

        public class SubAssistantProfessor : AssistantProfessor
        {
            public override void Print()
            {
                Debug.Write("I'm SubAssistantProfessor!");
            }
        }

            ITeacher teacher = new SubAssistantProfessor();
            teacher.Print();

上面的代码，运行结果：I'm SubAssistantProfessor!

这里依然是多态的作用，不知道大家注意到没有，子类AssistantProfessor用了override关键字，孙子类SubAssistantProfessor居然还能用override关键字，不是只有声明为virtual的方法才能override吗？

利用反编译工具，我们可以清晰的看到带有override的方法，被编译后依然是一个虚方法，可以被重写。我想，

这也是多态的意义所在，后辈子类才能表现出各自不同的行为。

	// Methods
	.method public hidebysig virtual 
		instance void Print () cil managed 
	{
		// Method begins at RVA 0x22bb
		// Code size 13 (0xd)
		.maxstack 8

		IL_0000: nop
		IL_0001: ldstr "I'm AssistantProfessor!"
		IL_0006: call void [System]System.Diagnostics.Debug::Write(string)
		IL_000b: nop
		IL_000c: ret
	} // end of method AssistantProfessor::Print

6，子类显示实现接口

        public interface ITeacher
        {
            void Print();
        }

        public class Professor : ITeacher
        {
            public virtual void Print()
            {
                Debug.Write("I'm Professor!");
            }
        }

        public class AssistantProfessor : Professor, ITeacher
        {
            public new void Print()
            {
                Debug.Write("I'm AssistantProfessor!");
            }
        }

            ITeacher teacher = new AssistantProfessor();
            teacher.Print();

上面这个例子和上面的情况4只有一点区别，子类AssistantProfessor显示实现了ITeacher接口。这时，通过ITeacher变量直接找到的是子类AssistantProfessor的Print方法，所以输出结果是：I'm AssistantProfessor!

再看看这段代码：

        public interface ITeacher
        {
            void Print();
        }

        public class Professor : ITeacher
        {
            public virtual void Print()
            {
                Debug.Write("I'm Professor!");
            }
        }

        public class AssistantProfessor : Professor, ITeacher
        {
        }

上面这段代码结果：I'm Professor!

虽然子类定义了Iteacher接口，但是没有提供任何实现。

再来看看这段代码：

        public interface ITeacher
        {
            void Print();
        }

        public class Professor 
        {
            public virtual void Print()
            {
                Debug.Write("I'm Professor!");
            }
        }

        public class AssistantProfessor : Professor, ITeacher
        {
        }

这段代码能编译过吗？父类没有实现ITeacher接口，子类实现了Iteacher接口，但却没提供实现方法。

奇怪的是，它能编译通过，运行结果为：I'm Professor!没错！父类实现了ITeacher中定义的方法，子类可以不实现。

上面的一些例子可能有些出乎我们的意料，从中我们也可以大致归纳出接口的调用顺序，去解释那些奇怪的问题。

7，从上面的实验，简单归纳，接口方法执行时的查找顺序：

1）实例类如果直接继承了接口，则查找实例类上有无接口方法，如果有，直接执行；如果没有，查找实例类父类中有无接口方法，如果有，执行之。（不可能出现找不到的情况，不然编译是通不过的）

2）实例类如果没有直接继承接口，首先查找实现接口的父类，然后查找父类中有无接口方法，如果有，查看方法是否是virtual方法，如果是，查看实例类有无重写这个方法，如果重写则调用实例类的方法，如果没有重写，直接调用父类的virtual方法。如果在实现接口的父类中没有找到接口方法，则在父类的父类往上查找，直到找到为止，执行该方法。（同理，也不可能出现找不到的情况，不然编译通不过）

二，接口间的继承

1,接口可以继承接口

        public interface ITeacher
        {
            void Print();
        }

        public interface IGoodTeacher : ITeacher
        {
            void Read();
        }

如果我们要定义一个类来继承IGoodTeacher的话，必须同时实现Print和Read方法，不然会编译出错

        public class Professor : IGoodTeacher
        {
            public void Print()
            {
                Debug.Write("I'm Professor! Print");
            }

            public void Read()
            {
                Debug.Write("I'm Professor! Read");
            }
        }

2,子类如果继承Professor，也会自动继承IGoodTeacher

        public class AssistantProfessor : Professor
        {
        }

AssistantProfessor没有提供任何方法，即便AssistantProfessor在显示继承IGoodTeacher接口，也可以不提供任何方法，因为它的父类已经提供了这些方法，这和我们上面讨论的类继承接口的分析方法是一致的，这里就不做进一步的讨论了。