如果一个类实现了两个接口，而这两个接口里边有相同名字的方法，在类里边如何定义这两个方法？

Question

例如
interface Interface1
{
    void Test();
}
interface Interface2
{
    void Test();
}
class ClassTest implements Interface1,Interface2
{
    void Test()//实现哪个接口的Test方法？
    {
    }
}

Answer 1

没办法分别就是一个，可以说是继承Interface1，也可以说是Interface2的
用这两个接口都可以找到这个方法

Answer 2

能编译通过？实现接口的方法一定要是public

Answer 3

能编译通过？实现接口的方法一定要是public
－－－－－
接口里的东西默认就是public的

Answer 4

对象是实现哪个接口的引用,那么Test()方法就是哪个接口的

Answer 5

这完全正常！两个接口共用一个实现。接口不是实体，只是声明。在JAVA中多次声明在原则是没有问题的，只要能保证只有一次实现就可以了。这一点和C++是类似的。从设计上说，这种设计也完全合情合理，无可厚非。

Answer 6

我不认为有什么设计问题。两个接口有相同名称的方法这很正常。比如：
interface Employee
{
    void getName();
}
interface Student
{
    void getName();
}
//研究生边在外边做兼职，既是雇员又是学生，所以实现Employee和Student
class GraduateStudent implements Employee,Student
{
    void getName();//????
}

Answer 7

上面回复是楼主吧？那么，你是疑问是什么呢？我上面说了，这种设计是完全合理的。
但记住，不同接口中同样的名字的方法只能有一处实现。
比如上面的情况你就可以处理成这样：interface Employee
{
String getName();
}
interface Student
{
String getName();
}
public class GraduateStudent implements Employee, Student
{
String name;
public String getName() {
return name;
}
}因为一般来说，一个兼职的研究生只有一个名字，不论他是员工还是学生，获得的名字都只有一个。但这也不是一概而论。
比如，如果你希望用一个getNumber()来返回他的学号或者工号，那么你就设计错了。interface Employee
{
String getName();
String getNumber();
}
interface Student
{
String getName();
String getNumber();
}
public class GraduateStudent implements Employee, Student
{
String name;
String studentNumber;
String employeeNumber;
public String getName() {
return name;
}
//public String getNumber() // how to get the number ????
}因为学号和工号是不同的，用相同的名字难以区分二者，这时你就要为学号和工号分别设计方法了，解决方法如下：interface Employee
{
String getName();
String getEmployeeNumber();
}
interface Student
{
String getName();
String getStudentNumber();
}
public class GraduateStudent implements Employee, Student
{
String name;
String studentNumber;
String employeeNumber;
public String getName() {
return name;
}
public String getEmployeeNumber() {
return employeeNumber;
}
public String getStudentNumber() {
return studentNumber;
}
}

Answer 8

建议你去看一下java的内部类来解决方法名相同的问题

Answer 9

接口可声明事件。下面的示例演示如何在类中实现接口事件。实现接口事件的规则与实现任何接口方法或属性的规则基本相同。在类中实现接口事件
在类中声明事件，然后在适当的区域调用该事件。  复制代码 
public interface IDrawingObject
{
    event EventHandler ShapeChanged;
}
public class MyEventArgs : EventArgs {…}
public class Shape : IDrawingObject
{
    event EventHandler ShapeChanged;
    void ChangeShape()
    {
        // Do something before the event…
        OnShapeChanged(new MyEventsArgs(…));
        // or do something after the event. 
    }
    protected virtual void OnShapeChanged(MyEventArgs e)
    {
        if(ShapeChanged != null)
        {
           ShapeChanged(this, e);
        }
    }
}
 示例
下面的示例演示如何处理以下的不常见情况：您的类是从两个以上的接口继承的，每个接口都含有同名事件）。在这种情况下，您至少要为其中一个事件提供显式接口实现。为事件编写显式接口实现时，必须编写 add 和 remove 事件访问器。这两个事件访问器通常由编译器提供，但在这种情况下编译器不能提供。您可以提供自己的访问器，以便指定这两个事件是由您的类中的同一事件表示，还是由不同事件表示。例如，根据接口规范，如果事件应在不同时间引发，则可以将每个事件与类中的一个单独实现关联。在下面的示例中，订户将形状引用强制转换为 IShape 或 IDrawingObject，从而确定自己将会接收哪个 OnDraw 事件。C#  复制代码 
namespace WrapTwoInterfaceEvents
{
    using System;    public interface IDrawingObject
    {
        // Raise this event before drawing
        // the object.
        event EventHandler OnDraw;
    }
    public interface IShape
    {
        // Raise this event after drawing
        // the shape.
        event EventHandler OnDraw;
    }
    // Base class event publisher inherits two
    // interfaces, each with an OnDraw event
    public class Shape : IDrawingObject, IShape
    {
        // Create an event for each interface event
        event EventHandler PreDrawEvent;
        event EventHandler PostDrawEvent;        // Explicit interface implementation required.
        // Associate IDrawingObject's event with
        // PreDrawEvent
        event EventHandler IDrawingObject.OnDraw
        {
            add
            {
                lock (PreDrawEvent)
                {
                    PreDrawEvent += value;
                }
            }
            remove
            {
                lock (PreDrawEvent)
                {
                    PreDrawEvent -= value;
                }
            }
        }
        // Explicit interface implementation required.
        // Associate IShape's event with
        // PostDrawEvent
        event EventHandler IShape.OnDraw
        {
            add 
            {
                lock (PostDrawEvent)
                {
                    PostDrawEvent += value;
                }
            }
            remove
            {
                lock (PostDrawEvent)
                {
                    PostDrawEvent -= value;
                }
            }
        }        // For the sake of simplicity this one method
        // implements both interfaces. 
        public void Draw()
        {
            // Raise IDrawingObject's event before the object is drawn.
            EventHandler handler = PreDrawEvent;
            if (handler != null)
            {
                handler(this, new EventArgs());
            }
            Console.WriteLine("Drawing a shape.");            // RaiseIShape's event after the object is drawn.
            handler = PostDrawEvent;
            if (handler != null)
            {
                handler(this, new EventArgs());
            }
        }
    }
    public class Subscriber1
    {
        // References the shape object as an IDrawingObject
        public Subscriber1(Shape shape)
        {
            IDrawingObject d = (IDrawingObject)shape;
            d.OnDraw += new EventHandler(d_OnDraw);
        }        void d_OnDraw(object sender, EventArgs e)
        {
            Console.WriteLine("Sub1 receives the IDrawingObject event.");
        }
    }
    // References the shape object as an IShape
    public class Subscriber2
    {
        public Subscriber2(Shape shape)
        {
            IShape d = (IShape)shape;
            d.OnDraw += new EventHandler(d_OnDraw);
        }        void d_OnDraw(object sender, EventArgs e)
        {
            Console.WriteLine("Sub2 receives the IShape event.");
        }
    }
    public class Program
    {
        static void Main(string[] args)
        {
            Shape shape = new Shape();
            Subscriber1 sub = new Subscriber1(shape);
            Subscriber2 sub2 = new Subscriber2(shape);
            shape.Draw();            Console.WriteLine("Press Enter to close this window.");
            Console.ReadLine();
        }
    }}
   复制代码 
Sub1 receives the IDrawingObject event.
Drawing a shape.
Sub2 receives the IShape event.
 请参见
概念
C# 编程指南
事件（C# 编程指南）
委托（C# 编程指南）