1. Why using factory method pattern

Instead of calling a constructor directly, you call a creation method on a factory object which produces an implementation of the interface thus making it possible to transparently swap one implementation for another.

In theory, your code is completely isolated from the implementation of the interface.

2. A simple example for factory method

Service <-- Implementation1 & Implementation2
ServiceFactory <-- Im1F& Im2F

 interface Service {
    void method1();
    void method2();
 }

 interface ServiceFactory {
    Service getService();
 }
 
 class Implementation1 implements Service {
     Implementation1() {}
     public void method1() { print("Implementation1 method1");}
     public void method2() { print("Implementation1 method2");}
 }

 class Implementation1Factory implements ServiceFactory {
     public Service getService() {
             return new Implementation1();
      }
  }

 class Implementation2 implements Service {
     Implementation2() {}
     public void method1() { print("Implementation2 method1");}
     public void method2() { print("Implementation2 method2");}
 }

 class Implementation2Factory implements ServiceFactory {
     public Service getService() {
             return new Implementation2();
      }
  }

 public class Factories {
    public static void serviceConsumer(ServiceFactory fact) {
        Service s = fact.getService();
        s.method1();
        s.method2();
     }
     public static void main(String[] args) {
        serviceConsumer(new Implementation1Factory());
        serviceConsumer(new Implementation2Factory());
      }
 }

 // Output:
    Implementation1 method1
    Implementation1 method2
    Implementation2 method1
    Implementation2 method2

One more easy example about this is in here.