Trying to find a way for a factory that accepts an interface as an input.

TemplateFactory.java

import java.lang.reflect.Method;

public class Main {
	public static void main(String[] args) {
		AnimalParam ap = new AnimalParam("A");
		AnimalFactory<Animal, AnimalParam> af = new AnimalFactory<Animal, AnimalParam>();
		Animal a = af.create(Animal.class, AnimalParam.class, ap);
		System.out.println(a);
		
		BirdParam bp = new BirdParam("B", "C");
		AnimalFactory<Bird, BirdParam> bf = new AnimalFactory<Bird, BirdParam>();
		Bird b = bf.create(Bird.class, BirdParam.class, bp);
		System.out.println(b);
	}
}

class Animal {
	public String name;
	public String toString() { return "[Animal, name: " + name + "]"; }
	
	public static Animal create(AnimalParam ap) {
		Animal a = new Animal();
		a.name = ap.name;
		return a;
	}
}

class Bird extends Animal {
	public String color;
	public String toString() { return "[Bird, name: " + name + ", color: " + color + "]"; }
	
	public static Bird create(BirdParam bp) {
		Bird b = new Bird();
		b.name = bp.name;
		b.color = bp.color;
		return b;
	}
}

class AnimalParam {
	public String name;
	public AnimalParam (String name) { this.name = name; }
}

class BirdParam extends AnimalParam {
	public String color;
	public BirdParam (String name, String color) { super(name); this.color = color; }
}

class AnimalFactory<T extends Animal, PT extends AnimalParam> {
	public void template(T a) {
		a.name += 'x';
		// other template actions
	}
	
	public T create(Class<T> animalClass, Class<PT> animalParamClass, PT param) {
		try {
			Method m = animalClass.getMethod("create", animalParamClass);
			T a = (T) m.invoke(null, param);
			template(a);
			return a;
		} catch (Exception e) {
			return null;
		}
	}
}