static Android - was geht klar, was nicht?

  • 8 Antworten
  • Letztes Antwortdatum
missspelled

missspelled

App-Anbieter (In-App)
127
Hallo, in einem anderen Thread ging es um o.g. Fragestelltung, besser gesagt "wann das Keyword static Probleme hinsichtlich Memoryleaks macht/machen kann". Daher habe ich hier mal einen neuen Thread dazu aufgemacht, um diese Fragestellung konkreter zu thematisieren.

markus.tullius schrieb:
Statische Methoden sind recht übel, da die Objekte, die an ihnen hängen, nicht weggeräumt werden. Hängen im Speicher herum, und sind teilwiese nicht mehr erreichbar.

Das habe ich auch schon öfter gehört. Allerdings auch selbst noch keine negativen Erfahrungen gemacht - wohlgemerkt in Helferklassen.
An was liegt das - spielt es eine Rolle das die Helferklasse "final" ist? Vermutlich nicht...
Ich denke eher, dass die Erreichbarkeit, gar nicht mal so das Problem darstellt.. Sondern, schlicht und ergreifend, die Tatsache, dass ein "fester" Context in einer solchen Helferklasse nichts zu suchen hat und erst durch diesen Leaks entstehen. Wird der (aktuelle) Context der Methode beim Aufruf übergeben, sollten Leaks kein Problem darstellen. So meine Vermutung..
Eine Helferklasse benutze ich, um die Wartbarkeit und Lesbarkeit des Codes zu verbessern, bzw. die Codemenge zu reduzieren. Hier ein Beispiel für eine solchen Helfer:

Code:
public final class Logic {

    public static void toastShort(Context context, String message) {
        Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
    }


    public static void toastLong(Context context, String message) {
        Toast.makeText(context, message, Toast.LENGTH_LONG).show();
    }


    public static void toastLong(Context context, String message) {
        Toast.makeText(context, message, Toast.LENGTH_LONG).show();
    }

    public static boolean isDarkTheme(Context c) {
        final SharedPreferences sp = c.getSharedPreferences(MP.CONFIG_FILE_NAME, Context.MODE_PRIVATE);
        return !sp.getString(MP.PK_LIST_THEME, MP.DEFAULT_THEME).equals(MP.LIGHT);
    }

PS: in dem anderen Thread habe ich es schon gesagt, wiederhole es hier aber nochmal: Ich selbst kann dazu keine konkreten Erfahrungswerte abgeben, da ich auf den "static"-Bezeichner, mit obiger Ausnahme, verzichte.
 
Ich bin auch der Meinung(!), dass statische Methoden per se gar kein Problem darstellen. Genauso wie statische Variablen per se erstmal kein Problem darstellen.
Problematisch wird es erst wenn der Lifecycle ins Spiel kommt. Also z.B. statische Variablen in Activities um State auszutauschen...
Bei Helferklassen, die sich nichts merken sehe ich da überhaupt kein Problem. Im Gegenteil: Wenn ich aus 10 verschiedenen Klassen ein "new Util()" mache (damit ich keine statischen Methoden habe), habe ich das Ding 10 mal instanziiert und im Speicher rumhängen. Util.method() ist da weniger speicherintensiv. Alternativ kann man natürlich alle Util Klassen Singleton machen, aber so richtig viel Mehrwert bringt das auch nicht.

Das Problem ist eigentlich, und so gesehen ist eine allgemeine Warnung angebracht, dass zu viele Leute ohne ausreichenden Informatik-Background anfangen Apps zu programmieren. (Erinnert an die Schwemme von HTML-"Entwicklern" als das Internet populär wurde, HTML konnte "jeder")
Das soll jetzt nicht diffamierend sein oder die Leute als schlechte Menschen abstempeln. Ich finde es toll, wenn sich fachfremde Menschen mit der Materie befassen wollen. Aber oftmals ist es in diesen Fällen einfach einfacher zu sagen "statisch ist böse" anstatt die möglichen Einzelfälle nahe zu bringen.
 
  • Danke
Reaktionen: missspelled
https://www.youtube.com/watch?v=_CruQY55HOk

unbedingt mal anschauen ab 25:40 (und dann solang wie ihr wollt er kommt im letzten teil noch zur Arbeit mit einem memory analyzer wie man leaks ausfindig macht mit hilf von dominator trees und so)

hier ein zu Memory Leaks führender Code so wie im Video:

PHP:
public class MainActivity extends Activity
{
    static InnerClass innerClass=null;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        innerClass=innerClass==null?new InnerClass():innerClass;
        ...
    }


