static Klassenvariable

Status
Nicht offen für weitere Antworten.
P

PollerJava

Top Contributor
Hallo,

ich habe ein Objekt- Array com Type TimeSeries[] series (jFreeChart), dieses ist static,

mit series[x].add(...); füge ich eine xy- Punkt zu series hinzu,

mit series[x].clear() kann ich die TumeSeries wieder löschen (wenn ich einen JButton drücke),

Es funktioniert so ganz gut, nur wenn ich TimeSeries[] nicht static mache dann bekomme ich bei series[x].clear() eine NPE.

Wie kann das sein?? Das Objekt besteht ja!

Wenn TimeSeries[] static ist, funktionierts einwandfrei!

Hat da jemand eine Idee oder einen Tipp für mich?


lg und herzlichen Dank
 
einfache Lösung: wenn es nicht statisch ist, dann ist es nicht da (oder Element x darin ist null)

du irrst dich eben.., ist nicht immer leicht zu sehen, welches Objekt wann wo seine Exemplarvariablen korrekt initialsiert
 
x ist ja nur ein int- variable, also der Index im TimeSeries[] - Array und es müsste ja meiner Meinung nach egal sein, ob ich das Array statisch mache oder nicht,

Was wäre da eine Abhilfe, ich hab ja auch schon an das composite- Muster gedacht aber da müsste ich halt alles umschreiben und das will ich ja auch nicht unbedingt,

Bringt es eigentlich was, wenn series static ist und wenn ich

Code: 
series[x] = null; und dann 
series[x].add(...) schreibe
 
ich meinte nicht x, sondern schon dass das vorhandene Array an Position x kein TimeSeries-Objekt enthält

-------

zu einer ganz allgemeinen Situation 'ich habe ein Array, welches null ist oder ein null-Element enthält'
kannst du doch nicht 'Was wäre da eine Abhilfe' fragen?

wie immer kann man da nur sagen: eine Lösung für all deine Probleme ist ganz normale Programmierung,
wenn dein Array null ist, dann musst nicht irgendwelche SpezialPattern bemühen,
sondern die Exemplarvariable wie jede andere auch im Konstruktor richtig setzen oder ähnliches

wie zuletzt: ohne Kenntnis deines Programmes nur Vermutungen

-----------


> Bringt es eigentlich was, wenn series static ist und wenn ich [..]

ja, bringt ne NullPointerException 😉
 
ich hab natürlich was vergessen:

Code: 
series[x] = null; und dann
series[x] = new TimeSeries();
series[x].add(...) schreibe


So solls aussehen, also alte series an der Stelle x löschen, neue series an der Stelle x anlegen und weiter ...


