Studium für SCJP, und wie von Wissen in die Anwendung von Wissen zu bewegen

Question

Ich habe eine Menge der SCJP Fragen hier lesen, und alle Tipps und Tricks von Sun und den Head First Verlage, und ich frage mich, ob ich etwas fehlt.

Ich habe Probleme von Wissen über eine Komponente von Java zu bewegen, um eine Frage beantworten zu können, die dieses Wissen gilt. Wenn Sie mir eine spezifische Frage über die Sprache oder API fragten, konnte ich sie beantworten. Allerdings, wenn ich dieses Wissen anwenden suche die Mock-Codierung Fragen zu beantworten, es nimmt mich immer die Frage zu verarbeiten, und ich habe Mühe, die Punkte zu verbinden. Es ist wie nichts Klicks. Gibt es ein Verfahren, mit dem ich eine bessere Rückschlüsse auf Fragen zurückgreifen auf das, was ich weiß?

Answer 1

Ganz einfach: Sie verwenden es

.

Das mag banal klingen, aber es gibt keinen Ersatz für etwas Neues in der Programmierung zu lernen als zu versuchen, etwas damit zu tun. Wie in Code zu schreiben.

Wenn es wirklich neue, könnten Sie starten, indem Sie ein bestehendes Programm zu nehmen und zu modifizieren es etwas, was Sie tun wollen. Dies wird in der Regel brechen und Sie werden die nächsten 2 Stunden damit verbringen, arbeiten heraus, warum. Dass 2 Stunden haben Sie mehr über die Grundlagen der Programmstruktur gelernt (in dieser Sprache / framework), wie ein Programm gesetzt wird, um zusammen und so weiter als 5-mal, dass es aus einem Buch großer Lese.

Nicht, dass ich was darauf hindeutet, Bücher sind wertlos: weit davon entfernt. Aber Programmierung ist letztlich eine pragmatische Disziplin.

Answer 2

Wenn ein neues Konzept zu begegnen, mit einem Anwendungsfall kommen, und tatsächlich einige Codes schreiben.

Zum Beispiel, wenn wir lernen, über Runnables und wie sie verwendet werden, können neuen Threads zu machen, tatsächlich einige Codes schreiben und probieren Sie es aus:

Thread t = new Thread(new Runnable() {
    public void run() {
        // Do something.
    }
});
t.start();

Wenn etwas Neues zu lernen, gibt es wirklich keinen Ersatz für tatsächlich Dinge auszuprobieren.

Eigentlich glaube ich, dass auf Stack-Überlauf durch Fragen zu gehen und zu beantworten versuchen, würde sie ziemlich guter Weg, um zu versuchen, erlernten Konzepte anzuwenden. Selbst wenn man nicht wirklich eine Antwort hinterlassen, gehen durch den Prozess eine Antwort zu schreiben, würde selbst arbeiten, um das erlernte Konzept neu zu erzwingen.

Answer 3

Ich bin ein ziemlich guter Programmierer. Ich habe durch die Hälfte des SCJP Buch zu lesen, und wenn ich den Test auf der JavaOne nahm (kostenlos, zum Glück) Ich erzielte nur 60% darauf.

Was ich gelernt habe aus dieser Prüfung unterziehen ist, dass sie so viel wie möglich versuchen werden zu betrügen. Der einzige Weg, dies zu bekämpfen, die versuchen, starten dumme Dinge zu codieren und sehen, was passiert.

class Foo {
     public void doSomething() { System.out.println("Foo"); }
}
class MyFoo extends Foo {
     public void doSomething() { System.out.println("MyFoo"); }
}
public class MyClass extends MyFoo {
     Foo f;
     static {
        f = new MyFoo().doSomething();
     }
     public static void main(String args[]) {
        new MyClass();
     }
}

Erstellen Sie dumme Beispiele wie die oben und sehen, was druckt. Dann versuchen Sie mit Sets herumspielen, TreeSets und alle anderen Arten von Sets. Dann das gleiche mit Karten und alle von den Untergruppen von Maps. Ich kam mit der folgenden Klasse bis der von snipits von anderen genommen spielen mit Sets.

