I was using a self implemented Linked List on processing and that error just happened:

posX cannot be resolved or is not a field

Here’s my code:

Main Class:

List<Garbage> GarbageList = new List<>();

void removeGarbage(int x,int y){
  if(GarbageList.head.data.posX==x && GarbageList.head.data.posY==y){
    GarbageList.head = GarbageList.head.head;
  } else{
    Node end = GarbageList.head;
      while (end.next != null) {
        if(end.next.data.posX==x && end.next.data.posY==y){
          if(end.next.next =! null){
            end.next = end.next.next;
          } else{
            end.next = null;
          }
        }
        end = end.next;
      }
  }
}

Garbage Class:

class Garbage{
  
  int type;
  int value;
  int posX, posY;
  PImage sprite;

/methods
.
.
.
  
}

Node Class:

class Node<T> {
  T data;
  Node next;

  Node(T data) {
    this.data = data;
    this.next = null;
  }
}

List Class:

class List<T> {
  Node<T> head;

  void add(T data) {
    Node<T> newNode = new Node<T>(data);
    if (head == null) {
      head = newNode;
    } else {
      Node end = head;
      while (end.next != null) {
        end = end.next;
      }
      end.next = newNode;
    }
  }

}

I was trying to create a function to remove a Garbage based on its X and Y position for a future implementation but it happened to not work

I am just flooding that in the end, cause the stack overflow asks me to add some more details since my post is mostly code

FLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOODFLOOD