Best way to avoid duplicate code if two classes extending different class

Question

I am working on an Android project and i am facing this situation.

I have 2 class :

class A extends B
{

openDoor(){
//impl
}

closeDoor(){
//impl
}

}

class X extends Y{

openDoor(){
//impl
}

closeDoor(){
//impl
}

}

Now if you observe the are two methods common in both the classes openDoor() and closeDoor()

what is the best way to avoid duplicate methods?

My Approach

class ContainingDuplicateMethods{

     openDoor(){
    //impl
    }

    closeDoor(){
    //impl
    }

    }
   }

Create a object of ContainingDuplicateMethods in both the class and call the methods, which we call it as Strategy Pattern,but is this the best solution? why because in large projects we cannot follow this approach and people say it not GOOD PRACTICE, in that case what approach do i need to follow ?

Please note that class A and X are already extending other classes and also i dont want to use static because - Static members are loaded into memory when the program execution starts and will be in memory until the program is terminated, say my code runs continuously for days or weeks and keeps on creating many number of objects using the static references so there might be a chance that we could run out of memory.

1. use an abstract class.. put your common methods there... other classes which want to use these methods can do it by extending the abstract class... 2. in case you are already extending another class, you have very little choice.. — TheLostMind, Dec 18 '13 at 06:34
@TheLostMind yes but my class A and X are already extending the classes — user3114009, Dec 18 '13 at 06:35
then create a common utils class and make these methods as static. u can use these common methods by "UtilsClass.openDoor(). " in your other classes directly without inheritance... — TheLostMind, Dec 18 '13 at 06:36
I think you have to use use strategy pattern.. I dont see any other option here... I am not a big fan of static methods/fields :P — TheLostMind, Dec 18 '13 at 06:47

Tim B · Answer 1 · 2013-12-18T07:53:33.037

"Favour composition over inheritance" is a useful thing to remember.

Have a Door class with open and close. Include a Door as a member of both A and B.

Voila, job done.

So A.getDoor().close(). B.getDoor().open() etc.

If you need a common interface for both A and B (so you can use either somewhere) then create

interface HasDoor {
    Door getDoor();
}

Now A and B can extend any class you like and implement HasDoor. Any class requiring a door can accept a HasDoor (or just directly accept the Door object) and call open, close, etc.

No duplicated code, full flexibility.

If you need your Door to call methods back in A and B then create the Door class as abstract and implement it in A and B as an anonymous inner class. The abstract methods will be called from Door and then you can do whatever processing is needed in A and B when those methods are called.

For example class A becomes:

 class A implements HasDoor {
      private Door door = new Door() {
          @override void notifyDoorChanged(boolean closed) {
                // The door is telling us its been opened or closed
          }
      }

      @override
      public Door getDoor() {
           return door;
      }
 }

Where door is:

 public abstract class Door {
      boolean closed;
      abstract notifyDoorChanged();

      public void close() {
         closed = true;
         notifyDoorChanged(closed);
      }

      // etc
 }

Note that this is similar to the strategy pattern - but its not quite the same. The Strategy pattern has one master object and then you plug in multiple strategies (i.e. different forms of Door). This has one Door and multiple other objects using the same type of Door, although you could extend it to use the Strategy pattern and have multiple door implementations very easily.

score 3 · Answer 2 · edited Dec 18 '13 at 09:46

This is the implementation of the answer posted by Tim B. It is a very flexible approach to go with. It is following the principles of object oriented reuse :

Identify that varies and separate them from what stays the same.
Program to an interface , not an implementation.

Favor object composition over inheritance.

public class Main {

    public static void main(String[] args) {
        X x = new X();
        A a = new A();
        x.getDoor().open();
        x.getDoor().close();
        a.getDoor().open();
        a.getDoor().close();
    }
}


interface HasDoor {
    Door getDoor();
}

interface Door {
    public void open();
    public void close();
}

class A extends B implements HasDoor {
Door d;

@Override
public Door getDoor() {
    Door door = new Door() {
        public void open() {
            System.out.println("Open A's Door");
        }

        public void close() {
            System.out.println("Close A's Door");
        }
    };
    return door;
}

}

