Zwei Klassen in einer App?

[androidika]

Hi Folks,
leider habe ich das Prinzip mit den Klassen (Java) wohl noch nicht so
ganz kapiert.

Eben habe ich das Spinner-Tutorial auf Android Developers
durchgearbeitet und es funktioniert prima.
(Spinner | Android Developers)

Danach habe ich das ListView Tutorial durchgearbeitet.
Auch das läuft problemlos.
(List View | Android Developers)

Nun möchte ich aber beide Elemente, also den Spinner sowie die
ListView in einer App benutzen.
Hier komme ich mit den Klassenprinzip nicht klar.

Die ListView wird als Klasse mit extends ListActivity notiert,
während beim Spinner das bekannte extends Activity eingesetzt wird.

Das kann ich aber ja nicht beides in eine Klasse schreiben.

Sagen wir mal die App heisst 'Hoschie'.
public class Hoschie extends Activity {....
und
public class Hoschie extends ListActivity {
geht jawohl nicht.

Somit würde ich
public class Hoschie extends ListActivity {
in eine z.B. ho.java auslagern.

Tja, und dann?
Wie greife ich drauf zu?

Im Moment kann ich keinen Code posten, weil ich hier alles
total umgemuddelt habe und nun überhaupt nicht mehr durch-
steige. *ARRRGHHH kirege gleich nen Hals hier...*

Werde wohl erst einmal eine Pause machen müssen.
Naja, Wetter ist gut und Bier sollte dann auch schmecken.

androidika (der gerade etwas gefrustet ist)

 

[K2DaC]

wenn ich jetzt nicht total daneben liege, erbt eine ListActivity von einer Activity. Wenn du nun mit extends eine ListActivity erbst, erbst du die "normale" Activity automatisch mit.

Schwer dir zu helfen, wenn man nicht weiß was du vorhats

Aber nur mal am rande :

der name der Java Datei muss immer der gleiche Name der Klasse sein.

In deinem Fall könntest du :

public class Hoschie extends ListActivity {
in eine z.B. ho.java auslagern.

schonmal vergessen
2 Klassen mir gleichem Namen sowieso

------------------

kleine einleitung in Klassen :

Person.java (Representiert die Klasse Person)

public class Person {
    private String vorname;
    private String nachname;
    
    public String getNachname() {
        return nachname;
    }

    public String getVorname() {
        return vorname;
    }    
    
    public void setNachname(String nachname) {
        this.nachname = nachname;
    }

    public void setVorname(String vorname) {
        this.vorname = vorname;
    }
    
    public void sagHallo()
    {
        System.out.println("Hallo, mein Name ist " + vorname + " " + nachname );
    }
    
    
}

Hier die Klasse "Meinapp", gespeichert in Meinapp.java

public class Meineapp {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person eineNeuePerson = new Person();
        
        eineNeuePerson.setNachname("Mueller");
        eineNeuePerson.setVorname("Daniel");
        
        eineNeuePerson.sagHallo();
        
    }

}

Wir erstellen uns eine neue Person, geben ihr Vor und Nachnamen, und rufen auf dem Objekt .sagHallo auf.
Die Ausgabe des kleinen Programms wäre jetzt
"Hallo, mein Name ist Daniel Mueller"


Ohne java kommt man bei android leider nicht weit

Hier noch eine kurze ergänzung zu Vererbung und override / also dem Überschreiben von methoden (oder überladen? wie auch immer)

public class Mann extends Person{         
    final private String geschlecht = "Männlich";
    
    @Override
    public void sagHallo()
    {
        System.out.println("Hallo, mein Name ist " + getVorname() + " " + getNachname() + " und ich bin " + geschlecht );
    }
}

Ein Mann ist eine Person, also erben wir für die klasse Mann die Klasse Person.
Sie hat den zusatz "geschlecht = Männlich";

mit @Override sagen wir, dass wir hier unser sagHallo(), also das vom Mann benutzen wollen, und nicht das sagHallo() von Person.

hier noch die Main :

public class Meineapp {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person eineNeuePerson = new Person();
        
        eineNeuePerson.setNachname("Mueller");
        eineNeuePerson.setVorname("Daniel");
        eineNeuePerson.sagHallo();
        
