Question

我对这种情况有疑问，我在这里发布了一些示例代码....

public interface a{

      public void m1();
      public void m2();
      public void m3();
         .
         .
         .
      public void m100();
}


public class A implements a{

       public void m3(){

           // implementation code     

           }

 // Here i need to implement only m3() method but not all 100 methods
 //basically i have to implement all the other 99 methods
 // but here i don't want to either implement or provide skeleton declarations for all 
 //remaining.... what should i do for compiling this ????


}

有人可以帮忙吗？

Answer 1

我建议创建一个名为AbstractA的抽象类，它实现了接口A，但对其所有方法都有null实现。然后让每个实现类extend AbstractA。

此外，我想知道为什么你有一个单独的接口与所有这些方法，当它们不是所有的实现接口的每个类都实现。你几乎肯定在这里遇到了核心设计问题。

Answer 2

您可以使用代理。

MyInterface instance = Proxy.newProxyInstance(MyInterface.class.getClassLoader(), MyInterface.class, new InvocationHandler(){
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        if(!method.getName().equals("methodICareAbout")) {
           throw new UnsupportedOperationException();
        }

        //Implement your method here

     }
  });

免责声明：我绝不会建议在我的某个项目中实际使用这样的解决方案，但它确实允许您实现单个方法而不处理所有其他方法。

IMO有一个100个方法的界面，你只想实现一个是一个主要的代码气味，表明你应该重新考虑你的设计。但如果你的双手被束缚，你别无选择，只能使用现有的界面，这个解决方案就可以了。

Answer 3

你可以使用元代码，编写程序来编写99个抛出NotImplementedException的方法。

或者，你可以使“a”成为一个类而不是一个接口（也许是抽象的）并扩展它，只实现你需要的东西。缺点是如果您这样做，您的类不能扩展任何其他类，因为Java不支持多重继承。

Answer 4

解决此类问题的常用方法是创建实现接口的基类，并为所有方法提供STUB实现。

你可以在Swing中看到这个，例如AbstractAction类或MouseAdapter类是Action接口或MouseListener接口的简单实现更容易实施。为此，您可以提供课程AbstractA

public abstract class AbstractA implmements a
{
    public void m1() {}
    public void m2() {}
    ///... and so on
}

然后你会创建你的实际课程

public class A extends AbstractA
{
    public void m3()
    {
        //your implmentation
    }
}

Answer 5

除非你在A类或A的某个超类中实现所有100个方法，或者至少将它们作为抽象方法存在，否则A不会实现接口a。

如果你真的想要将每个方法的逻辑分开，那么你就不必在一个类中实现100个方法（这会很难看），请考虑策略模式。

M是定义一种方法的接口：

public interface M {
    public void go();
}

M的每个实现都实现了m个方法之一的逻辑：

public class M1 implements M {
    public void go() {
        //logic for m1
    }
}

public class M2 implements M {
    public void go() {
        //logic for m2
    }
}

等等。

现在，你的A类引用了100个M对象，每个方法只调用其中一个对象上的go（）。您可以单独实现和测试每个逻辑。

public class A implement a {
    M[] ms = {
            new M1(),
            new M2(),
            new M3(),
            ... ,
            new M100()};

    private do(int index) {
        ms[index].go();
    }

    public m1 {
        do(0);
    }
    public m2 {
        do(1);
    }

    public m3 {
        do(2);
    }

   ... 

    public m100 {
        do(99);
    }
}

自定义实现接口方法

5 个答案: