我学习使用java的一点体会 xuyongshuo（原作）

2002年初，因为公司的业务需要而学习java，并应用java开发项目。由于项目时间紧，没有充裕的时间系统学习java，对java的学习只能是项目需要用什么，就学什么，这种学习方法的上手快，但不扎实，在以后的工作中，因为java学的不扎实，吃了不少苦头。现在我学习应用java已经有一年半的时间，对java已经有了一定的体会，把自己的体会写出来，供网友分享。

      以我个人的经验，学习java应分以下几个阶段：

java的语法学习
面向对象观念的建立
java基本类库的学习
学习设计模式
应用设计模式
经过大量的实践，可以设计模式
      以上六个阶段，其中前三个阶段是针对java的，但java中，在很多设计模式的应用，同时有很多功能都支持设计模式，所以不懂设计模式的人是不会很好的应用java做开发的。第4、5个阶段的学习在前三个阶段的基础上，学习、应用成功的经验。从而进入第六个阶段，在软件设计这个领域尽情发挥。本人受能力所限，还处在第4个阶段的学习过程，所以会对前四个阶段说明。第五、六个阶段只是我根据我自己的知识做的推断，还没有经验无法说明。

      在对这些学习阶段进行阐述之前，我先说一下我的学习方法。在学习新的知识时我通常是按以下三个阶段学的

理论学习。通过对理论的学习，尽量了解新知识的概念；学习之后只是粗略的了解概念，不能和实际很好的结合。
演绎阶段。根据理论学习的知识，考虑在什么场合下可以应用这个新知识，哪些地方已经应用了这个概念，建立对新知识的感性认识。
归纳阶段。从一个更深的层次理解理论。
    以下根据java的六个学习阶段阐述我的体会，而每个阶段将按照理论学习、演绎和归纳三个小阶段讨论。

java语法的学习
    语法学习的理论学习阶段是最容易的阶段，70%以上的java书主要介绍的就是java语法，随意买来一本，通读一下就可以，主要理解以下内容：（1）数据类型，（2）操作符，（3）控制流程，（4）类和类再生，（5）包和接口，（6）异常操作。

     在理论学习阶段，不必过于注重细节，只要对java的基本语法有一个整体认识，能读懂示例的源代码就可以了。

     下一步就是演绎阶段，应用所学的语法知识，编写简单的程序。最好凭自己的记忆，将各语法要点都用一遍（编写代码最好用notepad），对自己不熟悉的语法要重新阅读，用编译器去检查语法错误。这个阶段的目标是脱离书本以及java API能编写简单的程序，阅读一个java源代码能说出执行结果。

     完成这个阶段的学习，参加scjp的考试，应该获得较高的成绩。

     在演绎阶段的基础上，根据自己犯过的错误，总结一下java的难点。重新阅读语法书，将一些自己不是很清楚的概念重新整理一下，这时你对java语法的理解比第一次阅读时更深了。

      我在刚开始学java时，只是粗略的看看语法书，就开始编程序了，遇到不懂的就重新阅读语法书，这样，完全可以成为一个合格程序员，但是当我成为team leader时，为了培训组员java编程，却发现自己脱离了java语法书和Java API，竟然会的不多（java集成开发工具有提示功能），为了培训，我又重新学了一遍java语法，很有收获。

     其实一个优秀的程序员，不但要能写出好的程序，更重要的是，对所写的程序能说的清楚：（1）说清楚程序的功能（2）说清楚程序的结构。而说清楚程序的结构的基础是对java的语法要熟悉。想成为优秀的程序员，一定要在学习语法的基础上，不断实践，不断总结，最终能脱离语法书，将java语法系统的讲解清楚。

（未完）

面向对象观念的建立
        Java是面向对象的开发工具，使用java开发应用时，一定要懂面向对象编程的概念。在学过了java语法之后，应该建立OOP的概念。