        Mann auchEinePersonAberMaennlich = new Mann();
        auchEinePersonAberMaennlich.setNachname("Meier");
        auchEinePersonAberMaennlich.setVorname("Hans");
        auchEinePersonAberMaennlich.sagHallo();
    }

}

ausgabe ist :
Hallo, mein Name ist Daniel Mueller
Hallo, mein Name ist Hans Meier und ich bin Männlich

//Eigentlich ist hier schon ein designFehler. Es gibt keine Geschlechtslosen Personen. Beim Versuch die Klasse Frau zu erstellen, müsste ich wieder final String geschlecht = "weiblich"; einführen. Unnötig wenn man es gleich in "Person" gemacht hätte als Leerer String, und dann in der entsprechenden klasse mit setGeschlecht("m...") nur noch eingestellt hätte, aber wie auch immer.
Ohne dem verständniss von Klassen geht bei android nicht viel



///////

Eventuell hilft dir das hier :
http://www.dpunkt.de/leseproben/3319/5_Kapitel%206%20bis%206.3.pdf

Dort wird erklärt wie man eine Listview mit eingebautem spinner realisiert

 

[androidika]

HeyHo,
vielen herzlichen Dank für die ausführlichen Erläuterungen.
Ich habe Deine Hinweise berücksichtigt und auch schon das
Wesentliche verstanden (denke ich).

Folgend die drei Quellcodes
Klassen.java (mit Main-Methode)
Person.java (mit den Variablen und Methoden)
Mann.java (mit extends Person)

Alle Dateien habe ich mit Kommentaren versehen, in denen ich
versuche zu erklären, wie ich es verstehe. Es sind allerdings auch
noch ein paar Fragen dabei.

Über ein kurzes feedback freue ich mich natürlich wieder.

Klassen.java

// Der Name der Klasse entspricht dem Dateinamen
// In diesem Fall ist es die Klasse mit der
// Main-Anweisung (die nur einmal auftauchen darf)

public class Klassen 
{
    public static void main(String[] args)
    {
        // Jetzt wird ein Objekt der Klasse Person erzeugt.
        // Der Bezeichner lautet eineNeuePerson
        // Die Deklarierung und die Initialisierung geschehen
        // hier zusammengefasst in einer einzigen Zeile.
        // Dem Bezeichner eineNeuePerson wird über das Wort 
        // new das "Person-Objekt" zugewiesen (Initialisierung).
        // Über den Bezeichner besteht also Zugriff auf das Objekt.
        Person eineNeuePerson = new Person();

        // Hier wird über den Bezeichner auf das Objekt zugegriffen,
        // was durch die Initialisierung mit Person dazu führt, dass
        // in der richtigen Klasse (nämlich Person in der Person.java)
        // auf die Methode setNachname() zugegriffen werden kann.
        // Konkret wird hier durch den Aufruf der Methode setNachname 
        // der String "Hotter" an die Methode setNachname übergeben.
        eineNeuePerson.setNachname("Hotter");
        
        // analog zum Nachnamen
        eineNeuePerson.setVorname("Parry");
    
        // Aufruf der Methode sagHallo in der Klasse Person
        // (auch hier durch die Objektdefinition festgelegt).
        eineNeuePerson.sagHallo();
        
        Mann auchEinePersonAberMaennlich = new Mann();
        auchEinePersonAberMaennlich.setNachname ("Meier");
        auchEinePersonAberMaennlich.setVorname ("Hans");
        auchEinePersonAberMaennlich.sagHallo();
    }
}

Person.java

public class Person 
{
    // Konstruktor ???
    // Werden die Variablen hier nicht hineingeschrieben,
    // würde es Fehlermeldungen geben, da die Methoden
    // die Variablen nicht kennen würden.
    // Ich vermute also, dass die Variablen hier global
    // (aber nur für diese Klasse!) für die Methoden zur
    // Verfügung gestellt bzw. bekanntgemacht werden.
    private String vorname;
    private String nachname;
    
    // Diese Metohde erwartet keine Daten, gibt aber nachname
    // an die aufrufende Seite zurück.
    // In diesem Beispiel erfolgt der Aufruf der Methode getNachname
    // in der Datei Mann.java
    // Wie aber kann die Methode getNachname den Nachnamen liefern,
    // wenn gar kein Nachname in die Methode getNachname geschrieben wird???
    public String getNachname()
    {
        return nachname;
    }

    // analog zu getNachname
    public String getVorname()
    {
        return vorname;
    }

    // Diese Methode bekommt als String den Nachnamen
    // Was bedeutet hier this ???
    public void setNachname(String nachname)
    {
        this.nachname = nachname;
    }

    // analog zu setNachname
    public void setVorname(String vorname)
    {
        this.vorname = vorname;
    }

