Einführung in die objektorientierte Programmierung

Aufgabe 1

public class Graph {
   protected boolean[][] adjacencyMatrix;
   protected String[] nodes;
   
   protected int indexOf(String node) throws GraphException {
   for (int i = 0; i < nodes.length; i++) {
   if (node.equals(nodes[i])) {
   return i;
   }
   }
   throw new GraphException();
   }
   public Graph(int nodeNumber) {
   nodes = new String[nodeNumber];
   adjacencyMatrix = new boolean[nodeNumber][nodeNumber];
   }
   public Graph(String[] nodes) {
   this(nodes.length);
   for (int i = 0; i < nodes.length; i++) {
   this.nodes[i] = nodes[i];
   }
   }
   public String getNode(int index) throws GraphException {
   // ...liefert den Namen des Knotens an der
   // durch den Wert des Parameters bezeichneten Position,
   // wenn diese einen Knoten bezeichnet; sonst eine GraphException.
   if (index < nodes.length) {
   return nodes[index];
   } // end of if
   throw new GraphException();
   }
   public int getNumberOfNodes() {
   // ...liefert die Anzahl der Knoten zurueck.
   return nodes.length;
   }
   public void setNodes(String[] nodes) {
   // ...weist den ersten k Elementen des Attributs nodes die
   // entsprechenden Werte des Parameters nodes zu. k ist dabei das
   // Minimum aus der Laenge des Attributs und des Parameters.
   for (int i=0; i<nodes.length && i<this.nodes.length; i++) {
   this.nodes[i] = nodes[i];
   } // end of for
   }
   public boolean isAdjacent(int index1, int index2) throws GraphException {
   // ...liefert "wahr", wenn die Knoten mit Index
   // index1 und index2 benachbart sind, sonst "falsch".
   if (index1<adjacencyMatrix.length && index2 <adjacencyMatrix.length ) {
   return  adjacencyMatrix[index1][index2];
   } // end of if
   throw new GraphException();
   }
   public boolean isAdjacent(String node1, String node2) throws GraphException {
   // ...liefert "wahr", wenn die Laender mit Namen
   // node1 und node2 benachbart sind, sonst "falsch".
   return adjacencyMatrix[indexOf(node1)][indexOf(node2)];
   }
   public void addEdge(int index1, int index2) throws GraphException {
   // ...fuegt Kante zwischen den Knoten mit
   // Index index1 und index2 ein, wenn diese
   // Indizes von Laendern sind; sonst eine GraphException.
   if (index1 < adjacencyMatrix.length && index2 < adjacencyMatrix.length) {
   adjacencyMatrix[index1][index2]= true;
   adjacencyMatrix[index2][index1]= true;
   } // end of if
   throw new GraphException();
   }
   public void addEdge(String node1, String node2) throws GraphException {
   // ...fuegt Kante zwischen den Knoten mit
   // Laendernamen node1 und node2 ein, wenn diese
   // Knoten des Graphen bezeichnen; sonst eine GraphException.
   try{
   adjacencyMatrix[indexOf(node1)][indexOf(node2)] = true;
   adjacencyMatrix[indexOf(node2)][indexOf(node1)] = true;
   }
   catch (GraphException e){};
   }
   
   public static void main(String[] args){
   String[] laender= { "Deutschland", "Frankreich", "Spanien"}; 
   Graph g = new Graph( laender);
   try{
   g.addEdge("Deutschland", "Frankreich");
   g.addEdge("Frankreich", "Spanien");
   System.out.println(g.isAdjacent("Deutschland", "Frankreich"));
   System.out.println(g.isAdjacent( "Frankreich", "Spanien"));
   System.out.println(g.isAdjacent( "Spanien", "Deutschland"));
   }
   catch (GraphException e){};
   }
   }

public class GraphException extends Exception {}

Aufgabe 3

class THW{
  
  /*
  * Erwartete Ausgabe ist:
  *
  * Helfer
  * Truppfuehrer
  * Gruppenfuehrer
  * Zugtruppfuehrer
  * Zugfuehrer
  * false
  * true
  * false
  *
  */
  
  enum Dienstgrad { HELFER, TRUPPFUEHRER, GRUPPENFUEHRER, ZUGTRUPPFUEHRER, ZUGFUEHRER;
    public String toString(){
      switch (this) {
        case HELFER : return "Helfer"; 
        
        case  TRUPPFUEHRER: return "Truppfuehrer";
        
        case  GRUPPENFUEHRER: return "Gruppenfuehrer";
        
        case  ZUGTRUPPFUEHRER: return "Zugtruppfuehrer";
        
        case  ZUGFUEHRER: return "Zugfuehrer";
        
        default: return "nichts";
      } // end of switch
    }
    public static void printAll(){
      for (Dienstgrad grad : Dienstgrad.values() ) {
        System.out.println(grad.toString() );
      } // end of for
    }
    public boolean istVorgesetzterVor(Dienstgrad d){
      return (this.ordinal() > d.ordinal()); 
    }
  };
  
  public static void main(String[] args) {
    // System.out.println(Dienstgrad.HELFER.toString() );
    Dienstgrad.printAll();
    System.out.println(Dienstgrad.HELFER.istVorgesetzterVor(Dienstgrad.GRUPPENFUEHRER));
    System.out.println(Dienstgrad.TRUPPFUEHRER.istVorgesetzterVor(Dienstgrad.HELFER));
    System.out.println(Dienstgrad.GRUPPENFUEHRER.istVorgesetzterVor(Dienstgrad.GRUPPENFUEHRER));
  }
  
  
}