Rapidement créer une classe à partir d'une interface dans eclipse

Je n'ai pas vu tous les plugins qui font cela, mais il semble raisonnable de raccourci pour moi.

Suivantes pourraient constituer la base d'un plugin pour générer une classe directement à partir d'une interface sélectionnée. Il fonctionne sur ma box(TM).

Il suppose la classe prendra le nom de l'interface suffixé par "Impl" et ne parvient pas (l'enregistrement de la raison), si ce type existe déjà.

Quelques améliorations que je peux penser de:

• permettre la sélection de plusieurs interfaces
• définir une page de préférences pour la mise en œuvre de suffixe et le nom du package
• ouvrir un dialogue avec les valeurs renseignées si le "par défaut" de la mise en œuvre existe déjà

Le plugin ajoute une commande du menu contextuel pour les éditeurs, les vues et les sélections de texte, la désactivation de l'élément, si la sélection ne se résout pas à une interface. Il peut aussi être activé avec ctrl-6 (vous pouvez bien sûr modifier la clé-des liaisons dans l'plugin.xml en fonction de votre humeur).

Le code du plugin est comme suit:

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);
}
}

L'plugin.xml pour contribuer à la commande est:

<?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>

et le manifeste.mf ressemble à ceci:

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

Il a été demandé dès en 2002

Le refactoring devez extraire toutes (switch pour "tout public") les méthodes
à partir d'une classe, de créer une interface, et de renommer l'ancienne classe
pour ClassnameImpl.

... et entre comme un demande de fonctionnalité, "résolu "dans billet 9798, parce que le Nouveau->Classe aura l'option "Hérité de la méthode abstraite" (depuis au moins Eclipse SDK 2.1 2003) pour vous de choisir pour automatiquement mettre en œuvre ces méthodes abstraites.

Méthode 1: clic Droit sur le nom de la classe, puis choisissez "Quick Fix", et puis, un petit menu s'affiche, dans laquelle vous choisissez: "Ajouter des méthodes non implémentées".

Méthode 2: clic Droit sur le nom de la classe, allez à la "Source", puis choisissez "Remplacer/mettre en Œuvre des Méthodes"