Code: 
public class MultipleAxisTrend extends JPanel implements MouseListener
    {
        
    private int x = 0;                                                          // x repräsentiert die einzelnen Seiten 
    private boolean addAxis = false;
    private int yAxisLocation = 0;
    private static int index = 0;
    private static final int PAGECNT = 10;
    private static final int TRENDLINIEN_ANZAHL = 40;
    private static HashMap<String, Integer>[] trendMap = new HashMap[TRENDLINIEN_ANZAHL];
    private static HashMap<String, Integer>[] unitMap = new HashMap[TRENDLINIEN_ANZAHL];
    private static HashMap<String, Integer>[] unitAxisMap = new HashMap[TRENDLINIEN_ANZAHL];
    private static HashMap<String, Integer>[] axisPosMap = new HashMap[TRENDLINIEN_ANZAHL];
    private static int[] trendCnt = new int[PAGECNT];
    private static String[] trendtitel = new String[PAGECNT];
    private static String[] xachsetitel = new String[PAGECNT];
    private static String[] yachsetitel = new String[PAGECNT];   
    private JFreeChart[] chart = new JFreeChart[PAGECNT];
    private ChartPanel[] chartPanel = new ChartPanel[PAGECNT];
    public static XYPlot[] plot = new XYPlot[PAGECNT];
    private static NumberAxis[][] axis = new NumberAxis[PAGECNT][TRENDLINIEN_ANZAHL];
    private XYItemRenderer[] renderer = new XYItemRenderer[PAGECNT];
    private XYStepRenderer[] stepRenderer = new XYStepRenderer[PAGECNT];
    private static TimeSeries[][] series = new TimeSeries[PAGECNT][TRENDLINIEN_ANZAHL];                         //10 Seiten mit je 40 Variablen 
    private static CombinedDomainXYPlot[] cplot = new CombinedDomainXYPlot[PAGECNT];
    private static StandardXYToolTipGenerator toolTip = new StandardXYToolTipGenerator();   
    private TimeSeriesCollection dataset;
    private DateTime dateTime = new DateTime();    
    public static JMenuItem[][] mi = new JMenuItem[PAGECNT][10];   
    private boolean schaltSignal = false;
    private String dBName;
    private SearchDBName searchDBName = new SearchDBName();    
    private static DateAxis[] axis1 = new DateAxis[10];
    private static Date startXAchse, endXAchse;
    
    
    public MultipleAxisTrend(String trendtitel, String xachsetitel, String yachsetitel, int x) 
        {                    
        this.x = x;
        trendMap[x] = new HashMap();
        unitMap[x] = new HashMap();
        unitAxisMap[x] = new HashMap();
        axisPosMap[x] = new HashMap();
        axis1[x] = new DateAxis();
        MultipleAxisTrend.trendtitel[x] = trendtitel;
        MultipleAxisTrend.xachsetitel[x] = xachsetitel;
        MultipleAxisTrend.yachsetitel[x] = yachsetitel;    
        chart[x] = createChart(x);
        chartPanel[x] = new ChartPanel(chart[x]);     
        chartPanel[x].getPopupMenu().addSeparator();
        
        chartPanel[x].getPopupMenu().setBorderPainted(false);      
        chartPanel[x].setPreferredSize(new java.awt.Dimension(600, 270));
        chartPanel[x].setDomainZoomable(true);
        chartPanel[x].setRangeZoomable(true);
        chartPanel[x].addMouseListener(this);
        
        mi[x][0] = (JMenuItem)chartPanel[x].getPopupMenu().getComponent(0); 
        mi[x][1] = (JMenuItem)chartPanel[x].getPopupMenu().getComponent(2);
        mi[x][2] = (JMenuItem)chartPanel[x].getPopupMenu().getComponent(4);           
        mi[x][3] = (JMenuItem)((JMenu)chartPanel[x].getPopupMenu().getComponent(9)).getMenuComponent(0);        
        }

    public ChartPanel getChartPanel()                                                                                                       
        {
        return this.chartPanel[x];
        }
      
    private static JFreeChart createChart(int x) 
        { 
        JFreeChart chart = ChartFactory.createTimeSeriesChart(MultipleAxisTrend.trendtitel[x], MultipleAxisTrend.xachsetitel[x] + " ", MultipleAxisTrend.yachsetitel[x] + " ", null, false, true, false);         
        chart.setBackgroundPaint(Color.white); 
        plot[x] = (XYPlot) chart.getPlot();
        axis1[x] = (DateAxis)plot[x].getDomainAxis();
        plot[x].setOrientation(PlotOrientation.VERTICAL);
        plot[x].setBackgroundPaint(Color.WHITE);
        plot[x].setDomainGridlinePaint(Color.white);
        plot[x].setRangeGridlinePaint(Color.white);  
        plot[x].setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 5.0));
        plot[x].getRangeAxis().setFixedDimension(15.0);
        plot[x].setDomainGridlinePaint(Color.GRAY);
        plot[x].setRangeGridlinePaint(Color.GRAY);
        plot[x].setDomainCrosshairVisible(true); 
        plot[x].setRangeCrosshairVisible(true); 
        DateAxis axis = (DateAxis) plot[x].getDomainAxis();
        return chart;
        }
              
    public void updatePanel(HashMap<String, Float> dBWerte, String nameLinie, int xSeite, String einheit, Color lineColor, int zeitRaum)                                                                  
        {
        try { 
            if (zeitRaum != 6)                                  
                {
                if (unitMap[xSeite].containsKey(einheit))                                                                                           // Wieviele Linien benutzen die einzelnen Einheiten-Achsen                               
                    {
                    unitMap[xSeite].put(einheit, new Integer(unitMap[xSeite].get(einheit)+1));  
                    addAxis = false;                                                                                                                // wenn die Einheit schon vorhanden ist, dann auf dem Plot keine neue y- Achse zeichnen
                    }
                else
                    {
                    unitMap[xSeite].put(einheit, new Integer(1));
                    if (axisPosMap[xSeite].containsKey(einheit))
                        addAxis = false;
                    else
                        addAxis = true;                                                                                                             // neue y- Achse zeichnen
                    }
                if (axisPosMap[xSeite].containsKey(einheit) == false)
                    {
                    axisPosMap[xSeite].put(einheit, trendCnt[xSeite]);
                    }
                }
            else
                {
                addAxis = false;
                }
            if (trendMap[xSeite].containsKey(nameLinie) == false)                                                                               // wenn die Linie in der Map noch nicht vorhanden ist                                                                                                           // wenn eine neue Linie hinzugefügt wird
                {
                trendMap[xSeite].put(nameLinie, trendCnt[xSeite]);                 
                createPlot(dBWerte, einheit, xSeite, nameLinie, trendCnt[xSeite], lineColor, addAxis, zeitRaum);   
                trendCnt[xSeite]++;
                }
            else
                {
                index = trendMap[xSeite].get(nameLinie);  //trend[xSeite] ist die Position, wo die Serie gespeichert wird                
                createPlot(dBWerte, einheit, xSeite, nameLinie, index, lineColor, addAxis, zeitRaum); 
                }
            }
        catch (Exception ex)
            {
            System.out.println("Fehler Klasse MultipleAxisTrend, Methode updatePanel: " + ex);
            }
        }
    
    public void createPlot(HashMap<String,Float> dBWerte, String einheit, int xSeite, String nameLinie, int trendCnt, final Color lineColor, boolean addAxis, int zeitRaum)
        { 
        try {
            dBName = searchDBName.getDBName(nameLinie, xSeite);
            for (int i = 0; i < Control.states.size(); i++)
                {
                if (Control.states.elementAt(i).getTypeElement().equals("TrendVariable") && Control.states.elementAt(i).getElementName().equals(dBName))                                
                    {   
                    schaltSignal = Control.states.elementAt(i).getSchaltSignal();
                    break;
                    }
                }                 
            if (addAxis == true)
                {
                axis[xSeite][trendCnt] = new NumberAxis(einheit, trendCnt, xSeite);
                axis[xSeite][trendCnt].setAutoRangeIncludesZero(false);
                axis[xSeite][trendCnt].setAutoRange(true);
                plot[xSeite].setRangeAxis(trendCnt, axis[xSeite][trendCnt]);                     // für jede TrendSeite einen plot[], also fuer 2 Seiten -> plot[0] und plot[1]  
                plot[xSeite].mapDatasetToRangeAxis(trendCnt, axisPosMap[xSeite].get(einheit));   // mapDatasetToRangeAxis(int indexLine, int axisIndex);
                }
            else if (addAxis == false)
                {           
                axis[xSeite][axisPosMap[xSeite].get(einheit)].setVisible(true);
                plot[xSeite].mapDatasetToRangeAxis(trendCnt, axisPosMap[xSeite].get(einheit));                       
                }    
            XYDataset dataset = createDataset(nameLinie, new Second(), dBWerte, trendCnt, xSeite);   
            plot[xSeite].setDataset(trendCnt, dataset); 
            toolTip = new StandardXYToolTipGenerator(StandardXYToolTipGenerator.DEFAULT_TOOL_TIP_FORMAT, new SimpleDateFormat("d-MMM-yyyy HH:mm:ss.SSSS"), new DecimalFormat("0.00"));            
            if (schaltSignal == false)                                                          // Linie Punkt zu Punkt zeichnen
                {
                renderer[trendCnt] = new StandardXYItemRenderer();       
                renderer[trendCnt].setSeriesPaint(0, lineColor);                                // setSeriesPaint(int series, Paint paint);
                //renderer[trendCnt].setBaseItemLabelsVisible(true);
                plot[xSeite].setRenderer(trendCnt, renderer[trendCnt]);  
                plot[xSeite].getDomainAxis().setAutoRange(true);                                  
                renderer[trendCnt].setBaseToolTipGenerator(toolTip);
                }
            else if (schaltSignal == true)                                                      // Linie in binärer Form zeichnen
                {
                stepRenderer[trendCnt] = new XYStepRenderer();
                stepRenderer[trendCnt].setSeriesPaint(0, lineColor);                            // setSeriesPaint(int series, Paint paint);
                stepRenderer[trendCnt].setBaseItemLabelsVisible(true);
                plot[xSeite].setRenderer(trendCnt, stepRenderer[trendCnt]); 
                stepRenderer[trendCnt].setBaseToolTipGenerator(toolTip);
                }  
             if (zeitRaum == 6)
                {
                axis1[xSeite].setRange(startXAchse, endXAchse); 
                }
             else 
                axis1[xSeite].setAutoRange(true); 
            }
        catch (Exception ex)
            {
            System.out.println("Fehler Klasse MultipleAxisTrend, Methode createPlot: " + ex);
            }
        }
    
    private XYDataset createDataset(final String name, RegularTimePeriod start, final HashMap<String, Float> dBWerte, final int trendCnt, final int xSeite)                                 // erstellt das dataset
        {
        series[xSeite][trendCnt] = new TimeSeries(name, start.getClass());
        for (Map.Entry<String, Float> e : dBWerte.entrySet())
            {
            dateTime.setDateTime(e.getKey());
            try {                 
                series[xSeite][trendCnt].add(new Second(dateTime.getSecond(), dateTime.getMinute(), dateTime.getHour(), dateTime.getDay(), dateTime.getMonth(), dateTime.getYear()), e.getValue());      
                }
            catch (Exception ex) {//System.out.println("Fehler Klasse MultipleAxisTrend, Methode createDataset: " + ex);   // hier tritt eine Exception auf, wenn 2 Werte mit den gleichen Zeiten hinzugefügt werden sollen
                }
            }  
        dataset = new TimeSeriesCollection();   
        dataset.addSeries(series[xSeite][trendCnt]); 
        return dataset;
        }
    
    public void deleteCurve(String nameLinie, int xSeite, int isCheckCnt)                       // Löschen der Linie
        {
        try {
            String einheit = "";
            series[xSeite][trendMap[xSeite].get(nameLinie)].clear();                           // die Linie, welche Abgewählt wurde, löschen
            for (int i = 0; i < Control.states.size(); i++)
                {
                if (Control.states.elementAt(i).getTypeElement().equals("TrendSeite") && Integer.parseInt(Control.states.elementAt(i).getElementName()) == xSeite && Control.states.elementAt(i).getText().equals(nameLinie))
                    {
                    dBName = Control.states.elementAt(i).getBezeichner();
                    break;
                    }
                }
            for (int i = 0; i < Control.states.size(); i++)
                {
                if (Control.states.elementAt(i).getElementName().equals(dBName)  && Control.states.elementAt(i).getTypeElement().equals("TrendVariable"))
                    {
                    einheit = Control.states.elementAt(i).getEinheit();
                    break;
                    }
                }
             if (unitMap[xSeite].get(einheit) == 1)                                     // wenn nur mehr eine Linie mit bezug auf eine Achse da ist, dann die Achse unsichtbar machen
                {
                try {
                    axis[xSeite][axisPosMap[xSeite].get(einheit)].setVisible(false);
                    }
                catch (Exception e)
                    {
                    System.out.println("Fehler in der Methode deleteCurve: " + e);
                    }
                unitMap[xSeite].remove(einheit);
                }
            else 
                {
                unitMap[xSeite].put(einheit, new Integer(unitMap[xSeite].get(einheit)-1)); 
                }
            if (isCheckCnt == 0)                                                        // wenn keine Linie mehr angewählt ist, dann alles auf null setzen
                {
                unitMap[xSeite].clear();
                axisPosMap[xSeite].clear();
                trendMap[xSeite].clear();
                unitAxisMap[xSeite].clear();
                trendCnt[xSeite] = 0;
                index = 0;
                addAxis = false;
                }  
            }
        catch (Exception ex)
            {
            System.out.println("Fehler in der Klasse MultipleAxisTrend beim Löschen: " + ex);
            }
        }
    
    public  void setXAxisTimes(Date startXAchse, Date endXAchse)
        {
        this.startXAchse = startXAchse;
        this.endXAchse = endXAchse;
        }    
}
 
