Interface - angive at en metode skal være statisk

Det kan du ikke.

Beklager men sådan er det altså.

Iøvrigt bruger man noralt ikke interfaces til Factory, fordi
hele pointen er jo netop at en factory kan returnere mange forskellige
slags objekter.

(og det kan godt laves dynamisk således at mulighederne ikke behøver
at være harcoded)

OK - jeg ved ikke, at man normalt ikke bruger Interfaces til til Factory Patterns. Det ligger i den opgave, jeg skal lave, som siger, at et interface skal bruges og senere er det meningen, at det interface skal gøres mere generelt og implementeres i de forskellige factories....

Jeg mener aldrig at jeg har set et interface.

Det giver da ingen mening, fordi man kan ikke instantiere et interface.

Og man skal vel ikke have en factory til at instantiere sin factory ??

Det er derimod ganske normalt at have en abstrakt basis klasse til
factories.

Men det er noget lidt andet.

Lad mig komme med et eksempel.

Basis:

public interface Foobar {
    public void doit();
}

public class FoobarA implements Foobar {
    public void doit() {
        System.out.println("I am A");
    }
}

public class FoobarB implements Foobar {
    public void doit() {
        System.out.println("I am B");
    }
}

Simpel factory:

public class LibraryFactory {
    public static Foobar newFoobar(String letter) {
        Foobar res;
        try {
            res = (Foobar)Class.forName("Foobar" + letter).newInstance();
        } catch (InstantiationException e) {
            res = null;
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            res = null;
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            res = null;
            e.printStackTrace();
        }
        return res;
    }
    public static void main(String[] args) {
        Foobar a = LibraryFactory.newFoobar("A");
        a.doit();
        Foobar b = LibraryFactory.newFoobar("B");
        b.doit();
    }
}

Mere avanceret factory:

public class FoobarFactoryA extends FrameworkFactory {
    public Foobar newFoobar() {
        return new FoobarA();
    }
}

public class FoobarFactoryB extends FrameworkFactory {
    public Foobar newFoobar() {
        return new FoobarB();
    }
}

public abstract class FrameworkFactory {
    public abstract Foobar newFoobar();
    public static FrameworkFactory createFoobarFactory(String letter) {
        FrameworkFactory res;
        try {
            res = (FrameworkFactory)Class.forName("FoobarFactory" + letter).newInstance();
        } catch (InstantiationException e) {
            res = null;
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            res = null;
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            res = null;
            e.printStackTrace();
        }
        return res;
       
    }
    public static void main(String[] args) {
        FrameworkFactory af = FrameworkFactory.createFoobarFactory("A");
        Foobar a = af.newFoobar();
        a.doit();
        FrameworkFactory bf = FrameworkFactory.createFoobarFactory("B");
        Foobar b = bf.newFoobar();
        b.doit();
    }
}

Ja, det kan jeg godt se - det må absolut være måden at gøre det på. Og ikke på den måde, som opgaven lægger op til. Og så får man netop den statiske metode, som jeg gerne vil have. Takker mange gange.