methoden holen geht nicht mehr.

[rellik]

Guten Abend,

ich habe eine Klasse die von Activity erbt und möchte eine Methode benutzen für die ArrayList, dass geht aber nicht.

Objekte erstellen geht ohne problem aber dann will ich die methode holen und der name der Methode wird rot und dann steht als fehler folgendes.

cannot resolve symbol add

 

[jogimuc]

Hi zeige uns mal wie du das machst.
Ohne Code können wir schwer helfen.

 

[rellik]

Das ist viel Code ich zeige nur die neueste was ich gemacht hab.

import android.app.Application;
import android.content.pm.ApplicationInfo;

import com.example.km4l.model.DoublyLinkedList;
import com.example.km4l.model.Fitnessgeraete;
import com.example.km4l.model.Muskelgruppe;
import com.example.km4l.model.Trainingseinheit;
import com.example.km4l.model.Trainingsprogramm;

public class TrainingApp extends Application {

    String moeglicheuebungen []= {"Bankdruecken", "Rudern", "Kniebeuge", "Beinpresse"};

    Muskelgruppe beine = new Muskelgruppe("beinmuskeln", "bizeps", "trizeps");
    Muskelgruppe ruecken = new Muskelgruppe("Rueckenmuskeln", "Rhomboid major", "Rhomboid minor", "Trapez-Muskel"); //liveaufgabe 111


    Fitnessgeraete cardio = new Fitnessgeraete("Cardio", "fitness", beine, 100, 200, true, moeglicheuebungen);
    Fitnessgeraete ruder = new Fitnessgeraete("Ruder", "maschine", beine, 30, 200, true, moeglicheuebungen);
    Fitnessgeraete rueckentrainer = new Fitnessgeraete("ruder", "maschine", ruecken, 30, 950, true, moeglicheuebungen); //liveaufgabe 111


    //Trainingseinheiten
    Trainingseinheit g2 = new Trainingseinheit("g2", 20,ruder);
    Trainingseinheit g23 = new Trainingseinheit("g23", 20,ruder);
    Trainingseinheit ganzkoerper = new Trainingseinheit("gk", 20, ruder);


    Trainingsprogramm tp1 = new Trainingsprogramm();


    DoublyLinkedList dl = new DoublyLinkedList();

    dl.add(); //Das wird rot angezeigt das add :(
}

 

[deek]

Kannst du noch den Code von deiner DoublyLinkedList zeigen? Das ist keine Standard Struktur.

 

[rellik]

Das ist meine doublylinkedlist, bei IntelliJ hat alles wunderbar geklappt.

import java.util.Iterator;
import java.util.NoSuchElementException;

public class DoublyLinkedList  {

    private Node currentNode;
    private static int size;

    public void add (Trainingseinheit e){
        if (isEmpty()) {

            Node training = new Node(null, null, e);
            training.next = training;
            training.prev =  training;
            currentNode = training ;
            System.out.println("Ein Knoten "+ e);
            size++;
        }else {
            Node newNode = new Node(currentNode.next, currentNode, e);
            currentNode.next.prev = newNode;
            currentNode.next = newNode;
            System.out.println("Mehrere Knoten "+e);
            size++;
        }
    }

    public Trainingseinheit getCurrent() {
        if (isEmpty())  throw new NoSuchElementException();
        else {
        return currentNode.training;}
    }

    public Trainingseinheit next(){
        if (isEmpty()) throw new NoSuchElementException();
        else {
        currentNode = currentNode.next;
        return currentNode.training;}
    }

    public Trainingseinheit prev (){
        currentNode = currentNode.prev;
        return currentNode.training;
    }

    /*liefert eine Trainingseinheit aus der verketteten
Liste zurück. offset gibt an, wie viele Stellen hinter dem aktuellen Knoten sich das Element
befindet. Beispiele: get(0) liefert die Trainingseinheit des aktuellen Knotens. get(1) liefert die
Trainingseinheit des darauffolgenden Knotens. get(2) liefert die Trainingseinheit dahinter usw.
Der Offset kann beliebig groß sein, da das „letzte“ Element ja wieder auf das „erste“ Element
verweist. */
    public Trainingseinheit get (int offset){
        Node runPointer = currentNode;
        for (int i = 0; i < offset; i++){

           runPointer = runPointer.next;
        }
        return runPointer.training;
    }