so schaut meine Klasse aus (oben),
vielleicht will sichs ja jemand ansehen,

Bin für jeden Verbesserungsvorschlag dankbar
 
PollerJava hat gesagt.:
so schaut meine Klasse aus (oben),
vielleicht will sichs ja jemand ansehen,

Bin für jeden Verbesserungsvorschlag dankbar
Zum Vergrößern anklicken....
auf den ersten (!) Blick:

konzeptionell nicht gelungen... 30 Zeilen Klassenvariablen oder Instanzvariablen, statistische Variablen werden im Konstruktor initialisiert und und und... wirkt fuer mich: ich mach eine Klasse und die macht, kann und tut alles....

wie gesagt, ist aber nur der erste blick
 
im jFreeChart ist alles static, Methoden und Variablen,

ich hab, was gegangen ist, als Objectvariablen deklariert, das andere habe ich so lassen,

lg
 
> im jFreeChart ist alles static, Methoden und Variablen,

kein Stück, das ist ja sauberer Java-Code,
einzig static ist dort vielleicht der Anfang, JFreeChart.createChart() oder ähnliches,
andere Factories und Singletons mögen auch sein, wie in jeder Library, in jedem normalen Programm


auch dein Programm kann durchaus statische Anteile haben,
die main-Operation natürlich,
ein paar HashMap<String, Integer>[] mit Konstanten gerne,

