added useful files
This commit is contained in:
Tim
260
02 baum/BinarySearchTree.java
Normal file
260
02 baum/BinarySearchTree.java
Normal file
@@ -0,0 +1,260 @@
|
||||
/**
|
||||
* <p>
|
||||
* Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
|
||||
* </p>
|
||||
* <p>
|
||||
* Generische Klasse BinarySearchTree<ContentType>
|
||||
* </p>
|
||||
* <p>
|
||||
* Mithilfe der generischen Klasse BinarySearchTree koennen beliebig viele
|
||||
* Objekte in einem Binaerbaum (binaerer Suchbaum) entsprechend einer
|
||||
* Ordnungsrelation verwaltet werden. <br />
|
||||
* Ein Objekt der Klasse stellt entweder einen leeren binaeren Suchbaum dar oder
|
||||
* verwaltet ein Inhaltsobjekt sowie einen linken und einen rechten Teilbaum,
|
||||
* die ebenfalls Objekte der Klasse BinarySearchTree sind.<br />
|
||||
* Die Klasse der Objekte, die in dem Suchbaum verwaltet werden sollen, muss
|
||||
* das generische Interface ComparableContent implementieren. Dabei muss durch
|
||||
* Ueberschreiben der drei Vergleichsmethoden isLess, isEqual, isGreater (s.
|
||||
* Dokumentation des Interfaces) eine eindeutige Ordnungsrelation festgelegt
|
||||
* sein. <br />
|
||||
* Alle Objekte im linken Teilbaum sind kleiner als das Inhaltsobjekt des
|
||||
* binaeren Suchbaums. Alle Objekte im rechten Teilbaum sind groesser als das
|
||||
* Inhaltsobjekt des binaeren Suchbaums. Diese Bedingung gilt (rekursiv) auch in
|
||||
* beiden Teilbaeumen. <br />
|
||||
* Hinweis: In dieser Version wird die Klasse BinaryTree nicht benutzt.
|
||||
* </p>
|
||||
*
|
||||
* @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
|
||||
* @version Generisch_03 2017-11-28
|
||||
*/
|
||||
public class BinarySearchTree<ContentType extends ComparableContent<ContentType>> {
|
||||
|
||||
/* --------- Anfang der privaten inneren Klasse -------------- */
|
||||
|
||||
/**
|
||||
* Durch diese innere Klasse kann man dafuer sorgen, dass ein leerer Baum
|
||||
* null ist, ein nicht-leerer Baum jedoch immer eine nicht-null-Wurzel sowie
|
||||
* nicht-null-Teilbaeume hat.
|
||||
*/
|
||||
private class BSTNode<CT extends ComparableContent<CT>> {
|
||||
|
||||
private CT content;
|
||||
private BinarySearchTree<CT> left, right;
|
||||
|
||||
public BSTNode(CT pContent) {
|
||||
// Der Knoten hat einen linken und rechten Teilbaum, die
|
||||
// beide von null verschieden sind. Also hat ein Blatt immer zwei
|
||||
// leere Teilbaeume unter sich.
|
||||
this.content = pContent;
|
||||
left = new BinarySearchTree<CT>();
|
||||
right = new BinarySearchTree<CT>();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* ----------- Ende der privaten inneren Klasse -------------- */
|
||||
|
||||
private BSTNode<ContentType> node;
|
||||
|
||||
/**
|
||||
* Der Konstruktor erzeugt einen leeren Suchbaum.
|
||||
*/
|
||||
public BinarySearchTree() {
|
||||
this.node = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den Wahrheitswert true, wenn der Suchbaum leer ist,
|
||||
* sonst liefert sie den Wert false.
|
||||
*
|
||||
* @return true, wenn der binaere Suchbaum leer ist, sonst false
|
||||
*
|
||||
*/
|
||||
public boolean isEmpty() {
|
||||
return this.node == null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Falls der Parameter null ist, geschieht nichts.<br />
|
||||
* Falls ein bezueglich der verwendeten Vergleichsmethode isEqual mit
|
||||
* pContent uebereinstimmendes Objekt im geordneten binaeren Suchbau
|
||||
* enthalten ist, passiert nichts. <br />
|
||||
* Achtung: hier wird davon ausgegangen, dass isEqual genau dann true
|
||||
* liefert, wenn isLess und isGreater false liefern. <br />
|
||||
* Andernfalls (isLess oder isGreater) wird das Objekt pContent entsprechend
|
||||
* der vorgegebenen Ordnungsrelation in den BinarySearchTree eingeordnet.
|
||||
*
|
||||
* @param pContent
|
||||
* einzufuegendes Objekt vom Typ ContentType
|
||||
*
|
||||
*/
|
||||
public void insert(ContentType pContent) {
|
||||
if (pContent != null) {
|
||||
if (isEmpty()) {
|
||||
this.node = new BSTNode<ContentType>(pContent);
|
||||
} else if (pContent.isLess(this.node.content)) {
|
||||
this.node.left.insert(pContent);
|
||||
} else if(pContent.isGreater(this.node.content)) {
|
||||
this.node.right.insert(pContent);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den linken Teilbaum des binaeren Suchbaumes. <br />
|
||||
* Wenn er leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return den linken Teilbaum (Objekt vom Typ BinarySearchTree<ContentType>)
|
||||
* bzw. null, wenn der Suchbaum leer ist
|
||||
*
|
||||
*/
|
||||
public BinarySearchTree<ContentType> getLeftTree() {
|
||||
if (this.isEmpty()) {
|
||||
return null;
|
||||
} else {
|
||||
return this.node.left;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert das Inhaltsobjekt des Suchbaumes. Wenn der Suchbaum
|
||||
* leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return das Inhaltsobjekt vom Typ ContentType bzw. null, wenn der aktuelle
|
||||
* Suchbaum leer ist
|
||||
*
|
||||
*/
|
||||
public ContentType getContent() {
|
||||
if (this.isEmpty()) {
|
||||
return null;
|
||||
} else {
|
||||
return this.node.content;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den rechten Teilbaum des binaeren Suchbaumes. <br />
|
||||
* Wenn er leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return den rechten Teilbaum (Objekt vom Typ BinarySearchTree<ContentType>)
|
||||
* bzw. null, wenn der aktuelle Suchbaum leer ist
|
||||
*
|
||||
*/
|
||||
public BinarySearchTree<ContentType> getRightTree() {
|
||||
if (this.isEmpty()) {
|
||||
return null;
|
||||
} else {
|
||||
return this.node.right;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Falls ein bezueglich der verwendeten Vergleichsmethode mit
|
||||
* pContent uebereinstimmendes Objekt im binaeren Suchbaum enthalten
|
||||
* ist, wird dieses entfernt. Falls der Parameter null ist, aendert sich
|
||||
* nichts.
|
||||
*
|
||||
* @param pContent
|
||||
* zu entfernendes Objekt vom Typ ContentType
|
||||
*
|
||||
*/
|
||||
public void remove(ContentType pContent) {
|
||||
if (isEmpty() || pContent == null ) {
|
||||
// Abbrechen, da kein Element zum entfernen vorhanden ist.
|
||||
return;
|
||||
}
|
||||
|
||||
if (pContent.isLess(node.content)) {
|
||||
// Element ist im linken Teilbaum zu loeschen.
|
||||
node.left.remove(pContent);
|
||||
} else if (pContent.isGreater(node.content)) {
|
||||
// Element ist im rechten Teilbaum zu loeschen.
|
||||
node.right.remove(pContent);
|
||||
} else {
|
||||
// Element ist gefunden.
|
||||
if (node.left.isEmpty()) {
|
||||
if (node.right.isEmpty()) {
|
||||
// Es gibt keinen Nachfolger.
|
||||
node = null;
|
||||
} else {
|
||||
// Es gibt nur rechts einen Nachfolger.
|
||||
node = getNodeOfRightSuccessor();
|
||||
}
|
||||
} else if (node.right.isEmpty()) {
|
||||
// Es gibt nur links einen Nachfolger.
|
||||
node = getNodeOfLeftSuccessor();
|
||||
} else {
|
||||
// Es gibt links und rechts einen Nachfolger.
|
||||
if (getNodeOfRightSuccessor().left.isEmpty()) {
|
||||
// Der rechte Nachfolger hat keinen linken Nachfolger.
|
||||
node.content = getNodeOfRightSuccessor().content;
|
||||
node.right = getNodeOfRightSuccessor().right;
|
||||
} else {
|
||||
BinarySearchTree<ContentType> previous = node.right
|
||||
.ancestorOfSmallRight();
|
||||
BinarySearchTree<ContentType> smallest = previous.node.left;
|
||||
this.node.content = smallest.node.content;
|
||||
previous.remove(smallest.node.content);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Falls ein bezueglich der verwendeten Vergleichsmethode isEqual mit
|
||||
* pContent uebereinstimmendes Objekt im binaeren Suchbaum enthalten ist,
|
||||
* liefert die Anfrage dieses, ansonsten wird null zurueckgegeben. <br />
|
||||
* Falls der Parameter null ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @param pContent
|
||||
* zu suchendes Objekt vom Typ ContentType
|
||||
* @return das gefundene Objekt vom Typ ContentType, bei erfolgloser Suche null
|
||||
*
|
||||
*/
|
||||
public ContentType search(ContentType pContent) {
|
||||
if (this.isEmpty() || pContent == null) {
|
||||
// Abbrechen, da es kein Element zu suchen gibt.
|
||||
return null;
|
||||
} else {
|
||||
ContentType content = this.getContent();
|
||||
if (pContent.isLess(content)) {
|
||||
// Element wird im linken Teilbaum gesucht.
|
||||
return this.getLeftTree().search(pContent);
|
||||
} else if (pContent.isGreater(content)) {
|
||||
// Element wird im rechten Teilbaum gesucht.
|
||||
return this.getRightTree().search(pContent);
|
||||
} else if (pContent.isEqual(content)) {
|
||||
// Element wurde gefunden.
|
||||
return content;
|
||||
} else {
|
||||
// Dieser Fall sollte nicht auftreten.
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------- Weitere private Methoden -------------- */
|
||||
|
||||
/**
|
||||
* Die Methode liefert denjenigen Baum, dessen linker Nachfolger keinen linken
|
||||
* Nachfolger mehr hat. Es ist also spaeter moeglich, in einem Baum im
|
||||
* rechten Nachfolger den Vorgaenger des linkesten Nachfolgers zu finden.
|
||||
*
|
||||
*/
|
||||
private BinarySearchTree<ContentType> ancestorOfSmallRight() {
|
||||
if (getNodeOfLeftSuccessor().left.isEmpty()) {
|
||||
return this;
|
||||
} else {
|
||||
return node.left.ancestorOfSmallRight();
|
||||
}
|
||||
}
|
||||
|
||||
private BSTNode<ContentType> getNodeOfLeftSuccessor() {
|
||||
return node.left.node;
|
||||
}
|
||||
|
||||
private BSTNode<ContentType> getNodeOfRightSuccessor() {
|
||||
return node.right.node;
|
||||
}
|
||||
|
||||
}
|
||||
203
02 baum/BinaryTree.java
Normal file
203
02 baum/BinaryTree.java
Normal file
@@ -0,0 +1,203 @@
|
||||
/**
|
||||
* <p>
|
||||
* Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2017.
|
||||
* </p>
|
||||
* <p>
|
||||
* Generische Klasse BinaryTree<ContentType>
|
||||
* </p>
|
||||
* <p>
|
||||
* Mithilfe der generischen Klasse BinaryTree koennen beliebig viele
|
||||
* Inhaltsobjekte vom Typ ContentType in einem Binaerbaum verwaltet werden. Ein
|
||||
* Objekt der Klasse stellt entweder einen leeren Baum dar oder verwaltet ein
|
||||
* Inhaltsobjekt sowie einen linken und einen rechten Teilbaum, die ebenfalls
|
||||
* Objekte der generischen Klasse BinaryTree sind.
|
||||
* </p>
|
||||
*
|
||||
* @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule;
|
||||
* Materialien zum schulinternen Lehrplan Informatik SII
|
||||
* @version Generisch_04 2020-03-11
|
||||
*/
|
||||
public class BinaryTree<ContentType> {
|
||||
|
||||
/* --------- Anfang der privaten inneren Klasse -------------- */
|
||||
|
||||
/**
|
||||
* Durch diese innere Klasse kann man dafuer sorgen, dass ein leerer Baum null
|
||||
* ist, ein nicht-leerer Baum jedoch immer eine nicht-null-Wurzel sowie
|
||||
* nicht-null-Teilbaeume, ggf. leere Teilbaeume hat.
|
||||
*/
|
||||
private class BTNode {
|
||||
|
||||
private ContentType content;
|
||||
private BinaryTree<ContentType> left, right;
|
||||
|
||||
private BTNode(ContentType pContent) {
|
||||
// Der Knoten hat einen linken und einen rechten Teilbaum, die
|
||||
// beide von null verschieden sind. Also hat ein Blatt immer zwei
|
||||
// leere Teilbaeume unter sich.
|
||||
this.content = pContent;
|
||||
left = new BinaryTree<ContentType>();
|
||||
right = new BinaryTree<ContentType>();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* ----------- Ende der privaten inneren Klasse -------------- */
|
||||
|
||||
private BTNode node;
|
||||
|
||||
/**
|
||||
* Nach dem Aufruf des Konstruktors existiert ein leerer Binaerbaum.
|
||||
*/
|
||||
public BinaryTree() {
|
||||
this.node = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wenn der Parameter pContent ungleich null ist, existiert nach dem Aufruf des
|
||||
* Konstruktors der Binaerbaum und hat pContent als Inhaltsobjekt und zwei leere
|
||||
* Teilbaeume. Falls der Parameter null ist, wird ein leerer Binaerbaum erzeugt.
|
||||
*
|
||||
* @param pContent das Inhaltsobjekt des Wurzelknotens vom Typ ContentType
|
||||
*/
|
||||
public BinaryTree(ContentType pContent) {
|
||||
if (pContent != null) {
|
||||
this.node = new BTNode(pContent);
|
||||
} else {
|
||||
this.node = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Wenn der Parameter pContent ungleich null ist, wird ein Binaerbaum mit
|
||||
* pContent als Inhalt und den beiden Teilbaeumen pLeftTree und pRightTree
|
||||
* erzeugt. Sind pLeftTree oder pRightTree gleich null, wird der entsprechende
|
||||
* Teilbaum als leerer Binaerbaum eingefuegt. So kann es also nie passieren,
|
||||
* dass linke oder rechte Teilbaeume null sind. Wenn der Parameter pContent
|
||||
* gleich null ist, wird ein leerer Binaerbaum erzeugt.
|
||||
*
|
||||
* @param pContent das Inhaltsobjekt des Wurzelknotens vom Typ ContentType
|
||||
* @param pLeftTree der linke Teilbaum vom Typ BinaryTree<ContentType>
|
||||
* @param pRightTree der rechte Teilbaum vom Typ BinaryTree<ContentType>
|
||||
*/
|
||||
public BinaryTree(ContentType pContent, BinaryTree<ContentType> pLeftTree, BinaryTree<ContentType> pRightTree) {
|
||||
if (pContent != null) {
|
||||
this.node = new BTNode(pContent);
|
||||
if (pLeftTree != null) {
|
||||
this.node.left = pLeftTree;
|
||||
} else {
|
||||
this.node.left = new BinaryTree<ContentType>();
|
||||
}
|
||||
if (pRightTree != null) {
|
||||
this.node.right = pRightTree;
|
||||
} else {
|
||||
this.node.right = new BinaryTree<ContentType>();
|
||||
}
|
||||
} else {
|
||||
// Da der Inhalt null ist, wird ein leerer BinarySearchTree erzeugt.
|
||||
this.node = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den Wahrheitswert true, wenn der Binaerbaum leer ist,
|
||||
* sonst liefert sie den Wert false.
|
||||
*
|
||||
* @return true, wenn der Binaerbaum leer ist, sonst false
|
||||
*/
|
||||
public boolean isEmpty() {
|
||||
return this.node == null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wenn pContent null ist, geschieht nichts. <br />
|
||||
* Ansonsten: Wenn der Binaerbaum leer ist, wird der Parameter pContent als
|
||||
* Inhaltsobjekt sowie ein leerer linker und rechter Teilbaum eingefuegt. Ist
|
||||
* der Binaerbaum nicht leer, wird das Inhaltsobjekt durch pContent ersetzt. Die
|
||||
* Teilbaeume werden nicht geaendert.
|
||||
*
|
||||
* @param pContent neues Inhaltsobjekt vom Typ ContentType
|
||||
*/
|
||||
public void setContent(ContentType pContent) {
|
||||
if (pContent != null) {
|
||||
if (this.isEmpty()) {
|
||||
node = new BTNode(pContent);
|
||||
this.node.left = new BinaryTree<ContentType>();
|
||||
this.node.right = new BinaryTree<ContentType>();
|
||||
}
|
||||
this.node.content = pContent;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert das Inhaltsobjekt des Binaerbaums. Wenn der Binaerbaum
|
||||
* leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return das Inhaltsobjekt der Wurzel vom Typ ContentType bzw. null, wenn der
|
||||
* Binaerbaum leer ist
|
||||
*/
|
||||
public ContentType getContent() {
|
||||
if (this.isEmpty()) {
|
||||
return null;
|
||||
} else {
|
||||
return this.node.content;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Falls der Parameter null ist, geschieht nichts. Wenn der Binaerbaum leer ist,
|
||||
* wird pTree nicht angehaengt. Andernfalls erhaelt der Binaerbaum den
|
||||
* uebergebenen BinaryTree als linken Teilbaum.
|
||||
*
|
||||
* @param pTree neuer linker Teilbaum vom Typ BinaryTree<ContentType>
|
||||
*/
|
||||
public void setLeftTree(BinaryTree<ContentType> pTree) {
|
||||
if (!this.isEmpty() && pTree != null) {
|
||||
this.node.left = pTree;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Falls der Parameter null ist, geschieht nichts. Wenn der Binaerbaum leer ist,
|
||||
* wird pTree nicht angehaengt. Andernfalls erhaelt der Binaerbaum den
|
||||
* uebergebenen BinaryTree als rechten Teilbaum.
|
||||
*
|
||||
* @param pTree neuer linker Teilbaum vom Typ BinaryTree<ContentType>
|
||||
*/
|
||||
public void setRightTree(BinaryTree<ContentType> pTree) {
|
||||
if (!this.isEmpty() && pTree != null) {
|
||||
this.node.right = pTree;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den linken Teilbaum des Binaerbaumes. Wenn der
|
||||
* Binaerbaum leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return linker Teilbaum vom Typ BinaryTree<ContentType> oder null, wenn der
|
||||
* aktuelle Binaerbaum leer ist
|
||||
*/
|
||||
public BinaryTree<ContentType> getLeftTree() {
|
||||
if (!this.isEmpty()) {
|
||||
return this.node.left;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den rechten Teilbaum des Binaerbaumes. Wenn der
|
||||
* Binaerbaum (this) leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return rechter Teilbaum vom Typ BinaryTree<ContentType> oder null, wenn der
|
||||
* aktuelle Binaerbaum (this) leer ist
|
||||
*/
|
||||
public BinaryTree<ContentType> getRightTree() {
|
||||
if (!this.isEmpty()) {
|
||||
return this.node.right;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
60
02 baum/ComparableContent.java
Normal file
60
02 baum/ComparableContent.java
Normal file
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* <p>
|
||||
* Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
|
||||
* </p>
|
||||
* <p>
|
||||
* Generisches Interface (Schnittstelle) ComparableContent<ContentType>
|
||||
* </p>
|
||||
* <p>
|
||||
* <p>Das generische Interface ComparableContent<ContentType> legt die Methoden
|
||||
* fest, ueber die Objekte verfuegen muessen, die in einen binaeren Suchbaum
|
||||
* (BinarySearchTree) eingefuegt werden sollen. Die Ordnungsrelation wird in
|
||||
* Klassen, die ComparableContent implementieren durch Ueberschreiben der drei
|
||||
* implizit abstrakten Methoden isGreater, isEqual und isLess festgelegt.
|
||||
* </p>
|
||||
* </p>
|
||||
* @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
|
||||
* @version Generisch_02 2014-03-01
|
||||
*/
|
||||
public interface ComparableContent<ContentType> {
|
||||
|
||||
/**
|
||||
* Wenn festgestellt wird, dass das Objekt, von dem die Methode aufgerufen
|
||||
* wird, bzgl. der gewuenschten Ordnungsrelation groesser als das Objekt
|
||||
* pContent ist, wird true geliefert. Sonst wird false geliefert.
|
||||
*
|
||||
* @param pContent
|
||||
* das mit dem aufrufenden Objekt zu vergleichende Objekt vom
|
||||
* Typ ContentType
|
||||
* @return true, wenn das aufrufende Objekt groesser ist als das Objekt
|
||||
* pContent, sonst false
|
||||
*/
|
||||
public boolean isGreater(ContentType pContent);
|
||||
|
||||
/**
|
||||
* Wenn festgestellt wird, dass das Objekt, von dem die Methode aufgerufen
|
||||
* wird, bzgl. der gewuenschten Ordnungsrelation gleich gross wie das Objekt
|
||||
* pContent ist, wird true geliefert. Sonst wird false geliefert.
|
||||
*
|
||||
* @param pContent
|
||||
* das mit dem aufrufenden Objekt zu vergleichende Objekt vom
|
||||
* Typ ContentType
|
||||
* @return true, wenn das aufrufende Objekt gleich gross ist wie das Objekt
|
||||
* pContent, sonst false
|
||||
*/
|
||||
public boolean isEqual(ContentType pContent);
|
||||
|
||||
/**
|
||||
* Wenn festgestellt wird, dass das Objekt, von dem die Methode aufgerufen
|
||||
* wird, bzgl. der gewuenschten Ordnungsrelation kleiner als das Objekt
|
||||
* pContent ist, wird true geliefert. Sonst wird false geliefert.
|
||||
*
|
||||
* @param pContent
|
||||
* das mit dem aufrufenden Objekt zu vergleichende Objekt vom
|
||||
* Typ ContentType
|
||||
* @return true, wenn das aufrufende Objekt kleiner ist als das Objekt
|
||||
* pContent, sonst false
|
||||
*/
|
||||
public boolean isLess(ContentType pContent);
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user