学习SCJP，如何从知识走向知识的应用

Question

我在这里读了很多SCJP的问题，以及来自Sun和Head First出版商的所有技巧和技巧，我想知道我是不是漏掉了什么。

从Java组件的知识转移到能够回答应用这些知识的问题时，我遇到了困难。如果你问我一个关于语言或API的具体问题，我可以回答。然而，当我希望应用这些知识来回答模拟编码问题时，我需要花费很长时间来处理问题，并且我很难将这些点连接起来。就像什么都没发生一样。有没有一个过程可以让我更好地根据我所知道的得出问题的结论？

Answer 1

很简单:你可以使用它。

这听起来可能是陈词滥调，但在编程中学习新东西，没有什么比尝试用它做点什么更重要的了。就像写代码一样。

如果它真的是新的，你可以从一个现有的程序开始，然后修改它来做你想做的事情。这通常会打破它，你将在接下来的两个小时里找出原因。在这两个小时中，你会学到更多关于程序结构的基础知识(在该语言/框架中)，程序是如何组合在一起的，等等，比从书上读到的时间长5倍。

我并不是在暗示书籍毫无价值:远非如此。但编程归根结底是一门实用的学科。

Answer 2

当遇到一个新概念时，想出一个用例，并实际编写一些代码。

例如，如果我们了解了Runnable以及如何使用它们来创建新的Thread，那么实际编写一些代码并尝试一下：

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

当学习新的东西时，没有什么可以代替实际的尝试。

实际上，我相信通过Stack Overflow上的问题并尝试回答它们将是尝试应用所学概念的一种很好的方式。即使一个人实际上没有张贴答案，通过写答案的过程本身也会重新强化学习到的概念。

Answer 3

我是一个很好的程序员。我已经读完了SCJP这本书的一半，当我在JavaOne (谢天谢地，免费)参加测试时，我只得了60分。

我从这次考试中学到的是，他们会尽可能多地欺骗你。解决这个问题的唯一方法是开始尝试编写一些愚蠢的代码，然后看看会发生什么。

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();
     }
}

创建像上面这样的愚蠢示例，看看输出的是什么。然后尝试使用Set、TreeSets和所有其他类型的Set。然后对Maps和Maps的所有子集执行相同的操作。我想出了下面的类，它是从其他人玩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();
}