The import android.support.v7 cannot be resolved

Beim Einrichten eines neuen Android-Projektes in Eclipse Juno kann es passieren, dass die Fehlermeldung "The import android.support.v7 cannot be resolved" auftritt. 

Android legt zusätzlich zum eigentlichen Projekt das Projekt "appcompat_v7" an. Wenn dieses Projekt schon besteht, wird es anscheinend nicht aktualisiert. Wenn man beim Erstellen eines neuen Projektes an den Android-Einstellungen Änderungen vornimmt, wird daher das dazu passende
appcompat_v7 nicht bereit gestellt. Das führt dann zu der o. g. Fehlermeldung.

Abhilfe: appcompat_v7 löschen, bevor man ein neues Projekt aufsetzt. Dann wird das passende appcompat_v7 erstellt.

Quicken 2015 - Web-Banking-Aktualisierung wird nicht installiert

Bisher wurden meine Web-Banking-Aktualisierungen für Quicken 2015 immer anstandslos herunter geladen und installiert. Ich bekam dabei immer die Aufforderung, mich als Administrator anzumelden.

Seit gestern muss ich erst ins Administratorkonto wechseln, Quicken aufrufen und dann die Web-Banking-Aktualisierung durchführen. Die Fehlermeldung, dass die Web-Banking-Aktualisierung nicht installiert wurde, als ich mein normales Benutzerkonto verwendete, war nicht sehr hilfreich. Schön wäre es gewesen, wenn auf die fehlenden Administratorrechte hingewiesen worden wäre.

Unterschied Objekt - Instanz

Oft werden die Begriffe Instanz und Objekt synonym verwendet. Das ist aber nicht ganz korrekt. Die Instanz einer Klasse ist ein Objekt, aber nicht jedes Objekt ist Instanz einer Klasse. In Java ist beispielsweise ein Array ein Objekt, es wird aber nicht von einer Klasse instanziiert.

Nach Systemreparatur fährt Windows 7 mit dem Boot Manager hoch

Mein Windows 7 war defekt. Ich habe es dann automatisch reparieren lassen. Anschließend fuhr das System nur noch mit dem Boot Manager hoch, weil jetzt das defekte und das reparierte Windows vorhanden waren.

Um das defekte Windows aus der Boot-Sequenz zu entfernen, geht man ins Startmenü und gibt in der Eingabeaufforderung msconfig ein. Es öffnet sich die Systemkonfiguration. Den Reiter Start auswählen, das defekte Windows auswählen und die Schaltfläche Löschen anklicken.

Beim nächsten Systemstart startet Windows automatisch mit der reparierten Windows-Version.

Binäre Bäume: Tiefe und Anzahl der Knoten

Die Anzahl der Knoten eines binären Baumes lässt sich in Java sehr schön durch Rekursion berechnen. Gegeben ist die Klasse Baum mit folgenden Methoden:

• void empty(): true, wenn der Baum leer ist.
• Baum left(): Gibt den linken Teilbaum zurück.
• Baum right(): Gibt den rechten Teilbaum zurück.

Die Summe der Knoten eines Baumes lässt sich in die Berechnung der Summe der Knoten seines linken und rechten Teilbaumes plus seines eigenen Knotens (= 1)  aufsplitten. Das ist schon die Rekursion. Die Rekursion bricht ab, wenn der Teilbaum keinen Teilbaum mehr hat (empty() = true):

/**
   * Liefert die Anzahl der Knoten eines Baumes.
   * @param b: Der Baum, dessen Knotenzahl berechnet werden soll.
   * @return Anzahl der Knoten.
   */
  public static int anzahlKnoten(Baum b) {
    if(!b.empty())  // Jeder Baum hat einen Knoten plus die Knoten seiner linken und rechten
                            // Teilbäume.
        return 1 + anzahlKnoten(b.left()) + anzahlKnoten(b.right());
    return 0;          // Wenn der Baum keinen Teilbaum hat, hat er keine zusätzlichen Knoten.
  }

Genauso einfach lässt sich die Baumtiefe bestimmen. Die Tiefe des Baumes ist seine eigene Tiefe (= 1) plus die Tiefe seines linken oder rechten Teilbaums, je nachdem welcher größer ist:

/**
   * Liefert die Tiefe eines Baumes.
   * @param b: Der Baum, dessen Tiefe bestimmt werden soll.
   * @return die Tiefe des Baumes.
   */
  public static int baumTiefe(Baum b) {
    if(!b.empty())  // Jeder Baum mit Kindern hat die Tiefe 1 plus die Tiefe des linken oder
                            // rechten Teilbaums, je nachdem, welcher größer ist.
        return 1 + Math.max(baumTiefe(b.left()), baumTiefe(b.right()));
    return 0;          // Wenn der Baum leer ist, hat er die Tiefe 0.
  }

Java: Reihenfolge in einer Liste umdrehen

