Java 具有innere类QueueNode的LinkedList队列推送方法

我需要编写一个Java程序（类LinkedList Queue），该程序可以在不使用导入列表的情况下完成所有工作，我已经尝试过了，但无法创建推送方法，我需要帮助

有人能帮我吗？ 您可以在我的github帐户中找到我的所有类：

这是我的班级：

package main.java.a4;
//First In First Out
public class Queue<K> {

    QueueNode first;
    QueueNode last;
    private int size = 0;

    //-------------------Innere Klasse------------------------------
        private class QueueNode {
            K data;
            QueueNode next;
            public QueueNode(K data, QueueNode next) {
                this.data = data;
                this.next = next;
            }

            public void setData() {
                this.data = data;
            }

            public void setNext() {
                this.next = next;
            }
        }
    //-------------------Innere Klasse------------------------------


    //(Methode zum Einfügen eines Elements in die Queue)
    public void push(K element) {
        if(element == null) {
            throw new NullPointerException("Element was null!");
        }
        if(first == null) {
            //here
        } else {
            //and here
        }
    } 

    //(Methode zum herausnehmen eines Elements aus der Warteschlange)
    public K pull() {
        if (first == null) {
            throw new NullPointerException("Queue was empty!");
        } else {
            QueueNode temp = first;
            first = first.next;
            if(size == 1) {
                last = null;
            }
            size--;
            return temp.data;
        }
    } 

//(Gibt die Anzahl der in der Liste gespeicherten Elemente zurück)
public int size() {
    return size;
} 

public String toString() {
    QueueNode temp = first;
    StringBuilder sb = new StringBuilder();
    while (temp != null) {
        sb.append("<" + temp.data + ">");
        temp = temp.next;
    }
    return sb.toString();
}

public boolean isEmpty() {
    if(first == null) {
        return true;
    } else {
        return false;
    }
}

package main.java.a4；
//先进先出
公共类队列{
排队节点优先；
排队节点最后；
私有整数大小=0；
//-------------------内尔克拉斯------------------------------
私有类队列节点{
K数据；
排队节点下一步；
公共QueueNode（K数据，QueueNode下一个）{
这个数据=数据；
this.next=next；
}
public void setData（）{
这个数据=数据；
}
公共无效setNext（）{
this.next=next；
}
}
//-------------------内尔克拉斯------------------------------
//（模具队列中的Methode zum Einfügen eines元素）
公共无效推送（K元素）{
if（元素==null）{
抛出新的NullPointerException（“元素为null！”）；
}
if（first==null）{
//这里
}否则{
//这里呢
}
} 
//（方法：根据瓦特范围内的元素）
公共K pull（）{
if（first==null）{
抛出新的NullPointerException（“队列为空！”）；
}否则{
QueueNode temp=第一；
first=first.next；
如果（大小==1）{
last=null；
}
大小--；
返回温度数据；
}
} 
//（这是祖鲁克元素的一部分）
公共整数大小（）{
返回大小；
} 
公共字符串toString（）{
QueueNode temp=第一；
StringBuilder sb=新的StringBuilder（）；
while（temp！=null）{
某人加上（“”）；
温度=下一个温度；
}
使某人返回字符串（）；
}
公共布尔值为空（）{
if（first==null）{
返回true；
}否则{
返回false；
}
}

}

这是我的测试级J-Unit：

package test.java.a4;


import main.java.a4.Account;
import main.java.a4.AccountDetails;
import main.java.a4.Euro;
import main.java.a4.Queue;
import main.java.a4.Transaction;
import org.junit.Before;
import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class QueueTest {

    private Queue<Transaction> transactions;
    private Transaction transaction1;
    private Transaction transaction2;
    private Transaction transaction3;

    //Method is called before every test method.
    @Before
    public void setUp() {
        this.transactions = new Queue<>();
        Account<Euro> acc1 = new Account<>(new AccountDetails("10001", "Bank1"), 20000d, 50000d, new Euro(1, "EUR"), 123);
        this.transaction1 = new Transaction(acc1, "10002", 20000);
        Account<Euro> acc2 = new Account<>(new AccountDetails("10002", "Bank1"), 20000d, 50000d, new Euro(1, "EUR"), 123);
        this.transaction2 = new Transaction(acc2, "10001", 30000);
        Account<Euro> acc3 = new Account<>(new AccountDetails("10004", "Bank1"), 20000d, 50000d, new Euro(1, "EUR"), 123);
        this.transaction3 = new Transaction(acc3, "10006", 50000);
    }

    //try to push null
    @Test(expected = NullPointerException.class)
    public void testPushNullElement() {
        this.transactions.push(null);
    }

    //test if the queue is empty
    @Test
    public void testQueueIsEmpty() {
        assertEquals(true, transactions.isEmpty());
    }

    //test if the size is zero when the queue is empty
    @Test
    public void testQueueSizeZero() {
        assertEquals(0, transactions.size());
    }

    //try to push one element
    @Test
    public void testPushFirstElement() {
        transactions.push(transaction1);
        assertEquals("<10002>", transactions.toString());
    }

    //test if the size is one after an element was pushed
    @Test
    public void testQueueSizeOne() {
        transactions.push(transaction1);
        assertEquals(1, transactions.size());
    }

    //try to push two elements
    @Test
    public void testPushSecondElement() {
        transactions.push(transaction1);
        this.transactions.push(transaction2);
        assertEquals("<10002><10001>", this.transactions.toString());
    }

    //test if the size is two after two elements were pushed
    @Test
    public void testQueueSizeTwo() {
        transactions.push(transaction1);
        transactions.push(transaction2);
        assertEquals(2, transactions.size());
    }

    //try to push three elements
    @Test
    public void testPushThirdElement() {
        transactions.push(transaction1);
        transactions.push(transaction2);
        transactions.push(transaction3);
        assertEquals("<10002><10001><10006>", this.transactions.toString());
    }

    //test if the size is three after three elements were pushed
    @Test
    public void testQueueSizeThree() {
        transactions.push(transaction1);
        transactions.push(transaction2);
        transactions.push(transaction3);
        assertEquals(3, transactions.size());
    }

    //add three elements and try to pull the first one
    @Test
    public void testQueuePullFirstTransaction() {
        transactions.push(transaction1);
        transactions.push(transaction2);
        transactions.push(transaction3);
        assertEquals(transaction1.getTargetIban(), transactions.pull().getTargetIban());
    }

    //add two elements and try to pull the first one
    @Test
    public void testQueuePullSecondTransaction() {
        transactions.push(transaction2);
        transactions.push(transaction3);
        assertEquals(transaction2.getTargetIban(), transactions.pull().getTargetIban());
    }

    //add one element and try to pull it
    @Test
    public void testQueuePullThirdTransaction() {
        transactions.push(transaction3);
        assertEquals(transaction3.getTargetIban(), transactions.pull().getTargetIban());
    }
}

package test.java.a4；
导入main.java.a4.Account；
导入main.java.a4.AccountDetails；
导入main.java.a4.Euro；
导入main.java.a4.Queue；
导入main.java.a4.Transaction；
导入org.junit.Before；
导入org.junit.Test；
导入静态org.junit.Assert.assertEquals；
公共类排队测试{
私有队列事务；
私人交易1；
私人交易2；
私人交易3；
//方法在每个测试方法之前调用。
@以前
公共作废设置（）{
this.transactions=新队列（）；
账户acc1=新账户（新账户详情（“10001”、“银行1”）、20000d、50000d、新欧元（1，“欧元”）、123）；
this.transaction1=新交易（acc1，“10002”，20000）；
账户acc2=新账户（新账户详情（“10002”、“银行1”）、20000d、50000d、新欧元（1，“欧元”）、123）；
this.transaction2=新交易（acc2，“10001”，30000）；
账户acc3=新账户（新账户详情（“10004”、“银行1”）、20000d、50000d、新欧元（1，“欧元”）、123）；
this.transaction3=新交易（acc3，“10006”，50000）；
}
//尝试推空
@测试（预期=NullPointerException.class）
public void testPushNullElement（）{
this.transactions.push（null）；
}
//测试队列是否为空
@试验
public void testQueueIsEmpty（）{
assertEquals（true，transactions.isEmpty（））；
}
//测试队列为空时大小是否为零
@试验
public void testQueueSizeZero（）{
assertEquals（0，transactions.size（））；
}
//试着推动一个元素
@试验
public void testPushFirstElement（）{
事务。推送（事务1）；
assertEquals（“，transactions.toString（））；
}
//测试推送元素后的大小是否为1
@试验
public void testQueueSizeOne（）{
事务。推送（事务1）；
assertEquals（1，transactions.size（））；
}
//试着推动两个元素
@试验
公共void testPushSecondElement（）{
事务。推送（事务1）；
this.transactions.push（transaction2）；
assertEquals（“，this.transactions.toString（））；
}
//在推送两个元素后测试大小是否为2
@试验
public void testqueuesizewo（）{
事务。推送（事务1）；
事务。推送（事务2）；
assertEquals（2，transactions.size（））；
}
//试着推动三个要素
@试验
公共void testPushThirdElement（）{
事务。推送（事务1）；
事务。推送（事务2）；
事务。推送（事务3）；
assertEquals（“，this.transactions.toString（））；
}
//在推送三个元素后测试大小是否为三
@试验
public void testQueueSizeThree（）{
事务。推送（事务1）；
事务。推送（事务2）；
事务。推送（事务3）；
assertEquals（3，transactions.size（））；
}
//添加三个元素并尝试拉动第一个元素
@试验
public void testQueuePullFirstTransaction（）{
事务。推送（事务1）；
事务。推送（事务2）；
事务。推送（事务3）；
assertEquals（transaction1.getTargetIban（），transactions.pull（）.getTargetIban（））；
}
//添加两个元素并尝试拉动第一个元素
@试验
public void testQueuePullSecondTransaction（）{
事务。推送（事务2）；
事务。推送（事务3）；
assertEquals（transaction2.getTargetIban（），transactions.pull（）.getTargetIban（））；
}
//添加一个元素并尝试拉动它
@试验
公共无效testQueuePullThirdTransaction（）{
事务。推送（事务3）；
资产质量（tr）
public void push(K element) {
    if (element == null) {
        throw new NullPointerException("Element was null!");
    }
    QueueNode newNode = new QueueNode(element, first);
    if (first == null) {
        last = newNode;
    }
    first = newNode;
}