static Klassenvariable

Status
Nicht offen für weitere Antworten.

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
 
S

SlaterB

Gast
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
 

PollerJava

Top Contributor
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
 
S

SlaterB

Gast
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 ;)
 

PollerJava

Top Contributor
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;
        }    
}
 

PollerJava

Top Contributor
so schaut meine Klasse aus (oben),
vielleicht will sichs ja jemand ansehen,

Bin für jeden Verbesserungsvorschlag dankbar
 
B

bygones

Gast
PollerJava hat gesagt.:
so schaut meine Klasse aus (oben),
vielleicht will sichs ja jemand ansehen,

Bin für jeden Verbesserungsvorschlag dankbar
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
 

PollerJava

Top Contributor
im jFreeChart ist alles static, Methoden und Variablen,

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

lg
 
S

SlaterB

Gast
> 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
 

PollerJava

Top Contributor
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

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
 
S

SlaterB

Gast
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
 
B

bygones

Gast
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
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 !
 

PollerJava

Top Contributor
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
 
S

SlaterB

Gast
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.
Ähnliche Java Themen
  Titel Forum Antworten Datum
E Methoden abstract static Methode Allgemeine Java-Themen 8
N nicht static und auch nicht new Allgemeine Java-Themen 3
P static Blocks und variablen Allgemeine Java-Themen 41
Kirby.exe Cannot make a static reference to the non-static field rimWidth Allgemeine Java-Themen 12
Thallius Ist meine static Helper Class Thread save? Allgemeine Java-Themen 9
S static in Interface und Klasse Allgemeine Java-Themen 2
S static methode im Interface Allgemeine Java-Themen 1
A Variablen non-static variable cannot be referenced from a static content Allgemeine Java-Themen 4
P Static Variable -> unterschiedliche Werte? Allgemeine Java-Themen 1
K Static Variablen verbieten Allgemeine Java-Themen 10
C Generic collections und static typing Allgemeine Java-Themen 4
M Warum nicht static ? Allgemeine Java-Themen 10
M Eine static-Methode verlassen Allgemeine Java-Themen 2
B Schlüsselworte [ERLEDIGT] static { } - Was ist das und wofür kann ich das brauchen? Allgemeine Java-Themen 1
J private static final String variable Allgemeine Java-Themen 8
L Non-static-Variables in Enumerationen Allgemeine Java-Themen 2
L OOP Klassen-Design (static oder nicht?) Allgemeine Java-Themen 3
T Enumeration/Static Final/Bitfield Allgemeine Java-Themen 6
T Static kann nicht verändert werden Allgemeine Java-Themen 3
W Threads Cannot make a static reference.. Allgemeine Java-Themen 13
H Programierstil: static - Zugriff vs. Staticzugriff Allgemeine Java-Themen 24
N Static oder andere Lösung Allgemeine Java-Themen 5
N Vererbung Static & private fields - Nicht ganz einfach? Allgemeine Java-Themen 4
M Wo hin mit static factory methods? Allgemeine Java-Themen 40
M Public Static importRunning -> Bad Design oder ok ? Allgemeine Java-Themen 5
S Cannot make a static reference to the non-static field MySecondClass.Points Allgemeine Java-Themen 3
M Methoden Static Methoden und Thread??? Allgemeine Java-Themen 4
S auf public void Methode zugreifen ohne static Allgemeine Java-Themen 11
K Static - Problem Allgemeine Java-Themen 10
M Variablen Variablenzugriff aus static void Allgemeine Java-Themen 21
D API - Beispiel + static member in inner (non static) class Allgemeine Java-Themen 2
S static methoden Allgemeine Java-Themen 9
S Performance Frage: Objekt oder static? Allgemeine Java-Themen 33
X HTTP Problem mit static/non static JTextArea Update Allgemeine Java-Themen 17
A Annotation einer Subklasse im static-Block auslesen. Allgemeine Java-Themen 6
woezelmann referenz der outer class aus static nested class heraus Allgemeine Java-Themen 7
B static Variable / Unterklasse Allgemeine Java-Themen 2
I Was macht static { ... } ? Allgemeine Java-Themen 8
G static inner Klassen Allgemeine Java-Themen 7
G static und dynamic linking? Allgemeine Java-Themen 32
J in einer static Variable Wert ändern Allgemeine Java-Themen 6
J Verständnisfrage - nested static classes Allgemeine Java-Themen 11
G static- Methoden überschreiben Allgemeine Java-Themen 10
E Geschwindigkeit static Allgemeine Java-Themen 6
V Static oder wie? Allgemeine Java-Themen 61
I reflection get inner static classes Allgemeine Java-Themen 2
L static main - Spezifikation? Allgemeine Java-Themen 7
G URLClassLoader stößt static Block nicht an Allgemeine Java-Themen 8
D static Allgemeine Java-Themen 46
P static-Methode aus dem Konstruktor aufrufen Allgemeine Java-Themen 6
oliver1974 "(.) should be accessed in a static way" Falsche W Allgemeine Java-Themen 6
B JPasswordField klassenübergreifend auslesen->static Probl Allgemeine Java-Themen 4
F Methoden: static vs. instance Allgemeine Java-Themen 24
MQue static Methoden/Klassen Allgemeine Java-Themen 7
K Warum static-Methoden nutzen Allgemeine Java-Themen 26
G Java-Befehle Native und Static Allgemeine Java-Themen 2
conan2 static-Block in Klassen Allgemeine Java-Themen 6
M JNI, static.a mit load.Library laden? Allgemeine Java-Themen 2
K Static Members von Superklasse für JEDEN Erben Allgemeine Java-Themen 6
padde479 The static method sleep(long) from the type Thread should. Allgemeine Java-Themen 2
M static-Methode vorschreiben Allgemeine Java-Themen 5
S singleton vs. static Allgemeine Java-Themen 7
G Object mit static Feldern speichern Allgemeine Java-Themen 9
J Warum heißt es eig. "public static void main" ? Allgemeine Java-Themen 4
conan2 "Cannot make a static reference to the non-static field Allgemeine Java-Themen 8
P Singleton vs static Allgemeine Java-Themen 19
J parameterized und static fields Allgemeine Java-Themen 4
A Static reference to non-static field Allgemeine Java-Themen 10
S static umgehen Allgemeine Java-Themen 5
G static oder nicht Allgemeine Java-Themen 4
J Problem mit static/non-static Allgemeine Java-Themen 2
G getAppletContext() in static Methode Allgemeine Java-Themen 3
m@nu Programm-Models in Static-Objekten speichern Allgemeine Java-Themen 5
J Nicht-static variable in static variable kopieren - wie? Allgemeine Java-Themen 14
O does not declare a static final serialVersionUID field of . Allgemeine Java-Themen 6
G static vor einem array Allgemeine Java-Themen 2
K Überschreiben von 'static'-Methoden hat anderes Verhalten? Allgemeine Java-Themen 2
A JSP & static-Variablen Allgemeine Java-Themen 3
B Static Import: Syntaxfrage Allgemeine Java-Themen 2
S Static + Speicher + Bytecode etc. Brauche HILFE :/ Allgemeine Java-Themen 11
Z auf static Methode aus anderen Package zugreifen? Allgemeine Java-Themen 7
N this im public static void Allgemeine Java-Themen 3
C Communication zwischen zwei Projekte - static objects Allgemeine Java-Themen 4
S static mit abstract und in interface Allgemeine Java-Themen 10
J Variablen Scanner als Klassenvariable Allgemeine Java-Themen 5
D String und Klassenvariable Allgemeine Java-Themen 6
kodela Klassen Klassenvariable wird nicht gesetzt Allgemeine Java-Themen 23
M Klassenvariable wird nicht überschrieben. Allgemeine Java-Themen 5
J Lebensdauer einer Klassenvariable Allgemeine Java-Themen 3

Ähnliche Java Themen

Neue Themen


Oben