"Open-end" Java-session

Jeg vil nok anbefale at benytte en debugger (JDB). Den kan noget af det du efterlyser...

Du kan se en lille tutorial i understående link:
http://www.javaworld.com/javaworld/javaqa/2000-06/04-qa-0623-jdb.html

eller from the source:
http://java.sun.com/j2se/1.5.0/docs/guide/jpda/examples.html

->snoop_one: Det er nok en udmærket ide at tænke i f.eks. JDI. Mit behov er for så vidt blot at kunne starte/stoppe en session, så det bør være muligt.

Videre kunne jeg tænke mig at lave en form for "step-vis kompilering" og ikke bare "step-vis eksekvering", således at kompilering foretages i takt med at programmet afvikles - altså en slags inter-aktiv "open-end" Java-session, hvor brugeren løbende taster kode ind, som derefter kompileres og eksekveres.

Har du nogen kommentar til, om dette vil kunne lade sig gøre?

Om det, med step-vis kompilering vil kunne lade sig gøre ved jeg faktisk ikke - men tror det næsten ikke. Det der kommer nærmest det du efterspørger har jeg set i eclipses scrapbook, hvor man kan skrive kodestumper og få eclipse til at eksekvere det.

Jeg har også svært ved at forstå hvorfor step-vis kompilering og eksekvering giver nogen mening - når vi taler om JAVA?

f.eks hvis du har:

public class MyTest{
  ...
  MyObject obj = new MyObject();
  ...
  private class MyObject{
    ...
  }
}

Ovenstående er jo et fuldstændigt lovligt Java language konstruktion.

I dit tilfælde (med stepvis kompilering) vil dit program kompilere linien
... obj = new  MyObject();
men den vil nok komme med en kompilerings fejl, da den ikke ved om MyObject klassen findes. Så det er først når hele klassen er blevet stepvise kompileret at du så kan give brugeren en fejlmeddelelse om, at der er kompileringsfejl eller at klassen er fri for kompileringsfejl.

->snoop_one: Det er helt korrekt. Det step-vise kommer i stand derved, at applikationen jo kun ved, hvad brugeren har tastet ind, indtil et vist tidspunkt, når kompilering skal ske. I ovennævnte eksempel vil det være sådan, at brugeren skal taste så meget kode ind, at koden lovligt kan kompilere indtil det tidspunkt, brugeren beder om det.

Fordelen ved denne fremgangsmåde, som jeg forestiller mig det, er, at den dynamik, som man at bygger ind med reflections - og som er temmelig tung - ikke altid er nødvendig, idet de dynamiske valg i mange tilfælde lægges fast, efterhånden som programmet afvikles.

I første omgang er jeg interesseret i at kunne starte en Java-session op fra en anden Java-session. Har du nogen kommentar til, hvordan dette gøres?

Ja, Runtime klassen kan gøre det, f.eks.

/*************** Frame.java **********************************************/
import java.io.IOException;
import javax.swing.JFrame;

public class Frame extends JFrame {

    public Frame() {
        super();
        setTitle("Frame");
        setDefaultCloseOperation(Frame.EXIT_ON_CLOSE);
        try {
            String java = "java -cp .";
            String classfile = "MyFrame";
            String args = "";
            String cmd = java + " " + classfile + " " + args;
            Process p = Runtime.getRuntime().exec(cmd);
            setVisible(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new Frame();
    }

}
/*************** MyFrame.java **********************************************/
import javax.swing.JFrame;

public class MyFrame extends JFrame{
   
    public MyFrame() {
        super();
        setDefaultCloseOperation(Frame.EXIT_ON_CLOSE);
        setTitle("MyFrame");
        setVisible(true);
    }
    public static void main(String[] args){
        new MyFrame();
    }
}

Kunne det bruges?

->snoop_one: Ja, det er fint. Smid lige et svar.

svar