Einführung in die objektorientierte Programmierung

Aufg1

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>=0 && index<this.getNumberOfNodes()) {
      return nodes[index];
    } // end of if
    else {
      throw new GraphException();
    } // end of if-else
  }
  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.
    int k= Math.min(nodes.length, this.getNumberOfNodes());
    for (int i=0;i<k ;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>=0 && index1 <this.getNumberOfNodes() && index2>=0 && index2 <this.getNumberOfNodes() ) {
      return  adjacencyMatrix[index1][index2];
    } // end of if
    else
    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".
    try{
      int index1= this.indexOf(node1);
      int index2= this.indexOf(node2);
      return  adjacencyMatrix[index1][index2];
    }
    catch (GraphException e){
      throw e;
    }
    
  }
  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>=0 && index1 <this.getNumberOfNodes() && index2>=0 && index2 <this.getNumberOfNodes() && index1!=index2 ) {
      this.adjacencyMatrix[index1][index2]=true;
      this.adjacencyMatrix[index2][index1]=true;
    } // end of if
    else
    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{
      int index1= this.indexOf(node1);
      int index2= this.indexOf(node2);
      this.addEdge(index1,index2);
    }
    catch (GraphException e){
      throw e;
    }
  }
  
  public static void  main(String args[]){
    String[] laender= {"Deutschland","Frankreich","Spanien"};
    Graph g = new Graph(laender);
    try{
      g.addEdge("Deutschland","Frankreich");
      g.addEdge("Spanien","Frankreich");
      System.out.println(g.isAdjacent("Deutschland","Frankreich"));
      System.out.println(g.isAdjacent("Deutschland","Spanien"));
      for (String land : laender ) {
        System.out.println(land);
      } // end of for
      for (boolean zeile[] : g.adjacencyMatrix ) {
        for (boolean wert : zeile) {
          System.out.println(wert);
        } // end of for
      }
    }
    catch ( GraphException e){
      System.out.println(e);
    }
    
  }
}

public class GraphException extends Exception {}

Aufg3

enum Dienstgrad {
  Helfer,Truppfuehrer, Gruppenfuehrer, Zugtruppfuehrer, Zugfuehrer;
  
  static String toString( Dienstgrad d){
    switch (d) {
      case  Helfer: 
      return "Helfer";
      case  Truppfuehrer: 
      return "Truppfuehrer";
      case  Gruppenfuehrer:
      return "Gruppenfuehrer";
      case  Zugtruppfuehrer:
      return "Zugtruppfuehrer";
      case  Zugfuehrer:
      return "Zugfuehrer"; 
      default :
      return "Fehler";
    } // end of switch
  }
  
  public static void printAll(){
    for ( Dienstgrad d : Dienstgrad.values() ) {
      System.out.println(Dienstgrad.toString(d ));
    } // end of for
  }
  
  public boolean istVorgesetzterVor(Dienstgrad d){
    return (this.ordinal()> d.ordinal());
  }
  
  public static void main(String[] args){
    Dienstgrad.printAll();
    System.out.println(Zugfuehrer.istVorgesetzterVor( Helfer));
    System.out.println(Helfer.istVorgesetzterVor( Zugfuehrer));
  }
}