aber das meiste ist bei dir völlig aus dem Ruder gelaufen,
ist für einen Anfänger natürlich nicht allzu dramatisch

aber wichtig ist, dass du das nicht als normalen Stil ansiehst,
ein JMenuItem ist nirgendwo auf der Welt statisch

-----

und vielleich noch ein wichtiger Punkt:
deine vielen Arrays lassen vermuten, dass du viele Infos verteilt speicherst,

zu einer Chart x befindet sich der Titel im Array a an Position 12,
die Länge der Achse in Array b an Position 12 usw.

das ist auch generell ein schlechter Stil,
besser ist da, ein eigenes ChartBeschreibung-Objekt zu haben,
mit Exemplarvariablen Title, Länge usw.
und möglichst wenig Arrays

sofern es sich dabei um allgemeine Konstanten handelt
(ALLE Charts haben den Title "schicke Chart")
kann man das natürlich wieder anders sehen
 
SlaterB hat gesagt.:
> im jFreeChart ist alles static, Methoden und Variablen,


aber wichtig ist, dass du das nicht als normalen Stil ansiehst,
ein JMenuItem ist nirgendwo auf der Welt statisch
Zum Vergrößern anklicken....

zu diesem Statement möchte ich mich gerne rechtfertigen,

ich musste im nachhinein Buttons am JPanel anlegen, welche genau das gleiche machen, wenn man diese drückt, wie wenn ich mit der rechten MT auf das ChartPanel klicke (z.B.: Popup-Menü -> drucken)


