In software engineering, Pull Up refactoring involves moving a member of a class, such as a method, from a Subclass into a Superclass.
Contents
Application
This refactoring is especially useful when subclasses of a certain class share some functionality but each implements it separately. Moving the shared functionality (using Extract Method if need be, or just moving the method) to the superclass will keep the functionality of the subclasses as it is, and give less code duplication and better code readability. This refactoring should not be used if only relatively few subclasses share a functionality, since this will add (probably) unintended functionality to other (most of the other ) subclasses. Suppose we have a class A and its subclasses B, C, D, E, F and G. If B and C share a method (for example), then a better solution in this case is creating a class that will have the B and C's shared method (let's call it Z), and have B and C use the method from that class (Z in this example). That process is called Extract Class. Another option would be making Z extend A and then making B and C extend Z.
Examples
Compare the following Java classes before and after the Pull Up refactoring is applied on myMethod2:
public class Superclass{
void myMethod(){
//do something
}
}
public class Subclass extends Superclass{
void myMethod() {
//do something
}
void myMethod2() {
//do something else
}
}
After the Pull Up refactoring is applied:
public class Superclass{
void myMethod(){
//do something
}
void myMethod2() {
//do something else
}
}
public class Subclass extends Superclass{
void myMethod() {
//do something
}
}