Szybko utwórz klasę z interfejsu w Eclipse

Question

Czy istnieje wtyczka do Eclipse, która pozwala mi szybko wygenerować nową klasę z interfejsu?

Zamiast zrobić wpisując w nowej klasie dialogowym

Idealnie pozwalając mi wybrać standardową nazwę jak IMPL na to, aby generować

Answer 1

Nie widziałem żadnych wtyczek, które to robią, ale wydaje mi się to rozsądnym skrótem.

Poniższe może stanowić podstawę wtyczki do generowania klasy bezpośrednio z wybranego interfejsu. Działa na moim pudełku (TM).

Obecnie zakłada, że ​​klasa przyjmie nazwę interfejsu z przyrostkiem "Impl" i nie powiedzie się (logując przyczynę), jeśli ten typ już istnieje.

Niektóre akcesoria mogą myślę:

• umożliwiają wybór wielu interfejsów
• określić stronę preferencji dla przyrostka realizacja opakowań i nazwy
• otworzyć dialog z wartościami zaludnionych czy „default "implementacja już istnieje

Wtyczka dodaje polecenie do menu kontekstowego dla redaktorów, widoków i zaznaczeń tekstu, wyłączając element, jeśli sel eection nie rozwiązuje interfejsu. Można go również aktywować za pomocą ctrl-6 (można oczywiście zmienić wiązania klawiszy w pliku plugin.xml, aby dostosować je do Twojego nastroju).

kod wtyczki jest następujący:

package name.seller.rich.classwizard.actions; 

import java.util.Collections; 

import org.eclipse.core.commands.AbstractHandler; 
import org.eclipse.core.commands.ExecutionEvent; 
import org.eclipse.core.commands.ExecutionException; 
import org.eclipse.core.expressions.EvaluationContext; 
import org.eclipse.core.resources.IFile; 
import org.eclipse.core.resources.IResource; 
import org.eclipse.core.runtime.CoreException; 
import org.eclipse.core.runtime.NullProgressMonitor; 
import org.eclipse.jdt.core.ICompilationUnit; 
import org.eclipse.jdt.core.IJavaElement; 
import org.eclipse.jdt.core.IType; 
import org.eclipse.jdt.core.JavaModelException; 
import org.eclipse.jdt.internal.ui.JavaPlugin; 
import org.eclipse.jdt.internal.ui.actions.SelectionConverter; 
import org.eclipse.jdt.ui.wizards.NewClassWizardPage; 
import org.eclipse.jface.viewers.IStructuredSelection; 
import org.eclipse.swt.widgets.Display; 
import org.eclipse.ui.IWorkbenchPage; 
import org.eclipse.ui.IWorkbenchPart; 
import org.eclipse.ui.IWorkbenchWindow; 
import org.eclipse.ui.PartInitException; 
import org.eclipse.ui.handlers.HandlerUtil; 
import org.eclipse.ui.ide.IDE; 
import org.eclipse.ui.wizards.newresource.BasicNewResourceWizard; 

public class GenerateClassHandler extends AbstractHandler { 

    public GenerateClassHandler() { 
    } 

    public Object execute(ExecutionEvent event) throws ExecutionException { 
     NewClassWizardPage page = new NewClassWizardPage(); 

     EvaluationContext evaluationContext = (EvaluationContext) event 
       .getApplicationContext(); 

     IWorkbenchPart activePart = (IWorkbenchPart) evaluationContext 
       .getVariable("activePart"); 
     try { 
      IStructuredSelection selection = SelectionConverter 
        .getStructuredSelection(activePart); 

      IType type = getFirstType(selection); 

      if (type != null && type.exists() && type.isInterface()) { 
       page.init(selection); 

       String typeName = type.getElementName() + "Impl"; 
       // TODO handle existing type 
       page.setTypeName(typeName, true); 

       // generate constructors and methods, allow modification 
       page.setMethodStubSelection(false, true, true, true); 

       page.setSuperInterfaces(Collections.singletonList(type 
         .getFullyQualifiedName()), true); 
       try { 
        page.createType(new NullProgressMonitor()); 

        IResource resource = page.getModifiedResource(); 
        if (resource != null) { 
         IWorkbenchWindow window = HandlerUtil 
           .getActiveWorkbenchWindowChecked(event); 
         BasicNewResourceWizard 
           .selectAndReveal(resource, window); 
         openResource((IFile) resource, window); 
        } 
       } catch (CoreException e) { 
        // TODO if we get this the type already exists, open a 
        // dialogue to allow the type name to be modified or give 
        // up? 
        logException(e); 
       } 

      } 
     } catch (JavaModelException e) { 
      logException(e); 
     } catch (InterruptedException e) { 
      logException(e); 
     } 
     return null; 
    } 

    protected void openResource(final IFile resource, 
      IWorkbenchWindow window) { 
     final IWorkbenchPage activePage = window.getActivePage(); 
     if (activePage != null) { 
      final Display display = window.getShell().getDisplay(); 
      if (display != null) { 
       display.asyncExec(new Runnable() { 
        public void run() { 
         try { 
          IDE.openEditor(activePage, resource, true); 
         } catch (PartInitException e) { 
          logException(e); 
         } 
        } 
       }); 
      } 
     } 
    } 