Ich hatte eine Klasse, welche

1. das ChartPanel und
2. meine buttons beinhaltet,

Mein Chartpanel ist ja in der Klasse oben (MultipleAxisTrend),

darum habe ich folgendes gemacht:


Code: 
// Methode actionPerformed(..)

if (evt.getActionCommand().equals("Drucken"))
            {
            JankMultipleAxisTrend.mi[Integer.parseInt(((JButton)evt.getSource()).getName())][2].doClick();
            }

Das war die einfachste Möglichkeit,



PS:
Mir ist durchaus klar, das OOP das erstellen von Klassen bedeutet, von denen Objekt erzeugt werden und das statische Methoden, Variablen nur verwendet werden sollen, wenn diese Varibale z.B.: alle Objektmethoden benötigen, nur ist eben mein Problem, dass ich immer wieder Aufgaben hinzubekomme und dass die Programmiersprache C die Haupt- Sprache in der Firma ist,

ich wehre mich so gut es geht gegen die sequenzielle Aufgabenstellung nur ist es halt sehr schwierig als Einzelkämpfer und schließlich muss sich ja auch jemand auskenne, sollte es mich mal nicht mehr in der Firma geben, daher mache ich es so, wies vorgeschlagen wird, ich kanns auch nicht anders machen, da ich das Ausmaß des Projekts ja nicht kenne,