public class PlayingWithSets {
private Set<Integer> s1;
private Set<Integer> s2;

enum Test {
    A,B,C

};
/*
 * Cannot be a static block because the variable is not static. This block
 * happens before the call to super() in the constructor.
 */
{
    s1 = generateSet();
    s2 = generateSet();
}

/**
 * Helper method to set up a new HashSet
 * @return
 */
private Set<Integer> generateSet() {
    Set<Integer> s = new HashSet<Integer>();
    Random r = new Random();
    for (int i = 0; i < 20; ++i) {
        s.add(r.nextInt(30));
    }
    return s;
}

/* **********************  Merges two sets *****************************/
private void mergeSets() {
    System.out.println("Set s1 = " + s1);
    System.out.println("Set s2 = " + s2);

    /*
     * Causes an error if you use the wildcard for the generic type. I.E.
     * Set<?> s1; in the declaration.
     * 
     * The cast is needed when using wild cards for declaration. The reason
     * is that you cannot gurantee that the object is of the same type,
     * which defeats the purpose of generics and type safety.
     */
    s1.addAll(s2);
    System.out.println(s1);
}

/* ************************  Sorting on a set  ***************************/
private void sortSets() {
    /*
     * Collections.sort() is ONLY for lists.
     */
    // Collections.sort(s1);

    TreeSet<Integer> ts = new TreeSet<Integer>(s1);
    System.out.println("Sorted set s1 = " + ts);
}

/* ********************  Tests the Uniqueness of sets (i.e. no duplicates)    **************************/

static void fill(Set s) {
    s.addAll(Arrays.asList("one two three four five six seven".split(" ")));
}

public static void testSetUniqueness(Set s) {
    // Strip qualifiers from class name:
    System.out.println(s.getClass().getName().replaceAll("\\w+\\.", ""));
    fill(s);
    fill(s);
    fill(s);
    System.out.println(s); // No duplicates!
    // Add another set to this one:
    s.addAll(s);
    s.add("one");
    s.add("one");
    s.add("one");
    System.out.println(s);
    // Look something up:
    System.out.println("s.contains(\"one\"): " + s.contains("one"));
}

/* ******************  Subset / Union / Intersection **********************/

public static <T> Set<T> union(Set<T> setA, Set<T> setB) {
    Set<T> tmp = new TreeSet<T>(setA);
    tmp.addAll(setB);
    return tmp;
}

public static <T> Set<T> intersection(Set<T> setA, Set<T> setB) {
    Set<T> tmp = new TreeSet<T>();
    for (T x : setA)
        if (setB.contains(x))
            tmp.add(x);
    return tmp;
}

public static <T> Set<T> difference(Set<T> setA, Set<T> setB) {
    Set<T> tmp = new TreeSet<T>(setA);
    tmp.removeAll(setB);
    return tmp;
}

public static <T> Set<T> symDifference(Set<T> setA, Set<T> setB) {
    Set<T> tmpA;
    Set<T> tmpB;

    tmpA = union(setA, setB);
    tmpB = intersection(setA, setB);
    return difference(tmpA, tmpB);
}

public static <T> boolean isSubset(Set<T> setA, Set<T> setB) {
    return setB.containsAll(setA);
}

public static <T> boolean isSuperset(Set<T> setA, Set<T> setB) {
    return setA.containsAll(setB);
}

private void subsetUnionIntersection() {
    TreeSet<Character> set1 = new TreeSet<Character>();
    TreeSet<Character> set2 = new TreeSet<Character>();

    set1.add('A');
    set1.add('B');
    set1.add('C');
    set1.add('D');

    set2.add('C');
    set2.add('D');
    set2.add('E');
    set2.add('F');

    System.out.println("set1: " + set1);
    System.out.println("set2: " + set2);

    System.out.println("Union: " + union(set1, set2));
    System.out.println("Intersection: " + intersection(set1, set2));
    System.out.println("Difference (set1 - set2): "
            + difference(set1, set2));
    System.out
            .println("Symmetric Difference: " + symDifference(set1, set2));

    TreeSet<Character> set3 = new TreeSet<Character>(set1);

    set3.remove('D');
    System.out.println("set3: " + set3);

    System.out.println("Is set1 a subset of set2? " + isSubset(set1, set3));
    System.out.println("Is set1 a superset of set2? "
            + isSuperset(set1, set3));
    System.out.println("Is set3 a subset of set1? " + isSubset(set3, set1));
    System.out.println("Is set3 a superset of set1? "
            + isSuperset(set3, set1));

}

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



/**
 * @param args
 */
public static void main(String[] args) {
    /*
     * Testing different types of sets
     */
    testSetUniqueness(new HashSet());
    testSetUniqueness(new TreeSet());
    testSetUniqueness(new LinkedHashSet());

    Test test = new Test();
    Test values[] = test.values();
    System.out.println("\nValues: " + values);
    for(Test t: values) {
        System.out.println("T: " + t.toString());
    }

    PlayingWithSets p = new PlayingWithSets();
    p.mergeSets();
    p.sortSets();
    p.subsetUnionIntersection();
}

Answer 4

Wirklich, ich denke, das gerade ist, wo Erfahrung kommt in. Sie müssen sich hinsetzen und einige Programme zu schreiben, um ein Gefühl dafür zu bekommen, wie die Dinge wirklich zusammenpassen.