    @Override 
    public void setEnabled(Object context) { 
     if (context != null && context instanceof EvaluationContext) { 
      EvaluationContext evaluationContext = (EvaluationContext) context; 

      IWorkbenchPart activePart = (IWorkbenchPart) evaluationContext 
        .getVariable("activePart"); 

      try { 
       IStructuredSelection selection = SelectionConverter 
         .getStructuredSelection(activePart); 

       IType type = getFirstType(selection); 

       if (type != null) { 
        setBaseEnabled(type.isInterface()); 
        return; 
       } 
      } catch (JavaModelException e) { 
       logException(e); 
      } 
     } 

     setBaseEnabled(false); 
    } 

    private IType getFirstType(IStructuredSelection selection) { 
     IJavaElement[] elements = SelectionConverter.getElements(selection); 

     if (elements != null && elements.length > 0) { 
      if (elements[0] != null && elements[0] instanceof IType) { 
       return (IType) elements[0]; 
      } 

      try { 
       if (elements[0] != null 
         && elements[0] instanceof ICompilationUnit) { 
        IType[] types = ((ICompilationUnit) elements[0]) 
          .getAllTypes(); 

        if (types != null && types.length > 0) { 
         return types[0]; 
        } 
       } 
      } catch (JavaModelException e) { 
       logException(e); 
      } 
     } 
     return null; 
    } 

    protected void logException(Exception e) { 
     JavaPlugin.log(e); 
    } 
} 

plugin.xml przyczynić polecenie brzmi:

<?xml version="1.0" encoding="UTF-8"?> 
<?eclipse version="3.0"?> 
<plugin> 
    <extension 
    point="org.eclipse.ui.commands"> 
     <command 
     name="Generate Class" 
     categoryId="name.seller.rich.classwizard.category" 
     id="name.seller.rich.classwizard.generateClassCommand"> 
     </command> 
    </extension> 
    <extension 
    point="org.eclipse.ui.handlers"> 
     <handler 
     commandId="name.seller.rich.classwizard.generateClassCommand" 
     class="name.seller.rich.classwizard.actions.GenerateClassHandler"> 
     </handler> 
    </extension> 
    <extension 
    point="org.eclipse.ui.bindings"> 
     <key 
     commandId="name.seller.rich.classwizard.generateClassCommand" 
     contextId="org.eclipse.ui.contexts.window" 
     sequence="M1+6" 
     schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"> 
     </key> 
    </extension> 
    <extension 
    point="org.eclipse.ui.menus"> 
     <menuContribution 
     locationURI="popup:org.eclipse.ui.popup.any?after=additions"> 
    <command 
      commandId="name.seller.rich.classwizard.generateClassCommand" 
      mnemonic="G"> 
    </command> 
     </menuContribution> 
    </extension> 
</plugin> 

i MANIFEST.MF wygląda następująco:

Manifest-Version: 1.0 
Bundle-ManifestVersion: 2 
Bundle-Name: Classwizard 
Bundle-SymbolicName: name.seller.rich.classwizard; singleton:=true 
Bundle-Version: 1.0.0 
Require-Bundle: org.eclipse.ui, 
org.eclipse.core.runtime, 
org.eclipse.jdt.core;bundle-version="3.5.0", 
org.eclipse.core.expressions;bundle-version="3.4.100", 
org.eclipse.jface.text;bundle-version="3.5.0", 
org.eclipse.jdt.ui;bundle-version="3.5.0", 
org.eclipse.ui.ide;bundle-version="3.5.0", 
org.eclipse.ui.editors;bundle-version="3.5.0", 
org.eclipse.core.resources;bundle-version="3.5.0" 
Eclipse-AutoStart: true 
Bundle-RequiredExecutionEnvironment: JavaSE-1.6 

Answer 2

havn't widział coś innego niż: kliknij prawym przyciskiem typ interfejsu w eksploratorze pakietów wybrał New-> Class i automatycznie zaimplementuje ten interfejs. Nadal musisz sam nazwać nową klasę.

Answer 3

to faktycznie poprosił najszybciej as 2002

refaktoring należy wyodrębnić wszystkie (przełącznik na „wszystkie publiczne”) metodami z klasy, tworzenie interfejsu i zmienić starą klasę do ClassName Impl .

... i wpisuje jako feature request „rozwiązany” w ticket 9798, ponieważ New-> Klasy będą mieli możliwość «odziedziczone metody abstrakcyjne» (przynajmniej od Eclipse SDK 2.1 2003) do wyboru w celu automatycznie implementują te publiczne metody abstrakcyjne.

Answer 4

Jeśli utworzyć klasę, niech implementować interfejs.

Otrzymujesz błędy, ponieważ metody nie zostały zdefiniowane. Po prostu Ctrl-1, lub prawy clic, i możesz stworzyć wszystkie metody, z TODO, komentarze javadoc i tak dalej, w zależności od potrzeb (w zależności od sposobu skonfigurowania Eclipse).

Answer 5

Metoda 1: Kliknij prawym przyciskiem myszy nazwę zajęć, a następnie wybierz "Szybka korekta", d pojawi się małe menu, w którym wybierzesz: "Dodaj niezmodyfikowane metody".

Metoda 2: Kliknij prawym przyciskiem myszy na nazwę klasy, przejdź do „źródła”, następnie wybierz „Zastąp/Wdrożenie metody”