Hallo,
nun wir hatten im Informatikunterricht angefangen mit Listen zu arbeiten, jedoch statt die ArrayListen zu nutzen, die Java bereitstellt, mussten wir eine vorgefertigte Klasse für diese Nutzen. Hier der Code der Liste:
Wir sollten eine Liste erstellen, in der Objekte der Klasse "LED" gespeichert werden. Auf diese sollte dann später auch insofern zugegriffen werden können, dass man einen Wahrheitswert "leuchtet" auf true und false ändert. Bis dahin hat alles funktioniert.
Dann sollten wir ein Lichtergitter erzeugen. Also dass an jeder LED noch weitere LED's angehängt werden können (Also man hat eine Kette und an jeder LED von dieser kann eine weitere Kette angehangen werden). Jetzt habe ich das Problem, dass ich an einer Stelle der Liste eine weitere Liste anfügen möchte. Ich habe mir gedacht, dass ich einfach beim Erzeugen der Liste so vorgehe:
Jetzt habe ich das Problem, dass ich nicht weiß, wie man auf die einzelnen Objekte zu greifen kann. Ich dachte mir, dass es evtl mögliche wäre das Gitter Spalte für Spalte durchzugehen. Dazu habe ich mir gedacht, ich greife durch die "getContent()" Methode auf die Objekte zu.
Und hier bin ich dann hängen geblieben. Durch die Methode "leuchten" sollen alle LED's im Lichtergitter leuchten, aber ich weiß nicht genau, wie ich auf alle Objekte zugreifen kann.
Hier nochmal der gesamte Code, an dem ich arbeite:
Steuerung (Nur die Lichterkette):
Steuerung2 (Das gesamte Lichtergitter):
LED:
Die List-Klasse:
Ich hoffe ihr könnt mir helfen
Danke
Finn
nun wir hatten im Informatikunterricht angefangen mit Listen zu arbeiten, jedoch statt die ArrayListen zu nutzen, die Java bereitstellt, mussten wir eine vorgefertigte Klasse für diese Nutzen. Hier der Code der Liste:
Java:
package Lichterkette;
public class List<ContentType>
{
/* --------- Anfang der privaten inneren Klasse -------------- */
private class ListNode
{
private ContentType contentObject;
private ListNode next;
/**
* Ein neues Objekt wird erschaffen. Der Verweis ist leer.
* @param pContent das Inhaltsobjekt vom Typ ContentType
*/
private ListNode(ContentType pContent)
{
contentObject = pContent;
next = null;
}
/**
* Der Inhalt des Knotens wird zurueckgeliefert.
* @return das Inhaltsobjekt des Knotens
*/
public ContentType getContentObject()
{
return contentObject;
}
/**
* Der Inhalt dieses Kontens wird gesetzt.
* @param pContent das Inhaltsobjekt vom Typ ContentType
*/
public void setContentObject(ContentType pContent)
{
contentObject = pContent;
}
/**
* Der Nachfolgeknoten wird zurueckgeliefert.
* @return das Objekt, auf das der aktuelle Verweis zeigt
*/
public ListNode getNextNode()
{
return next;
}
/**
* Der Verweis wird auf das Objekt, das als Parameter uebergeben
* wird, gesetzt.
* @param pNext der Nachfolger des Knotens
*/
public void setNextNode(ListNode pNext)
{
next = pNext;
}
}
/* ----------- Ende der privaten inneren Klasse -------------- */
// erstes Element der Liste
ListNode first;
// letztes Element der Liste
ListNode last;
// aktuelles Element der Liste
ListNode current;
/**
* Eine leere Liste wird erzeugt.
*/
public List()
{
first = null;
last = null;
current = null;
}
/**
* Die Anfrage liefert den Wert true, wenn die Liste keine Objekte enthaelt,
* sonst liefert sie den Wert false.
* @return true, wenn die Liste leer ist, sonst false
*/
public boolean isEmpty()
{
// Die Liste ist leer, wenn es kein erstes Element gibt.
return first == null;
}
/**
* Die Anfrage liefert den Wert true, wenn es ein aktuelles Objekt gibt,
* sonst liefert sie den Wert false.
* @return true, falls Zugriff moeglich, sonst false
*/
public boolean hasAccess()
{
// Es gibt keinen Zugriff, wenn current auf kein Element verweist.
return current != null;
}
/**
* Falls die Liste nicht leer ist, es ein aktuelles Objekt gibt und dieses
* nicht das letzte Objekt der Liste ist, wird das dem aktuellen Objekt in
* der Liste folgende Objekt zum aktuellen Objekt, andernfalls gibt es nach
* Ausfuehrung des Auftrags kein aktuelles Objekt, d.h. hasAccess() liefert
* den Wert false.
*/
public void next()
{
if (hasAccess())
{
current = current.getNextNode();
}
}
/**
* Falls die Liste nicht leer ist, wird das erste Objekt der Liste aktuelles
* Objekt. Ist die Liste leer, geschieht nichts.
*/
public void toFirst()
{
if (!isEmpty())
{
current = first;
}
}
/**
* Falls die Liste nicht leer ist, wird das letzte Objekt der Liste
* aktuelles Objekt. Ist die Liste leer, geschieht nichts.
*/
public void toLast()
{
if (!isEmpty())
{
current = last;
}
}
/**
* Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
* aktuelle Objekt zurueckgegeben, andernfalls (hasAccess() == false) gibt
* die Anfrage den Wert null zurueck.
* @return das aktuelle Objekt (vom Typ ContentType) oder null, wenn es kein aktuelles Objekt gibt
*/
public ContentType getContent()
{
if (hasAccess())
{
return current.getContentObject();
}
else
{
return null;
}
}
/**
* Falls es ein aktuelles Objekt gibt (hasAccess() == true) und pContent
* ungleich null ist, wird das aktuelle Objekt durch pContent ersetzt. Sonst
* geschieht nichts.
* @param pContent das zu schreibende Objekt vom Typ ContentType
*/
public void setContent(ContentType pContent)
{
// Nichts tun, wenn es keinen Inhalt oder kein aktuelles Element gibt.
if (pContent != null && hasAccess())
{
current.setContentObject(pContent);
}
}
/**
* Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird ein neues
* Objekt vor dem aktuellen Objekt in die Liste eingefuegt. Das aktuelle
* Objekt bleibt unveraendert.
* Wenn die Liste leer ist, wird pContent in die Liste eingefuegt und es
* gibt weiterhin kein aktuelles Objekt (hasAccess() == false).
* Falls es kein aktuelles Objekt gibt (hasAccess() == false) und die Liste
* nicht leer ist oder pContent gleich null ist, geschieht nichts.
*
* @param pContent das einzufuegende Objekt vom Typ ContentType
*/
public void insert(ContentType pContent)
{
if (pContent != null)
{ // Nichts tun, wenn es keinen Inhalt gibt.
if (hasAccess()) // Fall: Es gibt ein aktuelles Element.
{
// Neuen Knoten erstellen.
ListNode newNode = new ListNode(pContent);
if (current != first)
{ // Fall: Nicht an erster Stelle einfuegen.
ListNode previous = getPrevious(current);
newNode.setNextNode(previous.getNextNode());
previous.setNextNode(newNode);
}
else
{ // Fall: An erster Stelle einfuegen.
newNode.setNextNode(first);
first = newNode;
}
}
else //Fall: Es gibt kein aktuelles Element.
{
if (isEmpty()) // Fall: In leere Liste einfuegen.
{
// Neuen Knoten erstellen.
ListNode newNode = new ListNode(pContent);
first = newNode;
last = newNode;
}
}
}
}
/**
* Falls pContent gleich null ist, geschieht nichts.
* Ansonsten wird ein neues Objekt pContent am Ende der Liste eingefuegt.
* Das aktuelle Objekt bleibt unveraendert.
* Wenn die Liste leer ist, wird das Objekt pContent in die Liste eingefuegt
* und es gibt weiterhin kein aktuelles Objekt (hasAccess() == false).
*
* @param pContent das anzuhaengende Objekt vom Typ ContentType
*/
public void append(ContentType pContent)
{
if (pContent != null)
{ // Nichts tun, wenn es keine Inhalt gibt.
if (isEmpty()) // Fall: An leere Liste anfuegen.
{
insert(pContent);
}
else // Fall: An nicht-leere Liste anfuegen.
{
// Neuen Knoten erstellen.
ListNode newNode = new ListNode(pContent);
last.setNextNode(newNode);
last = newNode; // Letzten Knoten aktualisieren.
}
}
}
/**
* Falls es sich bei der Liste und pList um dasselbe Objekt handelt,
* pList null oder eine leere Liste ist, geschieht nichts.
* Ansonsten wird die Liste pList an die aktuelle Liste angehaengt.
* Anschliessend wird pList eine leere Liste. Das aktuelle Objekt bleibt
* unveraendert. Insbesondere bleibt hasAccess identisch.
*
* @param pList die am Ende anzuhaengende Liste vom Typ List<ContentType>
*/
public void concat(List<ContentType> pList)
{
if (pList != this && pList != null && !pList.isEmpty())
{ // Nichts tun,
// wenn pList und this identisch, pList leer oder nicht existent.
if (isEmpty()) // Fall: An leere Liste anfuegen.
{
first = pList.first;
last = pList.last;
}
else // Fall: An nicht-leere Liste anfuegen.
{
last.setNextNode(pList.first);
last = pList.last;
}
// Liste pList loeschen.
pList.first = null;
pList.last = null;
pList.current = null;
}
}
/**
* Wenn die Liste leer ist oder es kein aktuelles Objekt gibt (hasAccess()
* == false), geschieht nichts.
* Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
* aktuelle Objekt geloescht und das Objekt hinter dem geloeschten Objekt
* wird zum aktuellen Objekt.
* Wird das Objekt, das am Ende der Liste steht, geloescht, gibt es kein
* aktuelles Objekt mehr.
*/
public void remove()
{
// Nichts tun, wenn es kein aktuelle Element gibt oder die Liste leer ist.
if (hasAccess() && !isEmpty())
{
if (current == first)
{
first = first.getNextNode();
}
else
{
ListNode previous = getPrevious(current);
if (current == last)
{
last = previous;
}
previous.setNextNode(current.getNextNode());
}
ListNode temp = current.getNextNode();
current.setContentObject(null);
current.setNextNode(null);
current = temp;
//Beim loeschen des letzten Elements last auf null setzen.
if (isEmpty())
{
last = null;
}
}
}
/**
* Liefert den Vorgaengerknoten des Knotens pNode. Ist die Liste leer, pNode
* == null, pNode nicht in der Liste oder pNode der erste Knoten der Liste,
* wird null zurueckgegeben.
* @param pNode der Knoten, dessen Vorgaenger zurueckgegeben werden soll
* @return der Vorgaenger des Knotens pNode oder null, falls die Liste leer ist,
* pNode == null ist, pNode nicht in der Liste ist oder pNode der erste Knoten
* der Liste ist
*/
private ListNode getPrevious(ListNode pNode)
{
if (pNode != null && pNode != first && !isEmpty())
{
ListNode temp = first;
while (temp != null && temp.getNextNode() != pNode)
{
temp = temp.getNextNode();
}
return temp;
}
else
{
return null;
}
}
}Dann sollten wir ein Lichtergitter erzeugen. Also dass an jeder LED noch weitere LED's angehängt werden können (Also man hat eine Kette und an jeder LED von dieser kann eine weitere Kette angehangen werden). Jetzt habe ich das Problem, dass ich an einer Stelle der Liste eine weitere Liste anfügen möchte. Ich habe mir gedacht, dass ich einfach beim Erzeugen der Liste so vorgehe:
Java:
private List<List<LED>> lichtergitter;
public Steuerung(){
lichtergitter = new List<List<LED>>;
}Jetzt habe ich das Problem, dass ich nicht weiß, wie man auf die einzelnen Objekte zu greifen kann. Ich dachte mir, dass es evtl mögliche wäre das Gitter Spalte für Spalte durchzugehen. Dazu habe ich mir gedacht, ich greife durch die "getContent()" Methode auf die Objekte zu.
Java:
void leuchten(){
lichtergitter.toFirst();
while(lichtergitter.hasAccess()){
lichtergitter.getContent().getContent().lichtAn();
lichtergitter.getContent().next();
}
}Hier nochmal der gesamte Code, an dem ich arbeite:
Steuerung (Nur die Lichterkette):
Java:
package Lichterkette;
public class Steuerung {
private int anzahlLEDs;
private List<LED> lichterkette;
public Steuerung(int anzahlLEDs) {
this.anzahlLEDs = anzahlLEDs;
lichterkette = new List<LED>();
}
public void leuchten01(){
lichterkette.toFirst();
while(lichterkette.hasAccess())
lichterkette.getContent().lichtAn();
}
public void leuchten02(){
int i = 0;
lichterkette.toFirst();
while(lichterkette.hasAccess()){
i++;
if(i%2==0)
lichterkette.getContent().lichtAn();
else
lichterkette.getContent().lichtAus();
}
}
public void leuchten03(){
int i = 0;
lichterkette.toFirst();
while(lichterkette.hasAccess()){
i++;
if(i%3==0)
lichterkette.getContent().lichtAn();
else
lichterkette.getContent().lichtAus();
}
}
public void lichterketteAnhaengen(List<LED> lichterkette2){
lichterkette2 = new List<LED>();
int anzahlLEDs = 0;
lichterkette2.toFirst();
while(lichterkette2.hasAccess()){
anzahlLEDs++;
lichterkette.append(lichterkette2.getContent());
lichterkette2.next();
}
this.anzahlLEDs += anzahlLEDs;
}
private int getAnzahlLEDs(){
return anzahlLEDs;
}
}Steuerung2 (Das gesamte Lichtergitter):
Java:
package Lichterkette;
public class Steuerung2 {
private int anzahlLEDs;
//private List<LED> lichtergitterx;
//private List<LED> lichtergittery;
private List<List<LED>> lichtergitter;
public Steuerung2(){
//lichtergitterx = new List<LED>();
//lichtergittery = new List<LED>();
lichtergitter = new List<List<LED>>();
}
void leuchten(){
lichtergitter.toFirst();
while(lichtergitter.hasAccess()){
lichtergitter.getContent().getContent().lichtAn();
lichtergitter.getContent().next();
}
lichtergitter.toFirst();
while(lichtergitter.hasAccess()){
lichtergitter.getContent().getContent();
}
}
void leuchten02(){
}
void lichterAnhaengen(List<LED> lichterkette){
int anzahlLEDs = 0;
lichterkette = new List<LED>();
lichterkette.toFirst();
lichtergitter.toFirst();
if(lichterkette.hasAccess()){
anzahlLEDs++;
lichtergitter.append(lichterkette);
lichtergitter.next();
lichterkette.next();
}
this.anzahlLEDs += anzahlLEDs;
}
private int getAnzahlLEDs(){
return anzahlLEDs;
}
}LED:
Java:
package Lichterkette;
public class LED {
private boolean leuchtet;
public LED() {
leuchtet = false;
}
public void lichtAn(){
leuchtet = true;
}
public void lichtAus(){
leuchtet = false;
}
}Die List-Klasse:
Java:
package Lichterkette;
public class List<ContentType>
{
/* --------- Anfang der privaten inneren Klasse -------------- */
private class ListNode
{
private ContentType contentObject;
private ListNode next;
/**
* Ein neues Objekt wird erschaffen. Der Verweis ist leer.
* @param pContent das Inhaltsobjekt vom Typ ContentType
*/
private ListNode(ContentType pContent)
{
contentObject = pContent;
next = null;
}
/**
* Der Inhalt des Knotens wird zurueckgeliefert.
* @return das Inhaltsobjekt des Knotens
*/
public ContentType getContentObject()
{
return contentObject;
}
/**
* Der Inhalt dieses Kontens wird gesetzt.
* @param pContent das Inhaltsobjekt vom Typ ContentType
*/
public void setContentObject(ContentType pContent)
{
contentObject = pContent;
}
/**
* Der Nachfolgeknoten wird zurueckgeliefert.
* @return das Objekt, auf das der aktuelle Verweis zeigt
*/
public ListNode getNextNode()
{
return next;
}
/**
* Der Verweis wird auf das Objekt, das als Parameter uebergeben
* wird, gesetzt.
* @param pNext der Nachfolger des Knotens
*/
public void setNextNode(ListNode pNext)
{
next = pNext;
}
}
/* ----------- Ende der privaten inneren Klasse -------------- */
// erstes Element der Liste
ListNode first;
// letztes Element der Liste
ListNode last;
// aktuelles Element der Liste
ListNode current;
/**
* Eine leere Liste wird erzeugt.
*/
public List()
{
first = null;
last = null;
current = null;
}
/**
* Die Anfrage liefert den Wert true, wenn die Liste keine Objekte enthaelt,
* sonst liefert sie den Wert false.
* @return true, wenn die Liste leer ist, sonst false
*/
public boolean isEmpty()
{
// Die Liste ist leer, wenn es kein erstes Element gibt.
return first == null;
}
/**
* Die Anfrage liefert den Wert true, wenn es ein aktuelles Objekt gibt,
* sonst liefert sie den Wert false.
* @return true, falls Zugriff moeglich, sonst false
*/
public boolean hasAccess()
{
// Es gibt keinen Zugriff, wenn current auf kein Element verweist.
return current != null;
}
/**
* Falls die Liste nicht leer ist, es ein aktuelles Objekt gibt und dieses
* nicht das letzte Objekt der Liste ist, wird das dem aktuellen Objekt in
* der Liste folgende Objekt zum aktuellen Objekt, andernfalls gibt es nach
* Ausfuehrung des Auftrags kein aktuelles Objekt, d.h. hasAccess() liefert
* den Wert false.
*/
public void next()
{
if (hasAccess())
{
current = current.getNextNode();
}
}
/**
* Falls die Liste nicht leer ist, wird das erste Objekt der Liste aktuelles
* Objekt. Ist die Liste leer, geschieht nichts.
*/
public void toFirst()
{
if (!isEmpty())
{
current = first;
}
}
/**
* Falls die Liste nicht leer ist, wird das letzte Objekt der Liste
* aktuelles Objekt. Ist die Liste leer, geschieht nichts.
*/
public void toLast()
{
if (!isEmpty())
{
current = last;
}
}
/**
* Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
* aktuelle Objekt zurueckgegeben, andernfalls (hasAccess() == false) gibt
* die Anfrage den Wert null zurueck.
* @return das aktuelle Objekt (vom Typ ContentType) oder null, wenn es kein aktuelles Objekt gibt
*/
public ContentType getContent()
{
if (hasAccess())
{
return current.getContentObject();
}
else
{
return null;
}
}
/**
* Falls es ein aktuelles Objekt gibt (hasAccess() == true) und pContent
* ungleich null ist, wird das aktuelle Objekt durch pContent ersetzt. Sonst
* geschieht nichts.
* @param pContent das zu schreibende Objekt vom Typ ContentType
*/
public void setContent(ContentType pContent)
{
// Nichts tun, wenn es keinen Inhalt oder kein aktuelles Element gibt.
if (pContent != null && hasAccess())
{
current.setContentObject(pContent);
}
}
/**
* Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird ein neues
* Objekt vor dem aktuellen Objekt in die Liste eingefuegt. Das aktuelle
* Objekt bleibt unveraendert.
* Wenn die Liste leer ist, wird pContent in die Liste eingefuegt und es
* gibt weiterhin kein aktuelles Objekt (hasAccess() == false).
* Falls es kein aktuelles Objekt gibt (hasAccess() == false) und die Liste
* nicht leer ist oder pContent gleich null ist, geschieht nichts.
*
* @param pContent das einzufuegende Objekt vom Typ ContentType
*/
public void insert(ContentType pContent)
{
if (pContent != null)
{ // Nichts tun, wenn es keinen Inhalt gibt.
if (hasAccess()) // Fall: Es gibt ein aktuelles Element.
{
// Neuen Knoten erstellen.
ListNode newNode = new ListNode(pContent);
if (current != first)
{ // Fall: Nicht an erster Stelle einfuegen.
ListNode previous = getPrevious(current);
newNode.setNextNode(previous.getNextNode());
previous.setNextNode(newNode);
}
else
{ // Fall: An erster Stelle einfuegen.
newNode.setNextNode(first);
first = newNode;
}
}
else //Fall: Es gibt kein aktuelles Element.
{
if (isEmpty()) // Fall: In leere Liste einfuegen.
{
// Neuen Knoten erstellen.
ListNode newNode = new ListNode(pContent);
first = newNode;
last = newNode;
}
}
}
}
/**
* Falls pContent gleich null ist, geschieht nichts.
* Ansonsten wird ein neues Objekt pContent am Ende der Liste eingefuegt.
* Das aktuelle Objekt bleibt unveraendert.
* Wenn die Liste leer ist, wird das Objekt pContent in die Liste eingefuegt
* und es gibt weiterhin kein aktuelles Objekt (hasAccess() == false).
*
* @param pContent das anzuhaengende Objekt vom Typ ContentType
*/
public void append(ContentType pContent)
{
if (pContent != null)
{ // Nichts tun, wenn es keine Inhalt gibt.
if (isEmpty()) // Fall: An leere Liste anfuegen.
{
insert(pContent);
}
else // Fall: An nicht-leere Liste anfuegen.
{
// Neuen Knoten erstellen.
ListNode newNode = new ListNode(pContent);
last.setNextNode(newNode);
last = newNode; // Letzten Knoten aktualisieren.
}
}
}
/**
* Falls es sich bei der Liste und pList um dasselbe Objekt handelt,
* pList null oder eine leere Liste ist, geschieht nichts.
* Ansonsten wird die Liste pList an die aktuelle Liste angehaengt.
* Anschliessend wird pList eine leere Liste. Das aktuelle Objekt bleibt
* unveraendert. Insbesondere bleibt hasAccess identisch.
*
* @param pList die am Ende anzuhaengende Liste vom Typ List<ContentType>
*/
public void concat(List<ContentType> pList)
{
if (pList != this && pList != null && !pList.isEmpty())
{ // Nichts tun,
// wenn pList und this identisch, pList leer oder nicht existent.
if (isEmpty()) // Fall: An leere Liste anfuegen.
{
first = pList.first;
last = pList.last;
}
else // Fall: An nicht-leere Liste anfuegen.
{
last.setNextNode(pList.first);
last = pList.last;
}
// Liste pList loeschen.
pList.first = null;
pList.last = null;
pList.current = null;
}
}
/**
* Wenn die Liste leer ist oder es kein aktuelles Objekt gibt (hasAccess()
* == false), geschieht nichts.
* Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
* aktuelle Objekt geloescht und das Objekt hinter dem geloeschten Objekt
* wird zum aktuellen Objekt.
* Wird das Objekt, das am Ende der Liste steht, geloescht, gibt es kein
* aktuelles Objekt mehr.
*/
public void remove()
{
// Nichts tun, wenn es kein aktuelle Element gibt oder die Liste leer ist.
if (hasAccess() && !isEmpty())
{
if (current == first)
{
first = first.getNextNode();
}
else
{
ListNode previous = getPrevious(current);
if (current == last)
{
last = previous;
}
previous.setNextNode(current.getNextNode());
}
ListNode temp = current.getNextNode();
current.setContentObject(null);
current.setNextNode(null);
current = temp;
//Beim loeschen des letzten Elements last auf null setzen.
if (isEmpty())
{
last = null;
}
}
}
/**
* Liefert den Vorgaengerknoten des Knotens pNode. Ist die Liste leer, pNode
* == null, pNode nicht in der Liste oder pNode der erste Knoten der Liste,
* wird null zurueckgegeben.
* @param pNode der Knoten, dessen Vorgaenger zurueckgegeben werden soll
* @return der Vorgaenger des Knotens pNode oder null, falls die Liste leer ist,
* pNode == null ist, pNode nicht in der Liste ist oder pNode der erste Knoten
* der Liste ist
*/
private ListNode getPrevious(ListNode pNode)
{
if (pNode != null && pNode != first && !isEmpty())
{
ListNode temp = first;
while (temp != null && temp.getNextNode() != pNode)
{
temp = temp.getNextNode();
}
return temp;
}
else
{
return null;
}
}
}Ich hoffe ihr könnt mir helfen
Danke
Finn