理论学习阶段，首先应当理解class和object，了解class、interface、abstract class，理解OOP的继承性，封装性（public, protected,private）和多态性。然后应当熟悉UML，可以阅读一些UML的简单资料，基本上了解类图、状态图和时序图就可以了。
演绎阶段，对OOP的实践。而OOP的成功范例应该是常见的23种设计模式。这个阶段需要阅读并体会设计模式UML图和示例代码，我推荐《java与模式》这本书，也可以访问http://www.jdon.com/designpatterns/index.htm  。不必读懂模式，只需要读懂每个模式的UML和代码。
归纳阶段，通过演绎阶段的学习，体会OOP带来的好处——对扩展开放，对修改关闭。同时学会如何在java中使用OOP的概念设计。
         我在使用Java编程初期，一直使用面向过程的思想编程，对class、interface、abstract class以及public、protect、private的存在并没有理解，直到我阅读了Gof的设计模式，才理解OOP的优点。但是Gof的设计模式太晦涩了，我第一次读时，仅仅是有了面向对象的概念，而对设计模式并没有理解。相反《java与模式》容易读一些，但《java与模式》一书的废话多一些，有很多内容可以不读。

（未完）

java基本类库的学习
         曾经面试过一些java程序员，我出的题目是在使用java时，经常用到哪些类，在哪个包里。很少有人能答好，甚至有人做了2年java程序都没有回答出，他们会用java，但必须依赖工具(指java集成开工具)，我觉得他们可以编写出程序，但不能编写出特别好得程序。

        我认为作为java程序员必须掌握java类库的两个包：java.lang和java.util这两个包。java.lang包提供的是java编程要用到的基本类包，java程序员天天在用，无非是看别人如何用，自己就如何用，但很少有人去总结一下，比如String 和StringBuffer这两个类有什么差别，应该有很多java程序员说不出来。另外Vector和HashMap这两个类大家都在用，有多少人能说清楚Vector和HashMap继承了哪些类，实现了哪些接口呢。

理论学习。认真阅读java API的以下内容：java.lang包中的String，StringBuffer，Number，Double，Float，Byte，Short，Integer，Long，Character，Boolean，Process，Runtime，System，Object，Cloneable，Class，ClassLoader，Thread，ThreadGroup，Runnable，Package类或接口。java.util包中的Collection，list，Set，ArrayList，LinkedList，Hashset，TreeSet，Iterator，Map，SortedMap，HashMap，TreeMap，Comparator，Arrays，Enumeration，Vector，Stack，Dictionary，Hashtable，Properties，StringTokenizer，BitSet，Date，Calendar，Locale，Random，Observer，Observable类和接口。主要理清楚这些类或接口的继承关系、主要功能。
演绎阶段。通过阅读代码，练习编程，学习并应用这些类和接口。其实这些类的大部分是经常用的，无非对这些类和接口说不清楚。在这些类中，对java.lang和java.util包中的类，最好将各个方法练习使用一次。而对java.util包中Collections framework中的类，最好理清楚各个类和接口之间的关系。常用的类的方法我就不具体介绍了，我举一个使用Observer和Obserable 的例子（摘自《The Complete Reference Java 2 》）。在Observer和Obserable中，java实现了对设计模式Observer的支持。
         Watcher.java代码

import java.util.*;

class Watcher implements Observer
{
public void update(Observable obj, Object arg )
{
  System.out.println("Update() called, count is " +
   ((Integer) arg).intValue());
}
}
      

      BeingWatched.java代码

import java.util.*;

class BeingWatched extends Observable
{
void counter( int period )
{
  for(;period >=0; period-- )
  {
   setChanged();
   notifyObservers( new Integer ( period ) );
   try
   {
    Thread.sleep(100);
   }
   catch( InterruptedException e)
   {
    System.out.println("Sleep interrupeted" );
   }
  }
}
};

       ObserverDemo.java代码