Würd mich eh interessieren, wie das bei euch so ist,
ich gehe halt her, programmiers oop so gut es geht und zeichne dann das UML- Diagramm (normal ist es ja umgekehrt aber da fehlt das Verständnis von C- Programmierern)

lg
 
was hat das groß mit Firma, Änderungen, C oder UML zu tun?

wenn du das Programm zu dem Stand wie er gerade ist hast, dann muss es mal refactored werden,

das ist auch kein Vorwurf, da ist keine Rechtfertigung nötigt,
das ist eine Info/ ein Tipp für dich, eine Feststellung
 
stimme Slater zu... das hier sind Tipps und Anregungen sich Gedanken zu machen, man muss sich da nicht rechtfertigen...

nur
tatische Methoden, Variablen nur verwendet werden sollen, wenn diese Varibale z.B.: alle Objektmethoden benötigen
Zum Vergrößern anklicken....
das ist leider komplett falsch !

man macht nicht statische Methoden wenn sie alle Objektmethoden benoetigen... jedes Objekt erreicht seine eigenen Methoden, daher muss hier nix statisch sein.

Statische Methoden/Variablen macht man, wenn sie Objektunabhaengig sein sollen, d.h fuer die gesamte Klasse und somit nicht fuer den Zustand eines einzelenen Objekts dienen !
 
ja, das meinte ich ja, z.B.: der Klassische Objekt- Counter,

Ich hätte noch eine DefinitionsFrage, und zwar was ist eine Instanzvariable,

Bis jetzt glaubte ich, das ist eine Variable, die eine referenz auf ein Objekt einer Klasse ist aber im Entwurfsmuster- buch steht:


int zustand = 0; // Instanzvariable


Ist eine Instanzvariable also jede Variable??

lg
 
jede nicht statische im Unterschied zu den 'statischen Variablen'

in Operationen kannst du natürlich auch noch lokale Variablen definieren
 
Status
Nicht offen für weitere Antworten.

Aktuelle Jobs

Neue Themen

Ähnliche Themen

2 non-static Methoden, trotzdem Fehler "non static method can not be referenced from a static context"
Antworten: 9
Lebensdauer einer Klassenvariable
Antworten: 3
Scanner als Klassenvariable
Antworten: 5
Klassenvariable über Objekt aufrufen
Antworten: 16
Methode übernimmt nicht veränderte klassenvariable
Antworten: 5

Zurück
Oben