class X extends Y implements HasDoor{ Door d;

@Override
public Door getDoor() {
    Door door = new Door() {
        public void open() {
            System.out.println("Open X's Door");
        }

        public void close() {
            System.out.println("Close X's Door");
        }
    };
    return door;
}

}

class B {} class Y {}

If you do not want to use HasDoor interface, you can declare constructors inside the class X and class A that initializes the Door instance.

Example ;

class X extends Y {
    Door d;
     public X() {
         d = new Door() {
            public void open() {
                System.out.println("Open X's Door");
            }

            public void close() {
                System.out.println("Close X's Door");
            }
        };

     }



}

In my opinion, this approach still has duplicated code according to op's problem. In Tim B's answer, Door is a abstract class that's why it can have concrete implementation for open() and close() methods. In your approach, Door is Interface. That's why class A and class X still has to provide concrete implementation for Door's open() and close() methods. These two methods are identically same as per op's question. — Steve.NayLinAung, May 07 '17 at 10:32

Lijo · Answer 3 · 2013-12-18T07:22:56.210

1

so here your class a and class a has to follow same functions. that is both classes have same functions.

since the classes already extended another class we can use interface

interface door
{
 openDoor(){
    }

    closeDoor(){
    }


}

both class a and x can implement the door interface. enter image description here

A class can implement any number of interfaces but can extend only one class.

if implementation of class door is same we can do like this

class Door
{
openDoor(){
impl//
    }

    closeDoor(){
impl//
    }


}
class A extends b
{
Door d=new Door();
d.opendoor();
d.closeDorr();


}

edited Dec 18 '13 at 07:22

answered Dec 18 '13 at 07:16

Lijo

6,498
5
49
60

Yes but my implementation of openDoor() closeDoor() is also same, so creating an interface will again have dulpicate implementations – user3114009 Dec 18 '13 at 07:17
if implementation also same then write it inside a class.and in class a and X create an object of door class and access the close and open functions – Lijo Dec 18 '13 at 07:19
ok, then where will i use this interface ? i am totally confused can you please elaborate – user3114009 Dec 18 '13 at 07:20
then no need of interface,just create a class door and implment that functions.then where ever you need that functons just create the object of that class and access it.in the case of validation we do like this create one class for validation and use this one in all other classes. – Lijo Dec 18 '13 at 07:23
you mean creating an object of that class? – user3114009 Dec 18 '13 at 07:25

score 0 · Answer 4 · answered Dec 18 '13 at 06:35

0

Yes, create an abstract class which contains the common code. Have this abstract class implement an interface which contains the necessary methods.

Have both other classes extend the abstract class.

answered Dec 18 '13 at 06:35

Scary Wombat

44,617
6
35
64

score 0 · Answer 5 · answered Dec 18 '13 at 06:56

0

I think you should create an interface with methods openDoor() and closeDoor(). After that inherit classes A and X from this interface and implement methods. If methods implementation are similar then you can create utility class with static methods.

answered Dec 18 '13 at 06:56

dronidze

86
1
3

yes i had done the same thing, but still is this the best approach ? – user3114009 Dec 18 '13 at 07:00

score 0 · Answer 6 · answered Dec 18 '13 at 07:12

0

public interface YourInterface{
  public void openDoor();
  public void closeDoor();
}

public abstract class YourAbstractClass implements YourInterface{
  public abstract void openDoor();
  public abstract void closeDoor();
}

public class YourClass extends YourAbstractClass{
  @Override
  public void openDoor();
  public void closeDoor();
}

public class YourSubClass extends YourClass{
  //you can just call super methods here
  super.openDoor();
  super.closeDoor();
}

answered Dec 18 '13 at 07:12

Rick Royd Aban

904
6
33

you approach is good but if you extend some class , you cannot extend other classes. But in case of interface you can implement more than one interface. – Nishant Lakhara Dec 18 '13 at 08:01
its ok, since mr.user3114009 is only looking for a way to avoid duplication of methods – Rick Royd Aban Dec 18 '13 at 08:32
I believe that YourSubClass Class is the one he is looking for – Rick Royd Aban Dec 18 '13 at 08:32

Best way to avoid duplicate code if two classes extending different class

6 Answers6