public class ObserverDemo
{
public static void main( String[] args )
{
  BeingWatched observed = new BeingWatched();
  Watcher observing = new Watcher();
  observed.addObserver( observing);
  observed.counter(10);
}
};

执行结果

Update() called, count is 10
Update() called, count is 9
Update() called, count is 8
Update() called, count is 7
Update() called, count is 6
Update() called, count is 5
Update() called, count is 4
Update() called, count is 3
Update() called, count is 2
Update() called, count is 1
Update() called, count is 0

归纳阶段。总结使用经验，体会这两个包中类的继承关系，对设计模式的支持（如Iterator本身就是设计模式，同时也是工厂方法模式的应用），了解这些类提供的所有功能，比较功能相近类的异同。将这些类的api记在心中。


         虽然集成开发环境支持方法提示功能，但我个人认为，对于java.lang和java.util这两个包的api应当熟记于心，java的其他类库在使用时可以查找api。当然如果从事不同的开发，对其他类库应当有相应的了解，如开发swing，就应当对javax.swing包了如执掌，开发b/s结构的程序，就要了解javax.servlet，依个人的应用来开发了。

（未完）

本文的上一篇发表之后，承蒙各位网友关注，发表了很多评论，我感觉很多人对我写得文章有误解，大概是我表述不清楚的原因吧。这篇文章是对上一篇的补充，以一个示例阐述了解collection框架的重要性。

      我在半年以前写过一个函数printAll(Vector vector)，具体代码如下

import java.util.*;

public class UtilTool
{
public static void printAll ( Vector vector )
{
  System.out.println( "the Collection is vector" );
  System.out.println( vector.getClass().toString() );
  Iterator iterator = vector.iterator();
  while ( iterator.hasNext() )
  {
   System.out.println(iterator.next().toString());
  }
}

public static void main( String[] arg )
{
Vector vector = new Vector();
  vector.add( new Integer(1));
  vector.add( new Integer(2));
  vector.add( new Integer(3));
  UtilTool.printAll(vector);
}

}

      printAll这个函数设计的很不好——不够通用，假如，还想打印HashSet类型的数据，你就必须重载printAll函数，代码如下

public static void printAll ( HashSet hashSet )
{
  System.out.println( "the Collection is hashSet" );
  System.out.println( hashSet.getClass().toString() );
  Iterator iterator = hashSet.iterator();
  while ( iterator.hasNext() )
  {
   System.out.println(iterator.next().toString());
  }
}

      printAll函数的代码重用率低。其实Vector和 HashSet都是Collection的实现，可以将printAll的参数类型改为Collection，而不必重载。代码如下

public static void printAll ( Collection collection )
{
  System.out.println( "the Collection is collection" );
  System.out.println( collection.getClass().toString() );
  Iterator iterator = collection.iterator();
  while ( iterator.hasNext() )
  {
   System.out.println(iterator.next().toString());
  }
}
      这样就可以删除printAll(Vector vector)和printAll(HashSet hashSet)函数了。

      在设计函数时，应优先使用接口，而不是类。当然必须了解Vector 是Collection的实现。

      如果对Collection的继承关系不清楚，很容易滥用重载，以下代码是一个有问题的代码（摘自Effective Java Programming Language Guide）

public class CollectionClassifier{

    public static String classify(Set s){

        return "Set";

    }

    public static String classify(List l){

        return "List";

    }

    public static String classify(Collection c){

        return "Unknow Collection";

    }

    public static void main( String[] args )

        Collection[] tests = new Collection[]{

            new HashSet(),

            new ArrayList(),

            new HashMap().values()

       }

       for(int i=0;i<tests.length;i++)

        System.out.println(classify(test[i]));

     }

}

程序输出的是三次"Unknown Collection"，而不是你期望的打印"Set","List"以及"Unknown Collection"。这个程序错误的根源是对Collection层次结构不熟悉，而滥用重载导致。

