Une mise en œuvre partielle d'une interface

Avoir seulement une petite quantité de temps à la recherche pour de telles choses, je ne pouvais rien voir qui a couvert mon scénario spécifique.

Je suis en train de travailler avec une 3ème partie de l'interface. Supposons pour un moment il est comme suit:

    public interface interface1
    {
        public String getVar1();

        public void  method1();

        public void method2();

    }

J'ai besoin de créer un certain nombre de classes qui rendent l'utilisation de cette interface, mais la méthode de la mise en œuvre de "method2" serait différent sur chaque,lorsque "method1" et "getVar1" serait toujours le même code.

Est-il possible de créer une classe de base abstraite qui implémente l'interface, mais seulement les forces de la mise en œuvre de "method2" sur les classes enfant?

J'avais essayé

public abstract @Override void method2

mais tout ce qui est "acceptable" au moment de la conception dans Netbeans (ne sais pas si Eclipse agit différemment) au moment de la compilation, il se plaint de ce que method2 doit être mis en œuvre.

Si il n'est pas possible, juste assez, j'ai juste besoin de vérifier.

grâce

Vous devez déclarer votre de la classe résumé et laisse-le en dehors de toute mise en œuvre de method2

OriginalL'auteur Paul Eden | 2013-09-03

  1. 16

    Vous pouvez le faire en créant une classe abstraite qui implémente l'interface. Toute sous-classe de cette classe abstraite seront nécessaires pour mettre en œuvre toutes les méthodes d'interface qui n'étaient pas encore définis.

    public abstract class AbstractInterface implements interface1 {
    @Override
    public String getVar1() {

    }

    @Override
    public void method1() {

    }
}
    public class Implementation extends AbstractInterface {
    @Override
    public void method2() {

    }
}

    Voir: Java tutoriel sur les classes abstraites.

    Parfait, merci.

    OriginalL'auteur Tim Cooper

  2. 2

    Vous pouvez créer une classe abstraite qui ne permet pas de mettre en œuvre method2()

    public abstract class AbstractImplementation implements interface1 {
    public String getVar1() { 
      //implementation ..
    }

    public void  method1() {
      //implementation ..
    }

    //skip method2
}

    Alors créer de multiples implémentations:

    public class Implementation1 extends AbstractImplementation {
    public void method2() {
      //implementation 1
    }
} 

public class Implementation2 extends AbstractImplementation {
    public void method2() {
      //implementation 2
    }
}

...
    Il parle de la troisième partie de l'interface.Si le code de programme tiers est nulle(interface1 test){ test.getVar1(); // pas en mesure d'appeler ce service }
    Ups, j'ai oublié d'ajouter implements interface1. Corrigé cela. Merci pour l'info

    OriginalL'auteur micha

  3. 0

    Vous pouvez avoir un abstract Class permettant la mise en œuvre de la "méthode 1" et "getVar1" mais decalre method2 as abstract dans cette Classe.

    Maintenant Hériter de ce Résumé de la Super Classe de toutes les autres Classes!

    Comme 

    public interface interface1 {

    public void getVar1();

    public void method1();

    public void method2();

}

public abstract class test implements interface1 {

    @Override
    public void getVar1() {
        //TODO Auto-generated method stub

    }

    @Override
    public void method1() {
        //TODO Auto-generated method stub

    }

    @Override
    public abstract void method2();


}

public class test1 extends test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //TODO Auto-generated method stub

    }

    @Override
    public void method2() {
        //TODO Auto-generated method stub

    }

}

    OriginalL'auteur Nargis

  4. 0

    Dans ce cas, vous avez 3 méthodes abstraites dans l'interface, vous pouvez remplacer une ou deux méthodes et d'autres méthodes restera comme abstraite

    abstact class PartialImplementationDemo implements interface1 {
  @Override
  public void method1() {
    //override method1() here
  }

  //leave other methods as abstract
  abstract public void method2();
  abstract public String getVar1();
}

    OriginalL'auteur alexvipul

  5. 0
    interface I1
{
    public void  Method1();
    public void Method2();
}
abstract class A implements I1
{
    public void Method1()
    {
         System.out.println("In  Method 1");
    }

    abstract public void Method3();
}
class B extends A    //Inherits class A 
{
    public void Method2()
    {
         System.out.println("In Method 2");
    }
    public void Method3()
    {
         System.out.println("In Method 3");
    }
}
public class Main 
    {
     public static void main(String args[])
        {
            B b1=new B();
            b1.Method1();
            b1.Method2();
            b1.Method3();
        }            
    }
    La sortie sera:Dans la Méthode 1 Méthode 2 Méthode 3
    Merci de modifier votre réponse et ajoutez un peu d'info sur la façon d'appliquer ce code.

    OriginalL'auteur Jayswal Mihir