    class InnerClass
    {
        public void doSth()
        {
            ...
        }
    }
    ...
}


Der ursprüngliche Beitrag von 17:55 Uhr wurde um 17:56 Uhr ergänzt:

mal ne frage bevor ihr euch das video anguckt wo ist der memory leak?
 
Wer Programmiert bitte so?
 
ich denke kau meienr aber man kann ja seiner fantasie freien lauf lassen vllt erfüllt die innerClass für jemanden einen ganz speziellen zweck und er/sie möchte über die activity hinaus auf deren variablen oder methoden der instanzen zugriff haben...

manche leute denken sich ja die wildesten wege nach rom aus

Der ursprüngliche Beitrag von 19:02 Uhr wurde um 19:06 Uhr ergänzt:

ich hasse es mit dem finger auf elute zu zeigen aber heir in diesem thread (in folge dessen dieser thread ins lebens gerufen wurde) ->https://www.android-hilfe.de/forum/android-app-entwicklung.9/activity-beim-start-laden.673857.html

versucht er duch statische variablen und methode in eienr neuen activity an informationen aus einer voprhergehenden activity zu gelangen,a uch wenn er jetzt keinen memory leak verursacht zur zeit...soweit ich das sehen kopnnte jedenfalls....ist es doch keine gute herangehensweise imho
 
So ein static ist schnell mal vergessen... :D In einer Activity ist das vielleicht nicht so sinnig, aber in einem Application-Objekt kann das durchaus sinnvoll sein.
 
Der Hacken an statischen Variablen ist, das sie Klassenvariablen sind. Ein Objekt, welches einer statischen Variable zugewiesen wird, lebt ewig (Bis das Programm beendet wird). Kein GC räumt das Objekt weg!

Das ist zwar schon ärgerlich, aber man kann mit ihnen auch die Kapselung umgehen. Und das ist schon recht böse. Die Idee hinter OPP ist modularen, gekapselten Programmcode zu erzeugen. Und die Kommunikation läuft über definierten Schnittstellen. Mit statischen Variablen hat man die Möglichkeit, die Kapselung zu umgehen, und kann schlechten Code lauffähig machen.

Und zu Laufzeit weiß man auch nicht mehr, welchen Wert die Variable annimmt, da global von allen allen Stellen des Programmcode darauf zugegriffen werden kann. (siehe Beispiel https://www.android-hilfe.de/android-...art-laden.html)
Ein anderes Beispiel für die Problematik waren die ersten Windows-Versionen. Windows 95 und 98 waren berühmt, berüchtigt für ihren Abstürtze. ;)

Es gibt auch Ausnahmen, z.B. ein Singelton. Aber ob der Einsatz eines Singelton ein gute Idee ist, darüber gibt es endlose Diskussionen.
 
  • Danke
Reaktionen: missspelled
markus.tullius schrieb:
aber man kann mit ihnen auch die Kapselung umgehen. Und das ist schon recht böse.

Sehe ich 100%tig genauso. In dem Szenario gibt es den riesigen Nachteil (unabhängig von MemoryLeaks), dass man als Programmierer Zustände über verschiedene / verschiedenste Klassen und Prozesse weiterreicht bzw. auf diese zurückgreift. Das Ende vom Lied ist Code, den kein Mensch mehr versteht und eine Wartung mit zunehmender Projektgröße immer problematischer wird.

Auf Stackoverflow habe ich mal von "John Skeet" folgendes gelesen (frei aus der Erinnerung übersetzt): "Dem Mensch fällt es leicht im Kleinen zu denken, deswegen solle man Logik in kompakten Einheiten (möglichst modular) zusammenfassen."
Ich denke damit hat er den Nagel auf den Kopf getroffen und selbst ein Programmiereinsteiger weiß sofort was gemeint ist.
 

Ähnliche Themen

M
Antworten
21
Aufrufe
1.269
swa00
swa00
Mr-Fisch
Antworten
5
Aufrufe
933
migi01
migi01
Mr-Fisch
Antworten
8
Aufrufe
983
Mr-Fisch
Mr-Fisch
M
Antworten
9
Aufrufe
766
mkuz24
M
A
Antworten
5
Aufrufe
677
swa00
swa00
Zurück
Oben Unten