这篇文章仍然是对《我学习使用java的一点体会（3）》的补充。

      我使用java开发一年多，使用的应该还算熟练，最近在阅读《设计模式》和《Effective Java》时，又重新学了一下java的基本类库，对编程思想有了新的认识。java的基本类库是由专家设计的，理解基本类库一方面可以增加自己的开发效率，另外一方面可以学学专家的设计思路。在java的基本类库中，使用了很多的设计模式，在很多方面提供扩展机制，方便的支持设计模式。可以说java的基础类库，将面向对象设计的Open-Close principle (Software entities should be open for extension,but closed for modification)发挥到了极致。

      在java的基础类库中，有些类设计的是为了给java开发者提供工具，直接让开发者使用的，有些类是专门为继承而设计的。对于第一种类型的类，使用集成开发工具很容易就能上手使用，而对于第二种类型的类，不主动去学它的API，很难掌握它的使用。我举一个例子。java 2 提供了对Proxy模式的支持，在以下示例中，演示了如何使用代理模式（摘自《java与模式》）。主要体会java.lang.reflect.InvocationHandler的用法

package com.javapatterns.proxy.reflect;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;
import java.util.Vector;
import java.util.List;

public class VectorProxy implements InvocationHandler
{
    private Object proxyobj;

    /** @link dependency */
    /*#Proxy lnkProxy;*/

    public VectorProxy(Object obj)
    {
        proxyobj = obj;
    }

public static Object factory(Object obj)
    {
  Class cls = obj.getClass();

        return Proxy.newProxyInstance( cls.getClassLoader(),
            cls.getInterfaces(),
            new VectorProxy(obj) );
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {
  System.out.println("before calling " + method);

        if (args != null)
        {
   for (int i=0; i<args.length; i++)
            {
                System.out.println(args[i] + "");
            }
  }

        Object o = method.invoke(proxyobj, args);

  System.out.println("after calling " + method);

        return o;
    }

    public static void main(String[] args)
    {
  List v = null;

        v = (List) factory(new Vector(10));

        v.add("New");
        v.add("York");
    }

《Java与模式》这本书不是很好，废话太多，学究气十足。我在 CSDN 的论坛里看过有人对它的评价，大多是负面的。还是直接读《设计模式》或者《Java 设计模式》比较好。banq 写的那本我认为说的也不是很透彻。
http://www.cnforyou.com/query/bookdetail.asp?viBookCode=9718

《设计模式》一本书 200 多页，很薄，但是不要认为你一个星期足以读完。实际上我花了一个月才读完。名著是要读很多次的。以前上中学的时候老师说，辅导书是要买的，但是不需要买太多，熟读教材益无穷。

《Java 设计模式》
这本书在amazon上的评价并不好。
而且作者的文笔不佳,相信看过的人有所认识的

当然也可能是大家在看书是都是各取所需
我所言不是针对dlee兄的,给我个胆我也不敢
  

《Java 设计模式》没有什么独创的地方，只是《设计模式》的辅助。因为《设计模式》是用 C++ 举例的，可能有些朋友并不熟悉 C++。《Java 设计模式》中有用 Java 实现 GOF 设计模式的代码（不过这些代码在网上有很多）。我也没有买《Java 设计模式》。
我不是什么专家，只是一个想做好自己工作的 PM。我们讨论是真言无忌，不必担心伤害情面。

Good luck!

CSDN 上对《Java与模式》的评论。
一枝看上去很美的花——书评《Java与模式》
http://www.csdn.net/develop/article/16/16367.shtm

[eBook]Core Java 2 Volume I - Fundamentals, 6th Edition
http://arbow.itocean.net/resource/Core%20Java%202%20Volume%20I%20-%20Fundamentals,%206th%20Edition.chm

[eBook]Core Java 2 Volume II-Advanced Features 5th Edition
http://arbow.itocean.net/resource/Core%20Java%202%20Volume%20II-Advanced%20Features%205th%20Edition.exe

看完，j2se就搞定了。