   public int size (){
        return size;
    }


    public boolean isEmpty (){
        return currentNode == null;
    }

    public Trainingseinheit find (Fitnessgeraete f) {


        for (int i = 0; i < size(); i++) {


            if (get(i).getFitnessgeraete().equals(f)) {
                return currentNode.getTraining();

            } else throw new NoSuchElementException();

        }
        return currentNode.getTraining();
    }

    Iterator <Trainingseinheit> iterator(){
        return new Iterator<Trainingseinheit>() {

            @Override
            public boolean hasNext() {
                return currentNode != null;
            }

            @Override
            public Trainingseinheit next() {
                if(currentNode == null) throw new NoSuchElementException();

                currentNode = currentNode.next;

                return currentNode.training;
            }
        };
    }

    public class Node {

        private Node next, prev;
        private Trainingseinheit training;

        public Node(Node next, Node prev, Trainingseinheit training) {
            this.next = next;
            this.prev = prev;
            this.training = training;
        }



        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }

        public Node getPrev() {
            return prev;
        }

        public void setPrev(Node prev) {
            this.prev = prev;
        }

        public Trainingseinheit getTraining() {
            return training;
        }

        public void setTraining(Trainingseinheit training) {
            this.training = training;
        }
    }

}

 

[jogimuc]

Ich verstehe nicht was du willst.
Übrigens ist "String moeglicheuebungen []=" keine Arryliste sondern ein "String Array"
In Java gibt es Array und Listen.

Zeige mal die Klasse DoublyLinkedList();
Das was du erstellst ist eine Instanz einer klasse keine Liste

ArrayList<String> liste = new ArrayList<>(); wäre ein übliche Definition einer Liste
Auf die du mit den üblichen add Methoden zugreifen kannst.

-- Dieser Beitrag wurde automatisch mit dem folgenden Beitrag zusammengeführt --

Unsere post haben sich überschritten

-- Dieser Beitrag wurde automatisch mit dem folgenden Beitrag zusammengeführt --

Ohne jetzt den Code im einzelnen durchgehende sein wo ist dein Problem.

 

[rellik]

will meine arrayliste füllen die ich habe .

 

[jogimuc]

