我在这里阅读了很多SCJP问题，以及Sun和Head First出版商的所有提示和技巧，我想知道我是否遗漏了一些东西。
我无法从关于Java组件的知识转移到能够回答应用该知识的问题。如果您问我关于语言或API的具体问题，我可以回答。但是，当我希望应用这些知识来回答模拟编码问题时，我需要永远处理这个问题，而且我无法连接这些问题。这就像没有点击。是否有一个过程可以根据我的知识更好地得出有关问题的结论？
答案 0 :(得分：4)
简单：你使用它。
这可能听起来很陈词滥调，但是在编程中学习一些新东西，而不是试图用它做一些事情。与编写代码一样。
如果它真的是新的，你可以从现有程序开始并修改它来做你想做的事情。这通常会打破它，你将在接下来的2个小时内解决原因。在那2小时内，你将学到更多关于程序结构的基础知识（在那种语言/框架中），程序如何组合在一起，等等，而不是从书中读取它的5倍。
并不是说我建议书籍毫无价值：远非如此。但编程最终是一门务实的学科。
答案 1 :(得分：1)
遇到新概念时，想出一个用例，然后写一些代码。
例如，如果我们了解Runnable以及如何使用它们来制作新的Thread，请实际编写一些代码并尝试一下：
Thread t = new Thread(new Runnable() {
public void run() {
// Do something.
}
});
t.start();
在学习新东西时，实际上没有什么可以替代的。
实际上，我相信通过Stack Overflow上的问题并尝试回答它们将是尝试应用学习概念的好方法。即使一个人实际上没有发表答案，但通过编写答案的过程本身也会起到重新强化学习概念的作用。
答案 2 :(得分：1)
我是一个非常优秀的程序员。我已阅读了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();
}
}
创建如上所示的愚蠢示例，看看打印出来的内容。然后尝试使用Sets，TreeSet和所有其他类型的集合。然后使用地图和地图的所有子集执行相同操作。我想出了下面的课程，这个课程是从其他人玩的片段中拍摄的。
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();
}
答案 3 :(得分：0)
真的，我认为这只是经验的来源。你必须坐下来写一些程序，以了解事情是如何真正融合在一起的。