пользовательская реализация методов интерфейса

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

Вы можете использовать прокси.

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 2

Я бы предложил создать единственный абстрактный класс AbstractA, который бы реализовывал интерфейс A, но имел нулевые реализации для всех его методов. Затем пусть каждый из ваших классов реализации extend AbstractA.

Также мне хотелось бы знать, почему у вас есть единый интерфейс со всеми этими методами, когда они не предназначены для реализации каждым классом, реализующим интерфейс. У вас почти наверняка есть проблема с основным дизайном.

Answer 3

Если вы не реализуете все 100 методов в классе A или в каком-либо суперклассе A, или по крайней мере не заглушите их как абстрактные методы, 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);
    }
}

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

Вы можете мета-код, написать программу, чтобы написать 99 методов, которые генерируют исключение NotImplementedException.

Или вы можете сделать класс "a" вместо интерфейса (возможно, абстрактного) и расширить его, реализуя только то, что вам нужно. Недостатком является то, что ваш класс не может расширять какие-либо другие классы, если вы делаете это, поскольку Java не поддерживает множественное наследование.