我只知道多态的实现有虚方法、抽象方法、还有接口，其他的不知道还有什么，而且是不怎么具体，希望给举个例子，介绍下。

多态：可以理解为事物存在的多种表现形态。
1.多态的体现
父类的引用指向了自己的子类对象
父类的引用也可以接收自己的子类对象
2.多态的前提
必须是类与类之间有关系。继承或者实现
通常还要存在覆盖
3.多态的好处
多态的出现大大的提高了程序的扩展性
4.多态的弊端
虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员
---------------------------------------------------------------------------------------------------
多态的实例
class fu
{

}
在多态中成员函数的特点
在编译时期参阅引用型变量所属的类中是否有调用方法，如果有，编译通过；如果没有，编译失败
在运行时期参阅对象所属的类中是否有调用方法
总结：成员函数在多态调用时编译看左边，运行看右边

在多态中成员变量的特点
无论编译和运行都参考左边（引用型变量所属的类）

在多态中静态成员函数的特点
无论编译和运行都参考右边

不好意思 网不好  这是实例
多态的实例
class Fu
{
       void method1 ()
       {
             System.out.println("fu method_1");
       }
       void method2 ()
       {
             System.out.println("fu method_2");
       }

}

class Zi extends Fu
{
        void method1 ()
       {
             System.out.println("zi method_1");
       }
       void method3 ()
       {
             System.out.println("zi method_3");
       }

}


class DuoTai
{
      public static void main(String[] args)
      {
          Fu f = new Zi()
          f.method1();    //打印zi method_1
          f.method2();    //打印fu method_2
/*在多态中成员函数的特点
在编译时期参阅引用型变量所属的类中是否有调用方法，如果有，编译通过；如果没有，编译失败
在运行时期参阅对象所属的类中是否有调用方法
总结：成员函数在多态调用时编译看左边，运行看右边
*/
      }
}

以下开发时基本不用，一般出现在面试下
在多态中成员变量的特点
无论编译和运行都参考左边（引用型变量所属的类）

在多态中静态成员函数的特点
无论编译和运行都参考右边

1. public interface ISay
   
2.         {
   
3.                 void Say();
   
4.         }
   
5.                
   
6.         public class RealDuck : ISay
   
7.         {
   
8.                 public void Say()
   
9.                 {
   
10.                         Console.WriteLine("我是真鸭子");
    
11.                 }
    
12.         }
    
13.         
    
14.         public class WoodDuck : ISay
    
15.         {
    
16.                 public void Say()
    
17.                 {
    
18.                         Console.WriteLine("我是木鸭子");
    
19.                 }
    
20.         }
    
21.         
    
22.         public class FakeDuck : ISay
    
23.         {
    
24.                 public void Say()
    
25.                 {
    
26.                         Console.WriteLine("我是假鸭子");
    
27.                 }
    
28.         }
    
29.         
    
30.         public class TestDuck
    
31.         {
    
32.                 public static void Test()
    
33.                 {
    
34.                         //接口多态
    
35.                         List<ISay> ducks = new List<ISay>{
    
36.                                 new RealDuck(), new FakeDuck(), new WoodDuck()
    
37.                         };
    
38.                         
    
39.                         foreach (var duck in ducks)
    
40.                         {
    
41.                                 duck.Say();
    
42.                         }
    
43.                         
    
44.                         Console.WriteLine("---------------------------");
    
45.                         List<Duck> ducks2 = new List<Duck>{
    
46.                                 new RealDuck2(), new FakeDuck2(), new WoodDuck2()
    
47.                         };
    
48.                         
    
49.                         foreach (var duck in ducks2)
    
50.                         {
    
51.                                 duck.Say();
    
52.                         }
    
53.                         
    
54.                 }
    
55.         }
    
56.         
    
57.         public class Duck
    
58.         {
    
59.                 public virtual void Say(){}
    
60.         }
    
61.         
    
62.         public class RealDuck2 : Duck
    
63.         {
    
64.                 public override void Say()
    
65.                 {
    
66.                         Console.WriteLine("我是RealDuck2");
    
67.                 }
    
68.         }
    
69.         
    
70.         public class WoodDuck2 : Duck
    
71.         {
    
72.                 public override void Say()
    
73.                 {
    
74.                         Console.WriteLine("我是WoodDuck2");
    
75.                 }
    
76.         }
    
77.         
    
78.         public class FakeDuck2 : Duck
    
79.         {
    
80.                 public override void Say()
    
81.                 {
    
82.                         Console.WriteLine("我是FakeDuck2");
    
83.                 }
    
84.         }

复制代码

以前回答的别人的答案，可以参考下

接口的多种不同的实现方式即为多态，通过继承实现的不同对象调用相同的方法，表现出不同的行为