Eine beliebte Java-Programmieraufgabe ist es, die Reihenfolge einer gegebenen Liste umzudrehen. Die folgende Klasse erweitert die Klasse VerweisListe (ist hier nicht angegeben) um die Methoden umdrehen() und Object elem(int n). elem(int n) überschreibt die Methode elem() der Superklasse, die das aktuelle Listenobjekt zurückgibt.

/******************************  SuperListe.java  ******************************/

/**
 * Erweitet die Klasse VerweisListe um zwei nuetzliche Operationen.
 */

public class SuperListe extends VerweisListe {

  /**
   * Invertiert die Reihenfolge der Elemente in der Liste.
   */
  public void umdrehen() {
    Object zwischen = new Object();     // Zwischenspeicher
    int n = listenElemente();           // Anzahl der Listenelemente ermitteln.
    while(--n >= 0) {     // Beginnend beim vorletzten Element, Elemente zwischenspeichern,
                                     // loeschen und ans Ende haengen.
        zwischen = elem(n);     // Element von Position n zwischenspeichern.
        delete();                         // Element an Position n loeschen.
        endeSetzen();                // An das Listenende springen.
        insert(zwischen);           // Zwischengespeichertes Element ans Ende haengen.
    }    
  }
 
  /**
   * Springt auf das letzte Element der Liste.
   */
  private void endeSetzen() {
    while(!endpos())
        advance();
    } 
   
    /**
     * Zahl der Listenelemente ermitteln. Zaehlung beginnt bei 0.
     */
  private int listenElemente() {
    if(empty())
        throw new RuntimeException("Liste ist leer");
    int n = 0;
    reset();
    while(!endpos()) {
        advance();
        n++;
    }
    return n;
  }    

  /**
   * Liefert das Element an Stelle n.
   *
   * @param n der Index des zu liefernden Elementes, beginnend bei 0
   *
   * @return das Element an Stelle n
   *
   * @throws RuntimeException falls Liste weniger als n Elemente hat oder n < 0 ist
   */
  public Object elem(int n){
    if(n < 0 || listenElemente() < n)
        throw new RuntimeException("Ungueltiger Index");
    reset();                              // Auf Listenanfang springen.
    for(int i = 0; i < n; i++)    // An Auslesestelle springen.
        advance();
    return super.elem();          // Element zurueckgeben.
  }
}

/*************************************************************************/

Methoden der Superklasse:

• advance() wählt das nächste Listenelement aus.
• reset() wählt das erste Listenelement aus.
• boolean empty() ist true, wenn die Liste leer ist.
• boolean endpos() ist true, wenn das Ende der Liste erreicht wurde.
• Object elem() liest das Objekt an der aktuellen Listenposition aus.

Private Methoden:

• endeSetzen() wählt das letzte Element der Liste aus.
• int listenElemente() ermittelt die Anzahl der Listenelemente und gibt sie zurück. Dabei beginnt die Zählung bei 0: Der Wert 0 bedeutet also, dass 1 Element in der Liste ist. Wenn die Liste leer ist, wird eine RuntimeException geworfen.

Object elem(int n):

Die Methode gibt das Element an der Stelle n zurück. Zunächst wird geprüft, ob ein gültiger Wert n übergeben wurde. Wenn n kleiner 0 oder größer als die Anzahl der Listenelemente ist, wird eine RuntimeException geworfen.

Mit reset() wird das erste Listenelement angesteuert. In der For-Schleife wird advance() solange aufgerufen, bis das n-te Element erreicht ist. Mit dem Aufruf von elem() aus der Superklasse wird das Element zurückgegeben.

umdrehen():

Zunächst wird ein Objekt zwischen erzeugt, das jeweils das Element der Liste aufnimmt, das umgespeichert werden soll. n enthält die Position des umzuspeichernden Listenelements.

Beginnend mit dem (n - 1)-ten Element werden in der While-Schleife zunächst jeweils zwischengespeichert. dann gelöscht und schließlich am Ende der Liste wieder eingefügt. Damit mit dem (n - 1)-ten Element begonne wird, muss man im Schleifenkopf --n schreiben (anstatt n--). Bei --n wird zuerst n dekrementiert und anschließen auf <= 0 geprüft. Gleichzeitig wird damit erreicht, dass die While-Schleife nicht durchlaufen wird, wenn die Liste nur ein Element enthält.

Leere Seite lässt sich in Word nicht löschen

Ich hatte eine Tabelle erstellt, die die komplette Seite einnahm. Die Tabelle diente mir als Vorlage, um Etiketten zu bedrucken. Dummerweise wurde zusätzlich noch eine leere Seite erzeugt. Diese Seite ließ sich nicht löschen, obwohl ich alle Steuerzeichen anzeigte und versuchte, sie zu löschen.

Die Lösung des Problems ist einfach. Man muss die Zeilenhöhe der letzten Tabellenzeile nur ein wenig verringern, schon verschwindet die nachfolgende leere Seite. Alternativ kann man den unteren Seitenrand etwas verkleinern.