Also die Methode add in der Klasse verlangt einen Übergabe wert.
public void add (Trainingseinheit e){

-- Dieser Beitrag wurde automatisch mit dem folgenden Beitrag zusammengeführt --

Was soll deine arryliste sein ich sehe keine.

 

[rellik]

ja genau sorry aber es geht wirklich auch mit übergabe wert nicht . muss man vielleicht OnCreate schreiben um die DoublyLinkedList oder ArrayList zu füllen

 

[jogimuc]

Warum das add rot wird habe ich dir schon geschrieben es fehlt der Übergabe wert.
Eine Array Liste erkennt man an den spitzen klammen du hast keine Liste.

-- Dieser Beitrag wurde automatisch mit dem folgenden Beitrag zusammengeführt --

So nochmal mit DoublyLinkedList dl = new DoublyLinkedList(); erstellst du eine Instanz von der klasse keine Liste.
Mit dl.add() rufst du die add Methode in der klasse auf. Das hat nichts mit der add Methode die du auf eine Liste anwenden kannst zu tun , um ein Element einer Liste hinzuzufügen.
Wie gesagt hast du keine Liste. Im Sinne von Java

-- Dieser Beitrag wurde automatisch mit dem folgenden Beitrag zusammengeführt --

Ok habe deinen Code jetzt etwas verstanden .Du erstellst selber eine verkettete Liste

Du hast somit die Funktionalität von einer Java Liste <> selber nach gebaut. richtig?

Weil Du von einer Array Liste sprichst und keine hast sondern eine selbst erstellte verkettete Liste.
Kam es etwas zu einem Missverständnis.
ArrayList ist eine Java Klasse die die Funktionalität einer Liste zur Verfügung stellt. Dies benutzt du aber gar nicht. Somit hast du keine Array Liste. Du hast eine selber erstellte klasse die eine Liste darstellt.

So was genau geht jetzt nicht?

Frage hast Du das selber geschrieben?

 

[jogimuc]

Also das hier kann nicht richtig sein.

}else {
Node newNode = new Node(currentNode.next, currentNode, e);
currentNode.next.prev = newNode;
currentNode.next = newNode;
System.out.println("Mehrere Knoten "+e);
size++;

Beim erstellen eines neuen Element übergibt du den Verweis auf das nexte und das vorhergehende listen Element. Das nexte hast du noch nicht ,das vorhergehende ist das aktuelle.

currentNode.next.prev gibt es nicht. Und wenn kann Next und Prev nicht gleich sein.
Das neue nun aktuelle Element merkst du dir auch nicht.
Wie soll das eine Liste werden?

Versuche es so. Denn Rest des Codes habe ich nicht großartig analysiert. Kann also auch noch Fehler enthalten.
Wenn ja melde dich.

}else {
Node newNode = new Node(nulll, currentNode, e);
currentNode.next = newNode;
currentNode = newNode;
System.out.println("Mehrere Knoten "+e);
size++;

Das next wird immer erst gesetzt wenn ein neues Element eingefügt wird .du weist es ja noch nicht zu dem Zeitpunkt. Das prev ist das vorhergehende was du in currentNote speicherst.
So müsste die Liste funktionieren. Deine Variante kann nie gehen.

Bemerken möchte ich noch das es für deine suchmethoden sinnvoll ist sich den Anfang der Liste zu merken und nicht nur die aktuelle Position.
Sonnst mussst du dich erst zum Anfang der Liste durchhalten um deine Liste zu durchsuchen.

 

[deek]

Also das hier kann nicht richtig sein.

}else {
Node newNode = new Node(currentNode.next, currentNode, e);
currentNode.next.prev = newNode;
currentNode.next = newNode;
System.out.println("Mehrere Knoten "+e);
size++;

Beim erstellen eines neuen Element übergibt du den Verweis auf das nexte und das vorhergehende listen Element. Das nexte hast du noch nicht ,das vorhergehende ist das aktuelle.

Doch das sieht meiner Meinung nach gut aus. Der erste Node bekommt next und prev auf sich selbst. D.h. next und prev sind schonmal nie null.
Wenn ich jetzt einen Node einfüge nach dem currentNode muss das prev vom momentan nachfolger (=currentnode.next) auf den neuen Node gesetzt werden und danach das next von currentNode ebenfalls auf den neuen Node. Der newNode bekommt im ctor schon die korrekten Vorgänger und Nachfolgerbeziehungen übergeben.

 

[rellik]

richtig ich habe selbst eine arraylist erstellt und ja hab ich selbst geschrieben in intelliJ klappt das.

Ich weiss nicht wie ich es fragen soll.

Das mit den code klappt alles in intellij und jetzt hab ich es in android studio importiert hat auch alles funktioniert.

Was ich nicht verstehe wieso ich von der Klasse DoublyLinkedList keine methoden aufrufen kann. Er will immer eigene Methoden schreiben.

 

[jogimuc]

Wo und wie willst du eine Methode aufrufen zeige mal.

Frage mich auch warum du vom Application erbst und nicht von einer Activity, AppCompatActivity.
Somit ist eigentlich klar warum du nicht in deiner activity darauf zugreifen kannst.
Wenn du die variable nicht in deiner activity global erstellst.
Sondern in einer anderen Klasse.
Die activity ist sozusagen deine ausführende klasse.

 

[rellik]

import android.app.Application;
import android.content.pm.ApplicationInfo;

import com.example.km4l.model.DoublyLinkedList;
import com.example.km4l.model.Fitnessgeraete;
import com.example.km4l.model.Muskelgruppe;
import com.example.km4l.model.Trainingseinheit;
import com.example.km4l.model.Trainingsprogramm;

public class TrainingApp extends Application {

    String moeglicheuebungen []= {"Bankdruecken", "Rudern", "Kniebeuge", "Beinpresse"};

    Muskelgruppe beine = new Muskelgruppe("beinmuskeln", "bizeps", "trizeps");
    Muskelgruppe ruecken = new Muskelgruppe("Rueckenmuskeln", "Rhomboid major", "Rhomboid minor", "Trapez-Muskel"); //liveaufgabe 111


    Fitnessgeraete cardio = new Fitnessgeraete("Cardio", "fitness", beine, 100, 200, true, moeglicheuebungen);
    Fitnessgeraete ruder = new Fitnessgeraete("Ruder", "maschine", beine, 30, 200, true, moeglicheuebungen);
    Fitnessgeraete rueckentrainer = new Fitnessgeraete("ruder", "maschine", ruecken, 30, 950, true, moeglicheuebungen); //liveaufgabe 111


    //Trainingseinheiten
    Trainingseinheit g2 = new Trainingseinheit("Zuende", 20,ruder);
    Trainingseinheit g23 = new Trainingseinheit("Anfang", 20,ruder);
    Trainingseinheit ganzkoerper = new Trainingseinheit("Kiloweise", 20, ruder);


    Trainingsprogramm tp1 = new Trainingsprogramm();


    private DoublyLinkedList dl = new DoublyLinkedList();




}

dann will ich dl.add(g2); machen aber da steht cannot resolve symbol add

 

[jogimuc]

Wieso erbst du von Applikation und nicht von activity oder appcompacktactivity?
Wo ist deine activity?

 

[deek]

Ah, das sehe ich jetzt erst!
Du machst das alles direkt in deinem Klassenblock. Da kannst du zwar Variablen anlegen. (Das sind dann Felder, die in der kompletten Klasse sichtbar sind) Aber du kannst da keine Statements hinmachen. Das macht keinen Sinn.
Das musst du in einer Methode machen. Bei Activities oder der Application (auch wenn es wohl keinen Sinn macht, es in der Application zu machen, wie jogimuc richtig angemerkt hat) wahrscheinlich in der onCreate. Dort kannst du andere Methoden aufrufen. Der Main Block einer Klasse ist reserviert für Deklarationen, entweder von Methoden, inneren Klassen oder eben Feldern.

Btw: Du hast keine ArrayList gebaut. Du hast eine doppelt verkettete Liste gebaut. Das sind beides Listen, aber mit vollkommen verschiedenem Unterbau und verschiedenen Komplexitäten der verschiedenen Operationen.

 

[jogimuc]

Der Main block ist in Android nicht zu verwenden. Schaue dir den lifecycle von Android an.
Im Klassen Rumpf globale variablen Definitionen. In der oncreade werden sie dann initialisiert.
Auf eingaben wird in den listner Methoden reagiert. Dort läuft sozusagen das Programm.
Eine main wie bei Java gibt es nicht.
Im livecycle siehst du welche Callback Methoden nacheinander aufgerufen werden.
Die Klasse Applikation macht eigentlich in Android keinen sinn mir fällt da keiner ein.

Understand the Activity Lifecycle  |  Android Developers

 

[deek]

ich meine mit main Block nicht die main Method, sondern den Klassenblock, sorry für die confusion.

public class Foo {
    // hier ist für mich der "main" block, also der Hauptblock dieser Klasse

    public void bar() {
        // das hier ist ein Methodenblock
    }
}

Btw: ich benutze fast immer eine custom Application class. Macht oft sehr wohl Sinn bei komplexeren Apps, aber das ist hier nicht das Thema.

 

[jogimuc]

Genau das habe ich erklärt.
Ok ich meinte die Main Methode sollte klar gewesen sein wen ich sonst von Klassen Rumpf spreche.