auf eine andere Klasse zugreifen

[pappender]

Hallo, ich bräuchte nochmal eure Hilfe.


Da ich meinen Code etwas übersichtlicher gestalten möchte, möchte ich eine Klasse auslagern.

Also habe ich im gleichen package eine weitere Klasse erstellt: Eplan.

In der 1. Klasse importiere ich die andere Klasse: import xxx.xxx.Eplan;
Durch einen ActionListener rufe ich die andere Klasse auf:

        menubarEplanOperationplan.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent arg0) {
                new Eplan();
            }
         });

Das funktioniert auch soweit ganz gut << getestet durch System.out.println("Test");

Die neue Klasse hat folgenden Aufbau:

package xxx.xxx.xxx;

public class Eplan {

    public Eplan() {
       
        System.out.println("Test");

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

Sie hat den gleichen package-Namen.
Aber wie greife ich jetzt auf den Frame der anderen Klasse zu?
Ich dachte ja: mainFrame.setTitle("blaablaa");
Funktioniert aber nicht.

Ich nehme mal an, dass mainFrame in der zweiten Klasse nicht bekannt ist?

Oder mach ich das total falsch?

 

[Viktim]

Ich hab noch nicht so ganz verstanden, was du erreichen möchtst...
Willst du:
1) den ActionListner in der Main aufrufen, oder
2) Im ActionListner einen neuen Eplan erstellen, und dann einen Titel da setzten, oder
3) was ganz anderes

und nochmal was anderes, was ist dein MainFrame?

 

[Jardcore]

Was du falsch machst ist, dass du bei jedem Aufruf von actionPerformed() eine neue Klasse Eplan erzeugst.
Du solltest eher vorher die Klasse erzeugen und dann eine Methode der Klasse Eplan aufrufen.

Die main() Methode brauchst du auch nur ein einziges Mal in deinem Programm.

Wie heißt denn deine andere Klasse, bzw. was genau möchtest du erreichen?

 

[pappender]

Ich habe eine Menüleiste und dachte ich erstelle für jeden Menüpunkt eine Klasse, damit der Code übersichtlich bleibt.
Hier meine Hauptklasse:

package org.xxx.xxx;

import org.xxx.xxx.Eplan; // import der anderen Klasse

import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;

public class MainIDS {
 
 
 
 
 
    // Frame
    JFrame mainFrame;
    Toolkit t;
    int x = 0, y = 0, mainFrameWidth = 1200, mainFrameHeight = 800;
 
 
 
    // Komponenten Menüleiste
    JMenuBar menubar;
 
    JMenu menubarEplan;
    JMenuItem menubarEplanOperationplan;
 
    JMenu menubarDatacollections;
    JMenu menubarStatisticsanalysis;
    JMenu menubarTest;
    JMenu menubarForm;
    JMenu menubarSettings;
 
    JMenu menubarHelp;
    JMenuItem menubarHelpInfo;
 
 
 
 
 
