Wie kann ich eine non-static Funktion aus anderer Klasse aufrufen?

Das folgende Wissen stammt aus der Objective-C Welt und muss so nicht zu 100% auf Java portierbar sein. Ich finde es aber logisch und es funktioniert ähnlich, deshalb tue ich es dennoch.

Zum Einen gibt es zwei Arten von Objekten in Java: Klassenobjekte und Instanzobjekte.
Was immer man als Klasse erstellt ist an und für sich schon ein Objekt, denn es reagiert auf Nachrichten.

new Class() ruft den Konstruktor des Klassenobjekts auf und legt ein Instanzobjekt nach den Vorgaben des gewählten Konstruktors an.
Weiterhin verstehe ich 'static' als Klassenmethoden und non-static als Instanzmethoden.

Das heißt, die als static gekennzeichneten Methoden benötigen zum Aufruf ausschließlich das Klassenobjekt.
Deshalb gehen Dinge wie Collections.reverse(List<T>);

Alle anderem Methoden benötigen zum Aufruf ein Instanzobjekt.
Deshalb geht nicht Array.add(object);, sondern nur (new Array()).add(object);

Demnach hast du zwei simple Möglichkeiten.
Wann immer du dein Tools-Objekt benötigst, baust du dir ein Instanzobjekt davon.
Also quasi (new Tools()).vibrate(500);

Sinnvoll kann es aber auch sein, vibrate als Klassenmethode zu implementieren.
Salopp:

public class Tools...{
   public static void vibrate(int laenge) {
    /* Well, it's Java. 
    Das Device muss keinen Vibrator-Service haben, irgendwas könnte schief gehen etc.pp. 
    Errorhandling und Exceptionhandling sind also im Produktivcode angebracht. ;) */
    ((Vibrator)getSystemService(Context.VIBRATOR_SERVICE)).vibrate(laenge);
   }
}

Es kann natürlich durchaus passieren, dass du aus einer Static-Methode auf eine Non-Static Methode zugreifen möchtest, was dann zu Problemen führen kann.
Aber ich denke, der generelle Ablauf dürfte erkennbar sein.

Du musst schon einen Konstruktor ausführen.
Dieser sollte den Context der momentanen Activity beinhalten und dann kannst du deine Methode mit diesem Context aufrufen.
So sollte es gehen

Was spricht denn dagegen, die Methode einfach static zu machen?
So wie Lucas de Vil schon angedeutet hat (nur das der Context noch mitgegeben wird)

public static void vibrate(Context context, int length)
{
    ((Vibrator)context.getSystemService(Context.VIBRATOR_SERVICE)).vibrate(length);
}

Diese Methode soll ja nicht den Zustand eines Objektes verändert, daher ist es in deiner Utility-Klasse ganz gut aufgehoben.

block_

Hallo maalbert,

es hat schon seine Richtigkeit dass du .getSystemService nicht ohne Context aufrufen kannst:
Die meisten Systemservices brauchen ja bestimmte Rechte (welche du in er manifest Datei angeben musst). Also muss die getSystemService Funktion den "Context" kennen, um bestimmen zu dürfen ob du überhaupt diese Funktion ausführen darfst.

Hier mein Lösungsansatz, wird wohl der "sauberste" sein. Allerdings würde ich vielleicht dann zwei Tools klassen machen, eine die initalisiert werden muss mit Context, und eine "normale".

import android.content.Context;import android.os.Vibrator; 
public abstract class Tools { 
private static Context mContext; 


public static void initTools(Context c){ 
mContext = c; 
} 


public static void vibrate(int length){ 
Vibrator vib = (Vibrator)mContext.getSystemService(Context.VIBRATOR_SERVICE); 
vib.vibrate(length); 
} 




}

In deiner MainActivity:

@Overrideprotected void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
setContentView(R.layout.activity_main); 
Tools.initTools(this); 
NotAnActivity test = new NotAnActivity(); 
test.testVibrator(); 
}

Die Testklasse ohne verfügbaren "Context":

public class NotAnActivity { 


public void testVibrator(){ 
Tools.vibrate(1000); 
} 


}

PS: sorry keine Ahnung wieso mein source code so komisch formatiert ist, irgendwie funktionert das mit copy-paste und "java" flag hier im editor nicht so richtig.

Gruss

antifish

antifish
Zwei Klassen für eine Hilfsmethode halte ich persönlich etwas zu viel.
Statt der zweiten non-static Klasse kann man doch genauso gut direkt die statische Methode aufrufen. (Warum ist die Tools-Klasse abstract?)

maalbert

public final class Tools
{
   // verhindern das eine Instanz der Hilfsklasse erzeugt werden kann
   private Tools(){}


   private static vibrate(Context context, int length)
   {
      ((Vibrator)context.getSystemService(Context.VIBRATOR_SERVICE)).vibrate(length);
   }
}

Und Aufruf in der Activity:

Tools.vibrate(this, 1000);

So mach ich das immer und es funktioniert einwandfrei.

block_

Zitat von block_

antifish
Zwei Klassen für eine Hilfsmethode halte ich persönlich etwas zu viel.
Statt der zweiten non-static Klasse kann man doch genauso gut direkt die statische Methode aufrufen. (Warum ist die Tools-Klasse abstract?)

Wenn du richtig schaust ist es nur eine Klasse, die andere ist nur zu Demonstration.
Warum ist sie abstract? Verhindert instanzieren. Klar, Constructor private machen geht auch

Deine Methode brauch genau mein .init weniger, allerdings musst du dann trotzdem IMMER den Context mitgeben, also bringt es dir gar nix wenn du in einer Klasse bist in der du keinen Zugriff auf den Context hast, ausser du löst das halt anderst, es gibt ja verschiedene möglichkeiten. Auch ein public static Context in der MainActivity währe möglich und immer das verwenden...

Okay, jetzt hab ichs verstanden
Allerdings würde ich den Context auch nicht statisch halten. Was passiert dann wenn die Activity mit dem Context vom System destroyed wird? Dann gibts doch auch Probleme und um das zu umgehen musst trotzdem in jeder Activity deine init() Methode ausführen.

block_

Zitat

Okay, jetzt hab ichs verstanden
Allerdings würde ich den Context auch nicht statisch halten. Was passiert dann wenn die Activity mit dem Context vom System destroyed wird? Dann gibts doch auch Probleme und um das zu umgehen musst trotzdem in jeder Activity deine init() Methode ausführen.

block_

Ja das stimmt, kann zb bei mehreren activities ein Problem sein, da währe deine Lösung sicherer. Ist immer schwierig ohne die ganze App zu kennen.

Lg antifish

Ginge statt Übergabe von Context auch einfach ein getBaseContext() in der Static Methode?