combine Fragment and Activity class in Base class

Question

I have 2 classes:

public class MyFragment extends Fragment implements MyListener
public void myFun1()
public void myFun2()
public void myFun23()

public class MyActivity extends AppCompatActivity implements MyListener
public void myFun1()
public void myFun2()
public void myFun34()

I am trying to combine my two classes in an base class so I need to write myFun1() and myFun2() only once but the problem is that one class extends Fragment and one class extends Activity. How can I bring the functions together in one base class?

EDIT: The methods do not come from the listener and can be ignored. myFun1() and myFun2() have the same functionality while myFun23() and myFun34() have both a special function only necessary in its class

Answer 1

You can do it only with Java8 that introduced the default methods in interfaces.
You can define something like:

public interface MyInterface {

    default void myFun1() {
         // default method implementation
    }

    default void myFun2() {
         // default method implementation
    }

}

Then:

   public class MyActivity extends AppCompatActivity implements MyListener, MyInterface {

     // Just define
     public void myFun23(){}
   }

   public class MyFragment extends Fragment implements MyListener, MyInterface {

     // Just define
     public void myFun34(){}
   }

You can do the same with kotlin.

interface MyInterface {
    fun myFun1() {
      // implementation
    }
    //...
}

Then:

class MainActivity : AppCompatActivity(), MyInterface {

    fun func23() {
       //...
    }
}

....

Answer 2

In this specific situation probably your myFun1() and myFun2() access some member variables in MyFragment and MyActivity. If you want to common out (like strategy pattern) the implementation of the myFun1() and myFun2() you should supply those variables to the common implementation either directly, or indirectly by introducing another interface.

The second solution of introducing another interface is mostly not preferable. In the first solution we end up with a strategy like the following.

class DataFetchingStrategy(val repo: Repository) : MyListener {
    fun myFun1() {
      repo.fetchData1()
    }

    fun myFun2() {
      repo.fetchData2()
    }
}

A strategy is not a listener. Even though we name it differently like DataFetcher or RepoManager, they are also not listeners.

Then how can we eliminate the duplicate code from the listener methods? Listener methods should be as lean as possible and the listener implementations should be ad hoc. The listener methods will forward the call to a strategy or delegate or composite etc. Not the strategy or delegate or composite will implement the listener.

class DataFetcher(val repo: Repository) {
  fun fetchData1() {
    // implementation
  }

  fun fetchData2() {
    // implementation
  }
}

class MyFragment : Fragment, MyListener {
  val dataFetcher = DataFetcher(Repository())

  fun myFun1() = dataFetcher.fetchData1()

  fun myFun2() = dataFetcher.fetchData2()

  fun myFun23() {}
}

class MyActivity : AppCompatActivity, MyListener {
  val dataFetcher = DataFetcher(Repository())

  fun myFun1() = dataFetcher.fetchData1()

  fun myFun2() = dataFetcher.fetchData2()

  fun myFun34() {}
}