Thank you very much for the answers.

It's just that the benefit from using this code:

public static void main(String[] args) {
  serviceConsumer(new Implementation1Factory());
  serviceConsumer(new Implementation2Factory());
}

versus using this code:

public static void main(String[] args) {
  serviceConsumer(new Implementation1());
  serviceConsumer(new Implementation2());
}

was not obvious for me. But your answers gave me the clue that the first approach (with Factory pattern) does make sense if the Factory has some non-trivial logic for creating instances of the class that implements a particular interface, like this for example:

//: interfaces/Factories1.java
interface Service {
 void method1();
 void method2();
}
//define interface that works with Classes that implement Service interface
interface ServiceFactory {
 Service getService(int i);
}
class Implementation1 implements Service {
 Implementation1() {}
@Override public void method1() {System.out.println("Implementation1 method1"); }
@Override public void method2() {System.out.println("Implementation1 method2"); }
}
class Implementation1Child extends Implementation1 {
@Override public void method1() {System.out.println("Implementation1Child method1"); }
@Override public void method2() {System.out.println("Implementation1Child method2"); }
}
class Implementation1Factory implements ServiceFactory {
@Override public Service getService(int i) {
  if (i < 1) 
   return new Implementation1();
  else
   return new Implementation1Child();
 }
}
public class Factories1 {
 public static void serviceConsumer(ServiceFactory fact, int i) {
  Service s = fact.getService(i);
  s.method1();
  s.method2();
 }

 public static void main(String[] args) {
  serviceConsumer(new Implementation1Factory(), 0);  //Implementation1 methods will be called
  serviceConsumer(new Implementation1Factory(), 1);  //Implementation1Child methods will be called
 }
}/* Output:
Implementation1 method1
Implementation1 method2
Implementation1Child method1
Implementation1Child method2
*///:~

So here, the pattern allows us to use single Factory constructor, but produce different objects with different implementations of the interface. Am I correct that in such situations this pattern is suitable?

Thank you.

I rewrote example to illustrate the statement from the last explanation:

You pass parameters that the factory uses to determine which type instance is needed and then the factory method calls you appropriate constructor for the appropriate type.

//: interfaces/Factories1.java
interface Service {
 void method1();
 void method2();
}
//define interface that works with Classes that implement Service interface
interface ServiceFactory {
 Service getService();
}
class Implementation1 implements Service {
 Implementation1() {}
@Override public void method1() {System.out.println("Implementation1 method1"); }
@Override public void method2() {System.out.println("Implementation1 method2"); }
}
class Implementation1Child extends Implementation1 {
@Override public void method1() {System.out.println("Implementation1Child method1"); }
@Override public void method2() {System.out.println("Implementation1Child method2"); }
}
class Implementation1Factory implements ServiceFactory {
 private int i;

 Implementation1Factory (int i) {this.i = i; }

@Override public Service getService() {
  if (i < 1) 
   return new Implementation1();
  else
   return new Implementation1Child();
 }
}
public class Factories1 {
 public static void serviceConsumer(ServiceFactory fact) {
  Service s = fact.getService();
  s.method1();
  s.method2();
 }

 public static void main(String[] args) {
  serviceConsumer(new Implementation1Factory(0));  //Implementation1 methods will be called
  serviceConsumer(new Implementation1Factory(1));  //Implementation1Child methods will be called
 }
}/* Output:
Implementation1 method1
Implementation1 method2
Implementation1Child method1
Implementation1Child method2
*///:~

Now I got it.

So modify the sample code you posted to pass ONE parameter to a factory method that specifies which one of those concrete classes to instantiate and return.

Have I understood you correctly? (please have a look at the code below)

//: interfaces/Factories1.java
interface Service {
 void method1();
 void method2();
}
interface ServiceFactory {
 Service getService();
 String getClassName();
}
class Implementation1 implements Service {
 Implementation1() {}
@Override public void method1() {System.out.println("Implementation1 method1"); }
@Override public void method2() {System.out.println("Implementation1 method2"); }
}
class Implementation2 implements Service {
 Implementation2() {}
@Override public void method1() {System.out.println("Implementation2 method1"); }
@Override public void method2() {System.out.println("Implementation2 method2"); }
}
class ImplementationFactory implements ServiceFactory {
 private String className;

 ImplementationFactory (String className) {this.className = className; }

@Override public String getClassName() { return className; }

@Override public Service getService() {
  try{
   return (Service) Class.forName(className).newInstance();
  }catch (InstantiationException x) {
   x.printStackTrace();
   return null;
  } catch (IllegalAccessException x) {
   x.printStackTrace();
   return null;
  } catch (ClassNotFoundException x) {
   x.printStackTrace();
   return null;
  }   
 }
}
public class Factories1 {
 public static void serviceConsumer(ServiceFactory fact) {
  Service s = fact.getService();
  if (s != null) {
   s.method1();
   s.method2();
  } else {
   System.out.println("Exception occured while trying to create instance of class: " + fact.getClassName());
  }
 }

 public static void main(String[] args) {
  serviceConsumer(new ImplementationFactory("Implementation1"));  //Implementation1 methods will be called
  serviceConsumer(new ImplementationFactory("Implementation2"));  //Implementation2 methods will be called
  serviceConsumer(new ImplementationFactory("Implementation3"));  //Will generate ClassNotFoundException
 }
}/* Output:
Implementation1 method1
Implementation1 method2
Implementation2 method1
Implementation2 method2
java.lang.ClassNotFoundException: Implementation3
        at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
        at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
        at java.lang.Class.forName0(Native Method)
        at java.lang.Class.forName(Class.java:264)
        at ImplementationFactory.getService(Factories1.java:34)
        at Factories1.serviceConsumer(Factories1.java:50)
        at Factories1.main(Factories1.java:62)
Exception occured while trying to create instance of class: Implementation3
*///:~

Thanks.