Question: I followed [this tutorial](http://www.joellipman.com/articles/google/android/application-development/android-os-add-googlemap-as-fragment.html) to add a map to one of my tabs. It works, but when I open the map tab I cannot swipe up/down, zoom in/out (except when I double click). Swiping left/right works, but the map moves very little. I made a customViewPager, and it disables swiping the tabs, but does nothing for he map.

At first I used tabActivity and my map fragment worked as it should, and looked like this:

```
   mapActivity extends FragmentActivity...

```

Since tabActivity is deprecated I added sliding tabs, following the tutorial above. Map could not be added with FragmentActivity, only with Fragment so I changed map fragment to: 

```
   mapActivity extends Fragment...

```

Now I have the following problem - I cannot navigate the map. Swipe and touch inputs are not detected. I cannot move up or down, zoom in or out, and the only thing I can do is move from left to right, but it is very slow.

Answer: 
```
public interface CustomInterface {
    public void method1();
}

public interface CustomInterface2 extends CustomInterface {
    public void meathod2();
}

```

Other than default method you can use inheritance property as show above by which new interface will have all previous method along with new methods and use this interface in your required situation.
I think your question is more about design and techniques, so java8 answers are a bit misleading. This problem was known long before java8, so there are some other solutions for it.

First, there are no absolutely chargeless ways to solve a problem. The size of inconviniences that come from interface evolving depends on how the library is used and how deliberate your design is. 

**1)** No techniques will help, if you designed an interface and forgot to include a **mandatory** method in it. Plan your design better and try to anticipate how clients will use your interfaces.  

Example: Imagine `Machine` interface that has `turnOn()` method but misses `turnOff()` method. Introducing a new method with default empty implementation in java8 will prevent compilation errors but will not really help, because calling a method will have no effect. Providing working implementation is sometimes impossible because interface has no fields and state.

**2)** Different implementations usually have things in common. Don't be afraid to keep common logic in parent class. Inherit your library classes from this parent class. This will enforce library clients to inherit their own implementations from your parent class as well. Now you can make small changes to the interface without breaking everything.  

Example: You decided to include `isTurnedOn()` method to your interface. With a basic class, you can write a default method implementation that would make sence. Classes that were not inherited from parent class still need to provide their own method implementations, but since method is not mandatory, it will be easy for them.

**3)** Upgrading the functionality is usually achieved by extending the interfaces. There's no reason to force library clients to implement a bunch of new methods because they may not need them.  

Example: You decided to add `stayIdle()` method to your interface. It makes sence for classes in your library, but not for custom client classes. Since this functionality is new, it's better to create a new interface that will extend `Machine` and use it when it's needed.