Sounds interesting, but I'm not really sure I fully understand. Could you describe a use case, with a before and after code-sample?
Thanks!

@ralphbenjamin

Yes, it might be a bit long, but here it goes:
Suppose you start with this class:

-------------------------------------------------
package myorg.package

public class A {
    public void method1() {...}
    public void method2(int arg2) {...}
    public void method2(String arg3) {...}
}
-------------------------------------------------

and you copy it to another package (it could be the same package too) and you chage its name to B, you also add and remove some methods:

-------------------------------------------------
package myorg.anotherpackage

public class B {
    public void method1() {...}
    public void method2(int arg2) {...}
    public int getNumber() {...}
    public String getName() {...}
}
-------------------------------------------------

Because the class was copied, the implementation of method1 and method2 are redundant, so a superclass could be used there.

Now, in the Projects view, I would like to select both classes (Ctrl + click), make a right click on either of them, select Refactoring, and extract superclass (or extract common superclass). 

Because 2 (there might be more) classes were selected, the refactoring code would compare the methods contents (if they were different, the user could select which implementation should go to the soon-to-be-created superclass) and will ask for a superclass name, its location and if it should be made abstract (pretty much the same options we currently have for refactoring).

Let's say that we choose SuperclassAB for its name, myorg.commonpackage for the package in which it should be located and we choose to make it abstract.
The code after refactoring would look like this:

-------------------------------------------------
package myorg.commonpackage

public abstract class SuperclassAB {
    public void method1() {...}
    public void method2(int arg2) {...}
}
-------------------------------------------------

-------------------------------------------------
import myorg.commonpackage.SuperclassAB;

package myorg.package

public class A extends SuperclassAB {
    public void method2(String arg3) {...}
}
-------------------------------------------------

-------------------------------------------------
import myorg.commonpackage.SuperclassAB;

package myorg.anotherpackage

public class B extends SuperclassAB {
    public int getNumber() {...}
    public String getName() {...}
}
-------------------------------------------------

Of course the same could be applied if we want to extract a common interface. In this case the code code would be:


-------------------------------------------------
package myorg.commonpackage

public abstract class IntefaceAB {
    void method1();
    void method2(int arg2);
}
-------------------------------------------------

-------------------------------------------------
import myorg.commonpackage.InterfaceAB;

package myorg.package

public class A implements InterfaceAB {
    @Override public void method1() {...}
    @Override public void method2(int arg2) {...}
    public void method2(String arg3) {...}
}
-------------------------------------------------

-------------------------------------------------
import myorg.commonpackage.IntefaceAB;

package myorg.anotherpackage

public class B implements InterfaceAB {
    @Override public void method1() {...}
    @Override public void method2(int arg2) {...}
    public int getNumber() {...}
    public String getName() {...}
}
-------------------------------------------------

Well, I hope the idea is clear now... Please let me know if you need any further clarification.
Thanks!