    public MainIDS() {
     
     
     
     
     
        // Frame
        mainFrame = new JFrame();
        mainFrame.setTitle("IDS");
     
        t = Toolkit.getDefaultToolkit();
        Dimension d = t.getScreenSize();
        x = (int) ((d.getWidth() - mainFrameWidth) / 2);
        y = (int) ((d.getHeight() - mainFrameHeight) / 2);
        mainFrame.setBounds(x, y, mainFrameWidth, mainFrameHeight);
     
     
     
        // Menüleiste
        menubar = new JMenuBar();
        menubarEplan = new JMenu("Einsatzplan");
        menubarEplanOperationplan = new JMenuItem("Einsatzplan");
     
        menubarDatacollections = new JMenu("Datenerfassung");
        menubarStatisticsanalysis = new JMenu("Statistiken und Analysen");
        menubarTest = new JMenu("Test");
        menubarForm = new JMenu("Vordruck");
        menubarSettings = new JMenu("Einstellungen");
     
        menubarHelp = new JMenu("Hilfe");
        menubarHelpInfo = new JMenuItem("Info");
     
        menubar.add(menubarEplan);
        menubarEplan.add(menubarEplanOperationplan);
     
        menubar.add(menubarDatacollections);
        menubar.add(menubarStatisticsanalysis);
        menubar.add(menubarTest);
        menubar.add(menubarForm);
        menubar.add(menubarSettings);
     
        menubar.add(menubarHelp);
        menubarHelp.add(menubarHelpInfo);
     
        mainFrame.setJMenuBar(menubar);
     
     
     
        // Frame show
        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        mainFrame.setVisible(true);
     
     
     
     
     
        // ==================================================
        // Actionlistener
        // ==================================================
        menubarEplanOperationplan.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent arg0) {
                new Eplan();
            }
         });
     
     
     
        menubarHelpInfo.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent arg0) {
                JOptionPane.showMessageDialog(null, "xxx");
            }
        });
     
     
     
     
     
    }
 
 
 
 
 
    public static void main(String[] args) {
        new MainIDS();
    }
 
 
 
 
 
}

Also soll ich eher die Methode auslagern?

 

[pappender]

Der Menüpunkt um den es hier geht, soll dann ein TappedPane erstellen und je Registerkarte ein JTable bekommen. Das ist soweit auch fertig. Ich wollte halt den Code nur übersichtlicher gestalten und aufteilen.

 

[Viktim]

ich peils immer noch nicht ganz, aber es klingt, als müsstest du dir einen getter für deinen Frame schreiben, und den dann aufrufen o.o
http://stackoverflow.com/questions/2036970/how-do-getters-and-setters-work

 

[kneitzel]

Also was mich total verwirrt und was wohl einer Änderung bedarf, ist:
Du erstellst einfach nur einen neuen Eplan. Diese Variable merkst Du Dir nirgends und das war es dann schon. Das ist zumindest unüblich.

Wenn es ein Fenster ist, dann würde ich es etwas verstehen, denn dann hast da evtl. die Erstellung und das sichtbarmachen da mit drin. Würde ich aber dennoch als zwei Schritte machen a.la.

Eplan plan = new Eplan();
plan.setVisible(true);

Desweiteren sollten die Namen eindeutig sein, damit klar ist, was sich dahinter verbirgt. Eplan als kurz für Einsatzplan wäre schon bedenklich und dann ist nicht erkennbar, dass es sich um ein Fenster handelt. (So es denn so ist).

Wenn Du nun Zugriff auf irgendwas im Hauptfenster haben willst, dann kannst Du da auch Referenzen übergeben. Ist aber nicht ganz so toll, da Du so Abhängigkeiten zwischen den Fenstern einbaust und das kann leicht zu Problemen führen. Aber die Möglichkeit gibt es natürlich.

 

[pappender]

Hm. Okay.

Ich habe den Code jetzt nochmal geändert, ich hoffe das ist jetzt besser so?

package org.xxx.xxx;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;

public class MainIDS {
  
  
  
  
  
    // Frame
    JFrame mainFrame;
    Toolkit t;
    int x = 0, y = 0, mainFrameWidth = 1200, mainFrameHeight = 800;
  
  
  
    // Komponenten Menüleiste
    JMenuBar menubar;
  
    JMenu menubarEplan;
    JMenuItem menubarEplanOperationplan;
  
    JMenu menubarDatacollections;
    JMenu menubarStatisticsanalysis;
    JMenu menubarTest;
    JMenu menubarForm;
    JMenu menubarSettings;
  
    JMenu menubarHelp;
    JMenuItem menubarHelpInfo;
  
  
  
  
  