    // Ausgabe des Textes
    // Die Variablen vorname und nachname sind nun welche?
    // 1. die aus private String nachname...
    // 2. die aus return nachname...
    // 3. die aus this.nachname...
    // Habe hier n bissel den Faden verloren. ;-)
    public void sagHallo()
    {
        System.out.println("Hallo, mein Name ist: " + vorname + " " + nachname);
    }
}

Mann.java

// Das hier verstehe ich wie folgt:
// Die Klasse Person ist die Basisklasse,
// die um die Methoden der Klasse Mann
// erweitert wird.
// Oder anders ausgedrückt: Die Klasse
// Mann wird von der Klasse Person abgeleitet.
// Sehe ich das richtig, dass mir alle Methoden
// der Klasse Person PLUS ZUSÄTZLICH die Methoden
// der Klasse Mann zur Verfügung stehen?
// Ich kann also "ganz normal" auf die Methoden
// getVorname und getNachname aus der Klasse Person
// zugreifen.
// Warum muss hier mit "final" gearbeitet werden?

public class Mann extends Person
{
    final private String geschlecht = "männlich";
    
    // Das Override verstehe ich noch nicht.
    // Wenn ich es auskommentiere, hat es keine Auswirkungen
    // auf die Ausgabe.
    // Er benutzt also sowieso das sagHallo von Mann und nicht
    // von Person.
    @Override
    public void sagHallo()
    {
        System.out.println("Hallo, mein Name ist " + getVorname() + " " + getNachname() + " und ich bin " + geschlecht);
    }
}

Danke
androidika

 

[K2DaC]

Ich fang mal hinten an:
@Override muss nicht da stehen. geht auch ohne. Man sollte sich aber angewöhnen dies hin zu schreiben, um im nachhinein sofort zu sehen, hier wird eine andere methode überschrieben!

Zu final
kurz und bündig : muss nicht da stehen. bin mir auch grad garnicht sicher ob das final das macht was es soll. wollte damit nur ausdrücken, dass sich das geschlecht eines Mannes wohl kaum ändern wird
(Korrekt wäre wohl : private static final String geschlecht = "Männlich"; ) das ist soetwas wie eine Konstante, unveränderbar.

zu:
Sehe ich das richtig, dass mir alle Methoden
der Klasse Person PLUS ZUSÄTZLICH die Methoden
der Klasse Mann zur Verfügung stehen?
exakt. Du bekommst alles was Person besitzt: methoden, variablen, ... und du kannst diese um weitere methoden, variablen erweitern.

zu Person.java :

Ich habe hier keinen Konstruktor erstellt. Wenn man keinen erstellt, tut das Java für uns, und erstellt einen Standartkonstruktor. Der tut erstmal eigentlich garnix. Daher müssen wir der Person auch mit setVorname und setNachname werte zuweisen. (Wenn du Fragen dazu hast, wie man eigene Konstruktoren erstellt, werde ich dir das morgen beantworten).

Variablen bei Java werden in Klassen Global definiert.
die Methoden getNachname & getVorname geben mit "return nachname;" den wert der Globalen variable zurück. besser wäre hier "return this.nachname;"
wenn diese nicht vorher mit setNachname mit werten versehen, liefern sie NULL.
Daraus lässt sich schließen, setNachname("Meier"); setzt in der Klasse die Globale Variable "Nachname" auf Meier;

this.XYZ bezieht sich immer auf die globale Variablen. dient zur übersicht, und um fehler zu vermeiden.
Würde man es weglassen, würde dort "Nachname = Nachname;" stehen. Wer weiß schon welcher Nachname nun welcher ist ? Daher schreiben wir
this.Nachname = Nachname;
Der rechte teil vom = ist die "lokale" Variable Nachname. dies ist unser übergabeparameter.

Zu ausgabe des Textes : schöner wäre gewesen
System.out.println("Hallo, mein Name ist: " + this.vorname + " " + this.nachname);

Da wir die werte der globalen Variablen ausgeben wollen. Da es in der Methode aber keine Weiteren Variablen gibt, geschweige welche, die den gleichen namen haben wie unsere globalen, kann man es sich auch schenken

mehr morgen früh, muss nu ins bett

 

[K2DaC]

Konstruktoren:

Wir erweitern die Klasse Mann um 2 Konstruktoren.
Sobald wir einen eigenen Konstruktor erstellen, erstell Java für uns keinen Standart kontruktror. Da wir unser MainProgramm aber nicht ändern, sondern nur ergänzen wollen, erstellen wir uns den eigentlichen Standartkonstruktor nochmal mit.

public class Mann extends Person{
    
    
    private static final String geschlecht = "Männlich";
    
