Java pass by reference with listNode issue

I have a class:

class ListNode {
     int val;
     ListNode next;
     ListNode(int x) { val = x; }
}

And the function to print the LinkedList is :

public static void printLinkedNode(ListNode l){
        while(l != null){
            System.out.print(l.val+" ");
            l = l.next;
        }
        System.out.println(" ");
    }

In my main function, I create a ListNode called test:

ListNode test = new ListNode(1);
head.next = new ListNode(2);
head.next.next = new ListNode(3);
head.next.next.next = new ListNode(4);

If I do A:

ListNode fast = head, slow = head;
fast = fast.next.next;
printLinkedNode(head); // I get 1->2->3->4

If I do B:

ListNode fast = head, slow = head;
fast.next = fast.next.next;
printLinkedNode(head); // I get 1->3->4

I am confused at why in A, the head is 1->2->3->4, but not 3->4? I have read some posts about Is Java “pass-by-reference” or “pass-by-value”?, but still can't figure it out..

If I do C:

            ListNode fast = head, slow = head;
            fast = fast.next.next;
            printLinkedNode(fast);   //3->4
            printLinkedNode(head);   //1->2->3->4
            fast.next = new ListNode(5);
            printLinkedNode(fast);   //3->5
            printLinkedNode(head);   //1->2->3->5, why the head will change?

I am confused at why the head will change when we do fast.next = new ListNode(5); I think fast is not assign with head?

Solution

When you assign a variable, you make it point (reference) to a specific object. When you reassign it, you make it point (reference) to another object, you don't overwrite the reference value it is holding:

ListNode fast = head, slow = head; // fast has a reference to head.
fast = fast.next.next;             // fast has a reference to fast.next.next. You are not overwriting head, just fast.
printLinkedNode(head); // I get 1->2->3->4

Instead, if you edit something inside a referenced object, you'll edit the original object:

ListNode fast = head, slow = head; // fast has a reference to head
fast.next = fast.next.next;        // by editing fast.next, you edit head.next
printLinkedNode(head); // I get 1->3->4

Update for usecase C:

ListNode fast = head, slow = head; // fast = head = (1)
fast = fast.next.next;             // fast = fast.next.next = (3). head is still (1)
printLinkedNode(fast);             // 3->4 -> because fast points to head.next.next (3)
printLinkedNode(head);             // 1->2->3->4 -> head wasn't modified by any of the previous instructions

// here fast points to head.next.next. So fast.next is the same as head.next.next.next (4).
fast.next = new ListNode(5);       // Overwrites fast.next, it was (4), becomes (5)
printLinkedNode(fast);             // 3->5
printLinkedNode(head);             // 1->2->3->5

To make it easier to understand:

Let's say we have objects a, b and c of type ListNode:

ListNode a = new ListNode(1);
ListNode b = new ListNode(2);
ListNode c = new ListNode(3);

ListNode d = a; // variable d now points to object a
d.next = b;     // since d points to a, this statement modifies a.next
d = c           // This does *not* modify a. It just makes d point to c.