    public MainIDS() {
      
      
      
      
      
        // Frame
        mainFrame = new JFrame();
        mainFrame.setTitle("IDS");
      
        t = Toolkit.getDefaultToolkit();
        Dimension d = t.getScreenSize();
        x = (int) ((d.getWidth() - mainFrameWidth) / 2);
        y = (int) ((d.getHeight() - mainFrameHeight) / 2);
        mainFrame.setBounds(x, y, mainFrameWidth, mainFrameHeight);
      
      
      
        // Menüleiste
        menubar = new JMenuBar();
        menubarEplan = new JMenu("Einsatzplan");
        menubarEplanOperationplan = new JMenuItem("Einsatzplan");
      
        menubarDatacollections = new JMenu("Datenerfassung");
        menubarStatisticsanalysis = new JMenu("Statistiken und Analysen");
        menubarTest = new JMenu("Test");
        menubarForm = new JMenu("Vordruck");
        menubarSettings = new JMenu("Einstellungen");
      
        menubarHelp = new JMenu("Hilfe");
        menubarHelpInfo = new JMenuItem("Info");
      
        menubar.add(menubarEplan);
        menubarEplan.add(menubarEplanOperationplan);
      
        menubar.add(menubarDatacollections);
        menubar.add(menubarStatisticsanalysis);
        menubar.add(menubarTest);
        menubar.add(menubarForm);
        menubar.add(menubarSettings);
      
        menubar.add(menubarHelp);
        menubarHelp.add(menubarHelpInfo);
      
        mainFrame.setJMenuBar(menubar);
      
      
      
        // Frame show
        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        mainFrame.setVisible(true);
      
      
      
      
      
        // ==================================================
        // Actionlistener
        // ==================================================
        menubarEplanOperationplan.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent arg0) {
                eplanFrame();
            }
         });
      
      
      
        menubarHelpInfo.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent arg0) {
                JOptionPane.showMessageDialog(null, "xxx");
            }
        });
      
      
      
      
      
    }
  
  
  
  
  
    // ==================================================
    // Menüpunkt Einsatzplan
    // ==================================================
    public void eplanFrame(){
      
      
        // TabbedPane
        JTabbedPane tabbedpaneEplan;
        JPanel tabbedpaneEplanPlanung;
      
        tabbedpaneEplan = new JTabbedPane(JTabbedPane.BOTTOM,JTabbedPane.SCROLL_TAB_LAYOUT);
        tabbedpaneEplanPlanung = new JPanel(new BorderLayout());
        tabbedpaneEplan.addTab("Planung", tabbedpaneEplanPlanung);
      
        mainFrame.getContentPane().add(tabbedpaneEplan);
        mainFrame.pack();
        mainFrame.setBounds(x, y, mainFrameWidth, mainFrameHeight);


    }
  
  
  
  
  
    // ==================================================
    // mainFrame
    // ==================================================
    public static void main(String[] args) {
        new MainIDS();
    }
  
  
  
  
  
}

Was möchte ich eigentlich?
Ich möchte durch den Menüpunkt "Einsatzplan" dem mainFrame eine JTabbedpane zufügen. Die JPanel's sollen dann entsprechend JTables erhalten.
Desweiteren wäre die Frage, da hier ja noch viel Code kommen würde, ob ich die auslagern sollte?

 

[pappender]

Also ich habe den Code nun nochmal geändert. Wäre das jetzt konformer?

package org.xxx.xxx;

import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;

public class MainIDS {
  
  
  
  
  
    // Frame
    JFrame mainFrame;
    Toolkit t;
    int x, y, mainFrameWidth, mainFrameHeight;
  
  
    // Components MenuBar
    JMenuBar menubar;
  
    JMenu menubarEplan;
    JMenuItem menubarEplanOperationplan;
    JMenuItem menubarEplanTimesheet;
  
    JMenu menubarDatacollections;
    JMenu menubarStatisticsanalysis;
    JMenu menubarTest;
    JMenu menubarForm;
    JMenu menubarSettings;
  
    JMenu menubarHelp;
    JMenuItem menubarHelpInfo;
  
  
  
  
  
    public MainIDS() {
      
      
      
      
      
        // Frame
        mainFrame = new JFrame();
        mainFrame.setTitle("IDS");
      
        t = Toolkit.getDefaultToolkit();
        Dimension d = t.getScreenSize();
        x = 0;
        y = 0;
        mainFrameWidth = (int) d.getWidth();
        mainFrameHeight = (int) d.getHeight();
        mainFrame.setBounds(x, y, mainFrameWidth, mainFrameHeight);
      
      
      
        // MenuBar
        menubar = new JMenuBar();
        menubarEplan = new JMenu("Einsatzplan");
        menubarEplanOperationplan = new JMenuItem("Einsatzplan");
        menubarEplanOperationplan.addActionListener(new MenuActionListener());
        menubarEplanTimesheet = new JMenuItem("Stundenzettel");
        menubarEplanTimesheet.addActionListener(new MenuActionListener());
      
        menubarDatacollections = new JMenu("Datenerfassung");
        menubarStatisticsanalysis = new JMenu("Statistiken und Analysen");
        menubarTest = new JMenu("Test");
        menubarForm = new JMenu("Vordruck");
        menubarSettings = new JMenu("Einstellungen");
      
        menubarHelp = new JMenu("Hilfe");
        menubarHelpInfo = new JMenuItem("Info");
        menubarHelpInfo.addActionListener(new MenuActionListener());
      
        menubar.add(menubarEplan);
        menubarEplan.add(menubarEplanOperationplan);
        menubarEplan.add(menubarEplanTimesheet);
      
        menubar.add(menubarDatacollections);
        menubar.add(menubarStatisticsanalysis);
        menubar.add(menubarTest);
        menubar.add(menubarForm);
        menubar.add(menubarSettings);
      
        menubar.add(menubarHelp);
        menubarHelp.add(menubarHelpInfo);
      
        mainFrame.setJMenuBar(menubar);
      
      
      
        // show Frame
        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        mainFrame.setVisible(true);
      
      
      
      
      
    }
  
  
  
  
  
    // ==================================================
    // Select MenuItem
    // ==================================================
    public class MenuActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {
          
            if(e.getActionCommand() == "Einsatzplan") {
                menuPointOperationplan showOperationplan = new menuPointOperationplan();
                showOperationplan.operationplanFrame();
              
            }else if(e.getActionCommand() == "Stundenzettel") {
                    menuPointTimesheet showTimesheet = new menuPointTimesheet();
                    showTimesheet.timesheetFrame();
                  
            }else if(e.getActionCommand() == "Info") {
                JOptionPane.showMessageDialog(null, "xxx");
              
            }else{
                JOptionPane.showMessageDialog(null, "xxx");
            }
          
        }
    }
  
  
  
  
  
    // ==================================================
    // mainFrame
    // ==================================================
    public static void main(String[] args) {
        new MainIDS();
    }
  
  
  
  
  
  
  
  
  
  
    // ==================================================
    // operationplanFrame
    // ==================================================
    public class menuPointOperationplan {
        public void operationplanFrame() {
            mainFrame.setTitle("Einsatzplan");
// ...
        }
    }
  
  
  
  
  
    // ==================================================
    // timesheetFrame
    // ==================================================
    public class menuPointTimesheet {
        public void timesheetFrame() {
            mainFrame.setTitle("Stundenzettel");
// ...
        }
    }
  
  
  
  
  
}

 

[Jardcore]

Du willst doch eigentlich das du wenn du auf Einsatzplan drückst ein neues Fenster geöffnet wird und die Logik des Fensters wolltest du nicht unbedingt in der Hauptklasse abfrühstücken oder?

Man könnte jetzt das ganze nach MVC strukturieren. Und für den Einsatzplan eine View erstellen (JFrame ect.) und die benötigten Daten des Einsatzplans in einem Model speichern usw. Andererseits könnte man auch einfach ein Einsatzplan erzeugen und der hat gleichzeitig Zugriff auf seine View.

public class Einsatzplan {
    private JFrame view;