    ////////Eigentlich der Standartkonstruktor/////////////////
    public Mann()
    {}
    ////////Ende des eigentlichen Standartkonstruktor//////////
    
    ///////Jetzt kommt unser Konstruktor///////////////////////
    public Mann(String Vorname, String Nachname)
    {
        this.setNachname(Nachname);
        this.setVorname(Vorname);
    }
    //////Ende des eigenen Konstruktors////////////////////////
    
    @Override
    public void sagHallo()
    {
        System.out.println("Hallo, mein Name ist " + getVorname() + " " + getNachname() + " und ich bin " + geschlecht );
    }
}

Unser mainApp kann jetzt wie folgt benutzt werden

public class Meineapp {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        Person eineNeuePerson = new Person();
        
        eineNeuePerson.setNachname("Mueller");
        eineNeuePerson.setVorname("Daniel");
        eineNeuePerson.sagHallo();
        
        Mann auchEinePersonAberMaennlich = new Mann(); //Standartkonstruktor
        auchEinePersonAberMaennlich.setNachname("Meier");
        auchEinePersonAberMaennlich.setVorname("Hans");
        auchEinePersonAberMaennlich.sagHallo();
        
        Mann nochEinMann = new Mann("Hans","Meiser"); // Eigenen Konstruktor
        nochEinMann.sagHallo();
    }

}

Mann nochEinMann = new Mann("Hans","Meiser");

Wir übergeben dem Konstukror also gleich vorname und name. Wenn wir den Standartkonstruktor nicht manuell implementiert hätten, könnten wir
Mann auchEinePersonAberMaennlich = new Mann();
nicht mehr benutzen.
Den Standartkonstruktor lässt man häufig weg, wenn man z.b. Verhindern will, dass (in unserem Bsp.) Leere Männer erstellt werden.
MAn ist also in der MAinapp gleich gezwungen, dem Mann Vor & Nachname zu geben.

 

[androidika]

Wow! (Nein, nicht Wold of Wargedingens)
Super ausführliche Erklärung. Habe auch im Netz noch einmal
eine Menge Stoff zur Materie nachgelesen.
Das einzige, was mir noch nicht so richtig ins Blut geht,
sind die Konstruktoren, obwohl ich das anhand Deines Beispiels
begriffen habe...zumindest für diesen Fall.

Aber ich finde das schon arg gewöhnungsbedürftig.
Da muss ich wohl noch 'hineinwachsen'.

Bisher habe ich noch nicht objektorientiert programmieren müssen.
Zwar habe ich schon Dinge u.a. im Studium darüber gehört, aber
wenn man das dann jahrelang nicht benötigt....
...dann isses irgendwann weg.

Wie dem auch sei. Ich bin froh, dass ich in diesem Forum gelandet
bin und hier eine Super Hilfe erfahren habe.

DANKE
androidika

 

[the_alien]

Ein hervorragendes Buch über Java findest du übrigens bei Galileo Press: Java ist auch eine Insel. Kannst du komplett kostenlos online lesen.

 

[magpie]

Hallo
Als Buch kann ich dir "Java von Kopf bis Fuß" empfehlen. Da werden Objekte ausführlich und leicht verständlich erklärt.
Grüße magpie

 

[garak]

Bisher habe ich noch nicht objektorientiert programmieren müssen.

Falsche Formulierung, du solltest sagen "..noch nicht..dürfen". Wenn du es erst einmal verinnerlicht hast, willst du nie wieder etwas anderes machen müssen.

Zum Thema Konstruktoren, die du ja noch nicht richtig verstanden hast:

Klassenvariablen unterscheiden sich in notwendig und optional. Notwendige Variablen, ohne die eine Klasse nicht richtig funktionieren kann, gehören in den Konstruktor. Optionale Parameter werden nach der Initialisierung zugewiesen. Wenn du dir diesen Grundsatz merkst, hast du nie das Problem was ein Konstruktor beinhalten muss.

Wenn du notwendige Variablen hast, dann lege niemals einen Standard-Konstruktor an, der ohne Parameter auskommt. Und vermeide Pyramieden-Konstrukoren. Es gibt wesentlich elegantere Methoden, optionale Parameter in der Initialisierung unterzubringen.

Soweit für's erste...