Auto di istanze in Java

Question

Come faccio a sé un'istanza di una classe Java? Non dovrei utilizzare qualsiasi file diverso dal suo file di classe. presumono inoltre che dopo la linea dove ho inizializzato la variabile NAME, non sanno il nome della classe durante la fase di compilazione.

Esempio:

public class Foo implements Bar {
    public static final String NAME = "Foo";

    private void instantiate()  {
        Bar baz = (Bar)Class.forName(NAME).newInstance();
    }
    //...
}

sarebbe sbagliato dal momento che ha bisogno di avere un altro file chiamato Bar.java. Dovrebbe essere:

public class Foo {
    /*
    Instantiate self...
    */
}

Sono entrato in questa programmazione sfida sito web in cui mi è permesso solo per inviare un file per problema. Voglio creare una classe modello per tutte le classi che userò per le sfide. Quindi, quello che ho in mente è che farò questo:

public class Foo {
    public static final String NAME = "Foo";


    public static void main (String[] args) throws IOException {
        //Instantiate self and call launch(args)
        Foo foo = new Foo();
        foo.launch(args);
        System.exit(0);
    }

    public void launch(String[] args) {
        //...Do actual code here
    }
}

voglio cambiare solo il nome della classe e la variabile NAME e non è necessario cambiare il mio modo di creare un'istanza della classe ogni volta che uso la classe template. Con la configurazione attuale che ho, dovrò modificare la riga: Foo foo = new Foo(); e forse la linea di sotto di tale.

Si potrebbe anche chiedere perché devo chiamare launch() e non fare tutto all'interno del metodo principale. Questo è solo qualcosa che ho ricevuto dal mio istruttore di Java. E 'anche visto che non posso usare metodi non statici all'interno del metodo main().

Answer 1

Se "attuare" qualsiasi cosa, è BISOGNO per avere un'interfaccia definita. O si importare uno già esistente, o devi crearlo. In entrambi i casi, se si tratta di una classe pubblica (astratta o meno) o di un'interfaccia, deve essere definito in un file separato. A differenza di C ++, questo è un requisito Java.

Se:

public class Foo implements Bar { 
} 

allora il progetto deve essere composto da almeno:

Foo.java
Bar.java 

Periodo. Senza se / ands / senza ma.

Ma se si deve assolutamente avere un solo file nel progetto, dovrete ottenere un generatore di byte-code e costruire la vostra classe e le interfacce in modo dinamico in fase di esecuzione.

La vera domanda è: che cosa stai cercando di realizzare? Se si tratta di un Singleton / fabbrica, altri hanno risposto che già. Se si tratta di ridurre il numero di unità di compilazione, allora sei fuori di fortuna. Java impone il requisito che si deve fare in questo modo.

EDIT dopo gli aggiornamenti AUTORE:

Java permette di fare le cose in questo modo:

Foo.java :

public class Foo { 
  public static void main(String[] args) { 
    Bar bar = new Bar(); 
  }
}
class Bar { 
   int bar_var; 
   Snafu fu = new Snafu(); 

   public Bar() {  } 
   public int getBarVar() { return bar_var; } 
} 
class Snafu { 
   int var; 
   public Snafu() { } 
}

.... 

Il che realizzare ciò che si vuole raggiungere.

Answer 2

È stato modificato il messaggio e ha aggiunto ulteriori informazioni. Quello è buono. Ora il problema è più evidente. Si sta effettivamente cercando il modello di fabbrica.

public abstract class Batch {
    public static void main(String[] args) throws Exception {
        Batch batch = (Batch) Class.forName(args[0]).newInstance();
        batch.run();
    }

    abstract void run();
}

class Foo extends Batch {
    public void run() {
        System.out.println("Executing Foo");
    }
}

class Bar extends Batch {
    public void run() {
        System.out.println("Executing Bar");
    }
}

Il primo argomento è ovviamente il nome della classe. Spero che questo aiuti.

Answer 3

Perché memorizzare un riferimento, se non avete intenzione di chiamare più di un metodo su di esso?

public class Foo {
  public static void main(String[] args){
    new Foo().launch(args);
  }
  public void launch(String[] args){
    //...
  }
}

Qui, tutto quello che dovete fare per cambiare il file per ogni problema è cambiare due linee: l'intestazione di classe, e la clausola new! Facile!

Answer 4

È necessario un metodo main all'interno della vostra classe Foo che invoca il suo costruttore:

public static void main(String[] args) {
    Foo f = new Foo(); //the new syntax uses a Constructor, not reflection
    //etc

Poi si può eseguire la classe tramite l'eseguibile java (che chiamerà il metodo principale):

$> java mypackage.Foo

Non sono sicuro sul motivo per cui si è scelto di implementare l'interfaccia Bar; questo sembra inutile dalla tua domanda.

Answer 5

Che ne dite?

public class Foo {

    private void instantiate()  {
        Foo foo = Foo.class.newInstance();
    }
    //...
}

Answer 6

In entrambi per farlo nel metodo principale:

public class Foo implements Bar {
    public static final String NAME = "Foo";

    public static void main(String[] args) {
        Foo f = new Foo();
    }

O come un inizializzatore:

public class Foo implements Bar {
    public static final String NAME = "Foo";
    private static final instance = new Foo();

    private void getInstance()  {
        return instance;
    }
}

Answer 7

ha nessuno qui mai sentito parlare di classi interne nidificate / a Java? Sono stati intorno dal JDK 1.2, che era nuovo circa 9 anni fa.

public class Main {
    public static void main(String[] args) {
        Bar b = new Foo();
        b.doSomethingExciting();
    }
    interface Bar {
        void doSomethingExciting();
    }
    static class Foo implements Bar {
        public void doSomethingExciting() {
            System.out.println("Boo!");
        }
    }
}

È possibile nidificare le vostre classi a profondità sostanzialmente arbitrario, utilizzando la classe che contiene, come Modulo e contengono una raccolta arbitraria di classi e interfacce nidificate. Inserendo un main(String[]) si fornisce un punto di ingresso per il vostro programma da cui si può iniziare.

Questo approccio vi darà una file sorgente da cui può essere generato un qualsiasi numero di file di classe. Le classi nidificate avranno tutti nomi univoci (a differenza l'hack di includere più classi non pubbliche al livello più alto).