    public void show() {
        view.show();
    }
}

Das Menü würde ich erstmal zusammen lassen, wobei man das auch in eine Extra Menu Klasse auslagern könnte, aber first things first. Deine Hauptklasse würde ein Einsatzplan erzeugen und eine Referenz darauf halten, wenn du nun im Menu "Einsatzplan" drückst würde über die Referenz ein show() oder was auch immer aufgerufen werden.

 

[pappender]

Hallo.

Also eigentlich möchte ich alles im Hauptfenster machen und keine weiteren neuen Fenster öffnen lassen.
Ich habe mir gedacht, das ich je Menüpunkt ein eigenes JPanel erstelle und diese dann durch Auswahl des Menüpunktes dem Hauptfenster zuordne bzw. wieder entferne. So kann ich für jeden Menüpunkt eine eigene View bauen und alles bleibt übersichtlicher.

Ich würde also gerne durch Auswahl eines Menüpunktes eine bestimmte Klasse aufrufen, die weiteren Programmcode abarbeitet. Ich möchte aber, nicht für jeden Punkt eine eigene Methode schreiben, sondern das dynamisch gestalten.

In etwa so:

Class klasse = Class.forName(e);

Leider findet er aber die Klasse nicht, obwohl sie da ist und auch richtig geschrieben ist.

Woran kann das liegen, vielleicht am ClassLoader?

 

[pappender]

So würde das ganze Script/View aussehen:

package xxx;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;

public class View extends JFrame {
  
    private Controller controller;
  
    private JMenuBar menubar;
    private JMenu menuEplan;
    private JMenuItem menuEplanOperationplan;
  
    private JPanel mainPanel;
  
  
  
  
  
    public View(Controller controller) {
      
        super("IDS");
        this.controller = controller;

        menubar();
        mainPanel = new JPanel();
        add(mainPanel, BorderLayout.CENTER);
        setBounds(300, 300, 1000, 800);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        pack();
        setVisible(true);
      
    }
  
  
  
  
  
    //==================================================
    // Menubar
    //==================================================
    public void menubar() {
      
        menubar                    = new JMenuBar();
      
        menuEplan                = new JMenu("Einsatzplan");
        menuEplanOperationplan    = new JMenuItem("Einsatzplan");
        menuEplanOperationplan.addActionListener(new MenuActionListener());
      
        menuEplan.add(menuEplanOperationplan);
        menubar.add(menuEplan);
      
        add(menubar, BorderLayout.PAGE_START);
      
    }
  
    public class MenuActionListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent arg0) {
            controller.handleMenu(arg0);
        }
    }
  
  
  
  
  
    //==================================================
    // JPanel
    //==================================================
    public Class<?> showpanel(ActionEvent arg0) {
        getContentPane().remove(mainPanel);
        validate();
        repaint();
        try {
            Class<?> newClass =  (Class<?>) Class.forName("View"+arg0.getActionCommand());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }  
  
  
  
  
  
}

Wobei die Klasse "public Class<?> showpanel(ActionEvent arg0) {" noch angepasst werden muss, aber das später.
Aber warum bekomme ich immer eine "ClassNotFoundException" bei "Class<?> newClass = (Class<?>) Class.forName("View"+arg0.getActionCommand());"? Wenn ich die Klasse normal aufrufe, geht es ja auch. Also die Klasse ist definitiv da (Klasse steht in einer anderen Datei.java).

 

[pappender]

So, nach unzähligen gefühlten 1000 Versuchen scheint es jetzt endlich zu funktionieren:

    public void showpanel(ActionEvent arg0) {
        getContentPane().remove(mainPanel);
        validate();
        repaint();
        try {
            String klasse = "package.View"+arg0.getActionCommand();
            Class.forName(klasse);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

Obwohl ich der Meinung bin, das ich die Variante mit Angabe des Package's schon probiert hatte. Aber egal, es funktioniert. Jetzt kann ich die JPanel's dynamisch auswechseln.