尝试编译播放列表类时收到以下错误：
Playlist.java:164: error: cannot find symbol
head.data.play();
^
symbol: method play()
location: variable data of type Music
音乐数据类型类：
import java.net.MalformedURLException;
import java.net.URL;
import javazoom.jlgui.basicplayer.BasicPlayer;
import javazoom.jlgui.basicplayer.BasicPlayerException;
public class Music extends MediaData
{
// Data Fields
/** The name of the artist displayed */
private String artist;
/** The disk directory to a music file */
private String mediaFilePath;
/** Enables audio music to be played */
private BasicPlayer player = new BasicPlayer();
// Constructor for a music media type
public Music(String t, String a)
{
super.setTitle(t);
setArtist(a);
getPlayCount();
getMediaFilePath();
}
// mutator and accessor methods removed for space
/** Locates the media file on disk */
public String getMediaFilePath()
{
mediaFilePath = System.getProperty("user.dir") + "/Music Library/" +
getArtist() + "-" + getTitle() + ".mp3";
return mediaFilePath;
}
/** Plays a music file */
public void play()
{
try
{
player.open(new URL("file:///" + getMediaFilePath()));
player.play();
}
catch (BasicPlayerException | MalformedURLException e)
{
e.printStackTrace();
}
}
}
在驱动程序中测试时，此类中的play方法可以正常工作。但是，当我尝试从播放列表类中的播放方法访问它时，播放列表是带有音乐数据类型节点的双链接列表，我得到上面的错误：
import java.net.MalformedURLException;
import java.net.URL;
import javazoom.jlgui.basicplayer.BasicPlayer;
import javazoom.jlgui.basicplayer.BasicPlayerException;
import java.util.*;
public class Playlist<Music> extends MediaData
{
// Data fields
/** The playlist queue */
private LinkedList<Music> musicList;
/** The list head */
private Node<Music> head;
/** A Node is the building block for a single-linked list. */
private static class Node<Music>
{
// Data Fields
/** The reference to the data. */
private Music data;
/** The reference to the next node. */
private Node<Music> next;
/** The reference to the previous node. */
private Node<Music> prev;
// Constructors
/**
* Creates a new node with null next and previous fields.
* @param dataItem The data stored
*/
private Node(Music dataItem)
{
data = dataItem;
next = null;
prev = null;
}
/**
* Creates a new node that references another node.
* @param dataItem The data stored
* @param nodeRef The node referenced by new node
*/
private Node(Music dataItem, Node<Music> prevNode)
{
Node<Music> afterPrevNode = prevNode.next;
Node<Music> node = new Node(dataItem);
prevNode.next = node;
prevNode.prev = node;
node.prev = prevNode;
node.next = afterPrevNode;
}
} //end class Node
// Constructor
public Playlist(String t)
{
super.setTitle(t);
musicList = new LinkedList<Music>();
}
/**
* Adds a new node to the end of a list.
* @param head The head of the current list
* @param data The data for the new node
*/
private void add(Node<Music> head, Music data)
{
// If the list has just one element, add to it.
if (head.next == null)
{
Node<Music> node = new Node<Music>(data);
head.next = node;
node.prev = head;
}
else
{
add(head.next, data);
}
}
/**
* Wrapper method for adding a new node to the end of a list.
* @param data The data for the new node
*/
public void add(Music data)
{
if (head == null)
{
head = new Node<Music>(data);
}
else
{
add(head, data);
}
}
/**
* Wrapper method for removing a node.
* @post The first occurrence of outData is removed.
* @param outData The data to be removed
* @return true if the item is removed,
* and false otherwise
*/
public boolean remove(Music song)
{
boolean result;
if (head == null)
{
result = false;
}
else
{
result = remove(head.next, head, song);
}
return result;
}
/**
* Removes a node from a list.
* @post The first occurrence of outData is removed.
* @param head The head of the current list
* @param pred The predecessor of the list head
* @param outData The data to be removed
* @return true if the item is removed
* and false otherwise
*/
private boolean remove(Node<Music> head, Node<Music> pred, Music song)
{
boolean result;
if (head == null)
{
result = false;
}
else if (head.data.equals(song))
{
pred.next = head.next;
pred.prev = null;
head = pred;
result = true;
}
else
{
result = remove(head.next, head, song);
}
return result;
}
/** Plays a playlist
* @param head The song to be played */
private void play(Node<Music> head)
{
if (head != null)
{
head.data.play();
play(head.next);
}
}
/** Wrapper method that plays a playlist */
public void play()
{
if (head != null)
{
head.data.play();
play(head.next);
}
}
public void pause()
{
}
/**
* Finds the size of a list.
* @param head The head of the current list
* @return The Size of the Current List
*/
private int size(Node<Music> head)
{
if (head == null)
{
return 0;
}
else
{
return 1 + size(head.next);
}
}
/**
* Wrapper method for finding the size of a list.
* @return The size of the list
*/
public int size()
{
return size(head);
}
/**
* Returns the string representation of a list.
* @param head The head of the current list
* @return The state of the current list
*/
private String toString(Node<Music> head)
{
if (head == null)
{
return "";
}
else
{
return head.data + "\n" + toString(head.next);
}
}
/**
* Wrapper method for returning the string representation of a list.
* @return The string representation of the list
*/
@Override
public String toString()
{
return toString(head);
}
/**
* Checks if the list is empty
* @return true if empty, false otherwise
*/
public boolean empty()
{
boolean result = false;
if (head == null)
{
result = true;
}
return result;
}
/** Adds a node before another node.
@param prevNode The node before node
@param node The node the item will be inserted before
@param item The data stored in the node
*/
public void insertBefore(Node prevNode, Music nodeData, Music data)
{
if (prevNode.next.data == nodeData)
{
Node<Music> prevPrevNode = prevNode.prev;
Node<Music> node = new Node<Music>(data);
prevPrevNode.next = node;
prevNode.prev = node;
node.prev = prevNode.prev;
node.next = prevNode;
}
else
{
insertBefore(prevNode.next, nodeData, data);
}
}
/** Wrapper class that adds a node before another node.
@param node The node the item will be inserted before
@param item The data stored in the node
*/
public void insertBefore(Music nodeData, Music data)
{
if (nodeData == head.data)
{
addAtHead(data);
}
else
{
insertBefore(head.next, nodeData, data);
}
}
/** Adds a node after another node.
@param head The head node
@param nodeData The node the item will be inserted before
@param data The data stored in the node
*/
public void insertAfter(Node head, Music nodeData, Music data)
{
if (nodeData == head.data)
{
Node<Music> node = new Node<Music>(data);
Node<Music> afterHead = head.next;
node.next = afterHead.next;
head.next = node;
node.prev = head;
afterHead.prev = node;
}
else
{
insertAfter(head.next, nodeData, data);
}
}
/** Wrapper class that adds a node after another node.
@param nodeData The node the item will be inserted after
@param data The data stored in the node
*/
public void insertAfter(Music nodeData, Music data)
{
insertAfter(head, nodeData, data);
}
/** Adds a node to the front of the list
* @param head The front of the list
* @param Music The data added
*/
public void addAtHead(Music data)
{
if (empty())
{
head = new Node<Music>(data);
}
else
{
Node<Music> node = head;
head = new Node<Music>(data);
head.next = node;
node.prev = head;
}
}
/** Adds a node to the list
* @param head The front of the list
* @param Music The data added
*/
public void addAtEnd(Node head, Music data)
{
Node<Music> node;
if (head.next == null)
{
node = new Node<Music>(data);
head.next = node;
node.prev = head;
}
else
{
node = head.next;
addAtEnd(node, data);
}
}
/** Wrapper method to add a node to the list
* @param Music The data added
*/
public void addAtEnd(Music data)
{
if (empty())
{
head = new Node<Music>(data);
}
else
{
addAtEnd(head, data);
}
}
/**
* Return the data of the first Node
* @return The data of the first Node
*/
public Music peekFront()
{
Music m;
if (empty())
{
m = null;
}
else
{
m = head.data;
}
return m;
}
/**
* Return the data of the last Node
* @return The data of the last Node
*/
public Music peekEnd(Node<Music> head)
{
Music m;
if (head.next != null)
{
Node<Music> node = head.next;
peekEnd(node);
m = node.data;
}
else
{
m = head.data;
}
return m;
}
/**
* Wrapper method for the data of the last Node
* @return The data of the last Node
*/
public Music peekEnd()
{
Music m;
if (head == null)
{
m = null;
}
else
{
m = peekEnd(head);
}
return m;
}
/** Remove the first node from the list
@returns The data from the removed node, or null if the list is empty
*/
public Music removeFront()
{
Music m = null;
Node<Music> temp = head;
Node<Music> afterHead = head.next;
if (head != null)
{
m = temp.data;
head = head.next;
afterHead.prev = head;
}
return m;
}
/** Remove the last node from the list
* @param head The head of the current list
* @return The data from the removed node, or null if the list is empty
*/
public Music removeEnd(Node<Music> head)
{
Music m;
if (head.next != null)
{
Node<Music> node = head.next;
removeEnd(node);
m = node.data;
node.next = null;
}
else
{
m = head.data;
head = null;
}
return m;
}
/**
* Wrapper method for removing the last Node
* @return The data from the removed node, or null if the list is empty
*/
public Music removeEnd()
{
Music m;
if (head == null)
{
m = null;
}
else
{
m = removeEnd(head);
}
return m;
}
} // End of class
Music类中有一个play方法，所以我不明白为什么我会收到这个错误。此类的先前版本（其中播放列表未实现为LinkedList）没有此问题。请告知如何补救
答案 0 :(得分：0)
首先必须从LinkedList获取Music对象。
for(Music m: head.data)
{
m.play();
}
或
head.data.get(int index).play()
答案 1 :(得分：0)
这是因为在Node课程中，Music是模板类型参数而不是类名，并且与通常使用的符号T没有区别。你可能得到一个＆＃34;类型参数音乐是隐藏类型音乐＆＃34;警告那里。编译器不知道变量data的类是类Music的对象。您应该删除<Music>课程的Node。
您可以像这样编写Node类：
private static class Node
{
// Data Fields
/** The reference to the data. */
private Music data;
/** The reference to the next node. */
private Node next;
/** The reference to the previous node. */
private Node prev;
// Constructors
/**
* Creates a new node with null next and previous fields.
* @param dataItem The data stored
*/
private Node(Music dataItem)
{
data = dataItem;
next = null;
prev = null;
}
/**
* Creates a new node that references another node.
* @param dataItem The data stored
* @param nodeRef The node referenced by new node
*/
private Node(Music dataItem, Node prevNode)
{
Node afterPrevNode = prevNode.next;
Node node = new Node(dataItem);
prevNode.next = node;
prevNode.prev = node;
node.prev = prevNode;
node.next = afterPrevNode;
}
}