几年JAVA的编程经验汇总.docx

几年JAVA的编程经验汇总.docx

《几年JAVA的编程经验汇总.docx》由会员分享，可在线阅读，更多相关《几年JAVA的编程经验汇总.docx（16页珍藏版）》请在冰点文库上搜索。

几年JAVA的编程经验汇总

几年JAVA的编程经验汇总

1．关于动态加载机制?

?

学习Java比C++更容易理解OOP的思想，毕竟C++还混合了不少面向过程的成分。

很多人都能背出来Java语言的特点，所谓的动态加载机制等等。

当然概念往往是先记住而后消化的，可有多少人真正去体会过动态加载的机制，试图去寻找过其中的细节呢?

  提供大家一个方法：

在命令行窗口运行Java程序的时候，加上这个很有用的参数：

java  -verbose  *.class

这样会清晰的打印出被加载的类文件，大部分是jdk自身运行需要的，最后几行会明显的看到自己用到的那几个类文件被加载进来的顺序。

即使你声明了一个类对象，不实例化也不会加载，说明只有真正用到那个类的实例即对象的时候，才会执行加载。

这样是不是大家稍微能明白一点动态加载了呢？

^_^

2．关于寻找class文件原理?

?

建议大家在入门的时候在命令行窗口编译和运行，不要借助JCreator或者Eclipse等IDE去帮助做那些事情。

尝试自己这样做：

javac  -classpath  yourpath  *.java

java  -classpath  yourpath  *.class

也许很多人都能看懂，设置classpath的目的就是告诉编译器去哪里寻找你的class文件.  不过至少笔者今日才弄懂JVM去查询类的原理，编译器加载类要依靠classloader，  而classloader有3个级别，从高到低分别是BootClassLoader（名字可能不准确）  ,  ExtClassLoader,  AppClassLoader.

这3个加载器分别对应着编译器去寻找类文件的优先级别和不同的路径：

BootClassLoader对应jre/classes路径，是编译器最优先寻找class的地方

ExtClassLoader对应jre/lib/ext路径，是编译器次优先寻找class的地方

AppClassLoader对应当前路径，所以也是编译器默认找class的地方

其实大家可以自己写个程序简单的测试，对任何class，例如A,  

调用new  A（）.getClass（）.getClassLoader（）.toString（）  打印出来就可以看到，把class文件放在不同的路径下再次执行，就会看到区别。

特别注意的是如果打印出来是null就表示到了最高级BootClassLoader,  因为它是C++编写的，不存在Java对应的类加载器的名字。

寻找的顺序是一种向上迂回的思想，即如果本级别找不到，就只能去本级别之上的找，不会向下寻找。

不过似乎从Jdk1.4到Jdk1.6这一特点又有改变，没有找到详细资料。

所以就不举例子了。

告诉大家设计这种体系的是Sun公司曾经的技术核心宫力先生，一个纯种华人哦！

^_^

这样希望大家不至于迷惑为什么总报错找不到类文件，不管是自己写的还是导入的第三方的jar文件（J2ee中经常需要导入的）。

3．关于jdk和jre?

?

大家肯定在安装JDK的时候会有选择是否安装单独的jre，一般都会一起安装，我也建议大家这样做。

因为这样更能帮助大家弄清楚它们的区别：

Jre  是java  runtime  environment,  是java程序的运行环境。

既然是运行，当然要包含jvm，也就是大家熟悉的虚拟机啦，  还有所有java类库的class文件，都在lib目录下打包成了jar。

大家可以自己验证。

至于在windows上的虚拟机是哪个文件呢？

  学过MFC的都知道什么是dll文件吧，那么大家看看jre/bin/client里面是不是有一个jvm.dll呢？

那就是虚拟机。

Jdk  是java  development  kit，是java的开发工具包，里面包含了各种类库和工具。

当然也包括了另外一个Jre.  那么为什么要包括另外一个Jre呢？

而且jdk/jre/bin同时有client和server两个文件夹下都包含一个jvm.dll。

  说明是有两个虚拟机的。

这一点不知道大家是否注意到了呢？

相信大家都知道jdk的bin下有各种java程序需要用到的命令，与jre的bin目录最明显的区别就是jdk下才有javac，这一点很好理解，因为jre只是一个运行环境而已。

与开发无关，正因为如此，具备开发功能的jdk自己的jre下才会同时有client性质的jvm和server性质的jvm，  而仅仅作为运行环境的jre下只需要client性质的jvm.dll就够了。

记得在环境变量path中设置jdk/bin路径麽？

这应该是大家学习Java的第一步吧，  老师会告诉大家不设置的话javac和java是用不了的。

确实jdk/bin目录下包含了所有的命令。

可是有没有人想过我们用的java命令并不是jdk/bin目录下的而是jre/bin目录下的呢？

不信可以做一个实验，大家可以把jdk/bin目录下的java.exe剪切到别的地方再运行java程序，发现了什么？

一切OK！

那么有人会问了？

我明明没有设置jre/bin目录到环境变量中啊？

试想一下如果java为了提供给大多数人使用，他们是不需要jdk做开发的，只需要jre能让java程序跑起来就可以了，那么每个客户还需要手动去设置环境变量多麻烦啊？

所以安装jre的时候安装程序自动帮你把jre的java.exe添加到了系统变量中，验证的方法很简单，大家看到了系统环境变量的path最前面有“%SystemRoot%\system32;%SystemRoot%;”这样的配置，那么再去Windows/system32下面去看看吧，发现了什么？

有一个java.exe。

如果强行能够把jdk/bin挪到system32变量前面，当然也可以迫使使用jdk/jre里面的java，不过除非有必要，我不建议大家这么做。

使用单独的jre跑java程序也算是客户环境下的一种测试。

这下大家应该更清楚jdk和jre内部的一些联系和区别了吧？

1．  关于集合框架类

相信学过Java的各位对这个名词并不陌生，对  java.util.*这个package肯定也不陌生。

不知道大家查询API的时候怎么去审视或者分析其中的一个package，每个包最重要的两个部分就是interfaces和classes，接口代表了它能做什么，实现类则代表了它如何去做。

关注实现类之前，我们应该先理解清楚它的来源接口，不管在j2se还是j2ee中，都应该是这样。

那么我们先看这三个接口：

List、Set、Map。

也许有些人不太熟悉这三个名字，但相信大部分人都熟悉ArrayList，LinkedList，TreeSet，HashSet，HashMap，  Hashtable等实现类的名字。

它们的区别也是满容易理解的，List放可以重复的对象集合，Set放不可重复的对象组合，而Map则放  这样的名值对，  Key不可重复，Value可以。

这里有几个容易混淆的问题：

到底Vector和ArrayList，Hashtable和HashMap有什么区别？

很多面试官喜欢问这个问题，其实更专业一点应该这样问：

新集合框架和旧集合框架有哪些区别？

新集合框架大家可以在这些包中找since  jdk1.2的，之前的如vector和Hashtable都是旧的集合框架包括的类。

那么区别是？

a.  新集合框架的命名更加科学合理。

例如List下的ArrayList和LinkedList

b.  新集合框架下全部都是非线程安全的。

建议去jdk里面包含的源代码里面自己去亲自看看vector和ArrayList的区别吧。

当然如果是jdk5.0之后的会比较难看一点，因为又加入了泛型的语法，类似c++的template语法。

那么大家是否想过为什么要从旧集合框架默认全部加锁防止多线程访问更新到新集合框架全部取消锁，默认方式支持多线程？

（当然需要的时候可以使用collections的静态方法加锁达到线程安全）

笔者的观点是任何技术的发展都未必是遵循它们的初衷的，很多重大改变是受到客观环境的影响的。

大家知道Java的初衷是为什么而开发的麽？

是为嵌入式程序开发的。

记得上一篇讲到classLoader机制麽？

那正是为了节约嵌入式开发环境下内存而设计的。

而走到今天，Java成了人们心中为互联网诞生的语言。

互联网意味着什么？

多线程是必然的趋势。

客观环境在变，Java技术也随着飞速发展，导致越来越脱离它的初衷。

据说Sun公司其实主打的是J2se，结果又是由于客观环境影响，J2se几乎遗忘，留在大家谈论焦点的一直是j2ee。

技术的细节这里就不多说了，只有用了才能真正理解。

解释这些正是为了帮助大家理解正在学的和将要学的任何技术。

之后讲j2ee的时候还会再讨论。

多扯句题外话：

几十年前的IT巨人是IBM，Mainframe市场无人可比。

微软如何打败IBM？

正是由于硬件飞速发展，对个人PC的需求这个客观环境，让微软通过OS称为了第二个巨人。

下一个打败微软的呢？

Google。

如何做到的？

如果微软并不和IBM争大型机，Google借着互联网飞速发展这个客观环境作为决定性因素，避开跟微软争OS，而是走搜索引擎这条路，称为第3个巨人。

那么第4个巨人是谁呢？

很多专家预言将在亚洲或者中国出现，  Whatever，客观环境变化趋势才是决定大方向的关键。

当然笔者也希望会出现在中国，^_^~~

2．  关于Java设计模式

身边的很多在看GOF的23种设计模式，似乎学习它无论在学校还是在职场，都成了一种流行风气。

我不想列举解释这23种Design  Pattern，  我写这些的初衷一直都是谈自己的经历和看法，希望能帮助大家理解。

首先我觉得设计模式只是对一类问题的一种通用解决办法，只要是面向对象的编程预言都可以用得上这23种。

理解它们最好的方法就是亲自去写每一种，哪怕是一个简单的应用就足够了。

如果代码实现也记不住的话，记忆它们对应的UML图会是一个比较好的办法，当然前提是必须了解UML。

同时最好能利用Java自身的类库帮助记忆，例如比较常用的观察者模式，在java.util.*有现成的Observer接口和Observable这个实现类，看看源代码相信就足够理解观察者模式了。

再比如装饰器模式，大家只要写几个关于java.io.*的程序就可以完全理解什么是装饰器模式了。

有很多人觉得刚入门的时候不该接触设计模式，比如图灵设计丛书系列很出名的那本《Java设计模式》，作者:

  Steven  John  Metsker，大部分例子老实说令现在的我也很迷惑。

但我仍然不同意入门跟学习设计模式有任何冲突，只是我们需要知道每种模式的概念的和典型的应用，这样我们在第一次编写  FileOutputStream、BufferedReader、PrintWriter的时候就能感觉到原来设计模式离我们如此之近，而且并不是多么神秘的东西。

另外，在学习某些模式的同时，反而更能帮助我们理解java类库的某些特点。

例如当你编写原型（Prototype）模式的时候，你必须了解的是  java.lang.Cloneable这个接口和所有类的基类Object的clone（）这个方法。

即深copy和浅copy的区别：

Object.clone（）默认实现的是浅copy，也就是复制一份对象拷贝，但如果对象包含其他对象的引用，不会复制引用，所以原对象和拷贝共用那个引用的对象。

深copy当然就是包括对象的引用都一起复制啦。

这样原对象和拷贝对象，都分别拥有一份引用对象。

如果要实现深copy就必须首先实现  java.lang.Cloneable接口，然后重写clone（）方法。

因为在Object中的clone（）方法是protected签名的，而  Cloneable接口的作用就是把protected放大到public，这样clone（）才能被重写。

那么又有个问题了？

如果引用的对象又引用了其他对象呢？

这样一直判断并复制下去，是不是显得很麻烦？

曾经有位前辈告诉我的方法是重写clone方法的时候直接把原对象序列化到磁盘上再反序列化回来，这样不用判断就可以得到一个深copy的结果。

如果大家不了解序列化的作法建议看一看  ObjectOutputStream和ObjectInputStream

归根结底，模式只是思想上的东西，把它当成前人总结的经验其实一点都不为过。

鼓励大家动手自己去写，例如代理模式，可以简单的写一个Child类，  Adult类。

Child要买任何东西由Adult来代理实现。

简单来说就是Adult里的buy（）内部实际调用的是Child的buy（），可是暴露在main函数的却是Adult.buy（）。

这样一个简单的程序就足够理解代理模式的基本含义了。

1．  关于Object类理解

      大家都知道Object是所有Java类的基类，  意味着所有的Java类都会继承了Object的11个方法。

建议大家去看看Object的  11个成员函数的源代码，就会知道默认的实现方式。

比如equals方法，默认实现就是用"=="来比较，即直接比较内存地址，返回true  或者  false。

而toString（）方法，返回的串组成方式是?

?

      "getClass（）.getName（）  +  "@"  +  Integer.toHexString（hashCode（））"

      其实不用我过多的解释，大家都能看懂这个串的组成。

接下来再看看hashCode（）：

      public  native  int  hashCode（）；

      由于是native方法，跟OS的处理方式相关，源代码里仅仅有一个声明罢了。

我们有兴趣的话完全可以去深究它的hashCode到底是由OS怎么样产生的呢？

但笔者建议最重要的还是先记住使用它的几条原则吧！

首先如果equals（）方法相同的对象具有相通的hashCode，但equals  （）对象不相通的时候并不保证hashCode（）方法返回不同的整数。

而且下一次运行同一个程序，同一个对象未必还是当初的那个hashCode（）  哦。

      其余的方法呢？

nofigy（）、notifyAll（）、clone（）、wait（）都是native方法的，说明依赖于操作系统的实现。

最后一个有趣的方法是finalize（），类似C++的析构函数，签名是protected，证明只有继承扩展了才能使用，方法体是空的，默示什么也不做。

它的作用据笔者的了解仅仅是通知JVM此对象不再使用，随时可以被销毁，而实际的销毁权还是在于虚拟机手上。

那么它真的什么也不做麽？

未必，实际上如果是线程对象它会导致在一定范围内该线程的优先级别提高，导致更快的被销毁来节约内存提高性能。

其实从常理来说，我们也可以大概这样猜测出jvm做法的目的。

      2．  关于重载hashCode（）与Collection框架的关系

笔者曾经听一位搞Java培训多年的前辈说在他看来hashCode方法没有任何意义，仅仅是为了配合证明具有同样的hashCode会导致equals  方法相等而存在的。

连有的前辈都犯这样的错误，其实说明它还是满容易被忽略的。

那么hashCode（）方法到底做什么用？

      学过数据结构的课程大家都会知道有一种结构叫hash  table，目的是通过给每个对象分配一个唯一的索引来提高查询的效率。

那么Java也不会肆意扭曲改变这个概念，所以hashCode唯一的作用就是为支持数据结构中的哈希表结构而存在的，换句话说，也就是只有用到集合框架的  Hashtable、HashMap、HashSet的时候，才需要重载hashCode（）方法，

这样才能使得我们能人为的去控制在哈希结构中索引是否相等。

笔者举一个例子：

      曾经为了写一个求解类程序，需要随机列出1,2,3,4组成的不同排列组合，所以笔者写了一个数组类用int[]来存组合结果，然后把随机产生的组合加入一个HashSet中，就是想利用HashSet不包括重复元素的特点。

可是HashSet怎么判断是不是重复的元素呢？

当然是通过  hashCode（）返回的结果是否相等来判断啦，可做一下这个实验：

      int[]  A  =  {1,2,3,4};

      int[]  B  =  {1,2,3,4};

      System.out.println（A.hashCode（））;

      System.out.println（B.hashCode（））;

      这明明是同一种组合，却是不同的hashCode，加入Set的时候会被当成不同的对象。

这个时候我们就需要自己来重写hashCode（）方法了，如何写呢？

其实也是基于原始的hashCode（），毕竟那是操作系统的实现，  找到相通对象唯一的标识，实现方式很多，笔者的实现方式是：

      首先重写了toString（）方法:

      return  A[0]“+”  A[1]“+”  A[2]“+”  A[3];  //显示上比较直观

      然后利用toString（）来计算hashCode（）：

      return  this.toString（）.hashCode（）；

      这样上述A和B返回的就都是”1234”，在测试toString（）.hashCode（），由于String在内存中的副本是一样的，”1234”.hashCode（）返回的一定是相同的结果。

      说到这，相信大家能理解得比我更好，今后千万不要再误解hashCode（）方法的作用。

      3．  关于Class类的成员函数与Java反射机制

      很早刚接触Java就听很多老师说过Java的动态运行时机制、反射机制等。

确实它们都是Java的显著特点，运行时加载笔者在第一篇介绍过了，现在想讲讲反射机制。

在Java中，主要是通过java.lang包中的Class类和Method类来实现内存反射机制的。

      熟悉C++的人一定知道下面这样在C++中是做不到的：

  运行时以字符串参数传递一个类名，就可以得到这个类的所有信息，包括它所有的方法，和方法的详细信息。

还可以实例化一个对象，并通过查到的方法名来调用该对象的任何方法。

这是因为Java的类在内存中除了C++中也有的静态动态数据区之外，还包括一份对类自身的描述，也正是通过这描述中的信息，才能帮助我们才运行时读取里面的内容，得到需要加载目标类的所有信息，从而实现反射机制。

大家有没有想过当我们需要得到一个JavaBean的实例的时候，怎么知道它有哪些属性呢？

再明显简单不过的例子就是自己写一个JavaBean的解析器：

      a.  通过Class.forName（“Bean的类名”）得到Class对象，例如叫ABeanClass

      b.  通过ABeanClass的getMethods（）方法，得到Method[]对象

      c.  按照规范所有get方法名后的单词就代表着该Bean的一个属性

      d.  当已经知道一个方法名，可以调用newInstance（）得到一个实例，然后通过invoke（）方法将方法的名字和方法需要用的参数传递进去，就可以动态调用此方法。

      当然还有更复杂的应用，这里就不赘述，大家可以参考Class类和Method类的方法。

      4．  坦言Synchronize的本质

      Synchronize大家都知道是同步、加锁的意思，其实它的本质远没有大家想得那么复杂。

声明Synchronize的方法被调用的时候，锁其实是加载对象上，当然如果是静态类则是加在类上的锁，调用结束锁被解除。

它的实现原理很简单，仅仅是不让第二把锁再次被加在同一个对象或类上，仅此而已。

一个简单的例子足以说明问题：

      class  A{

synchronized  void  f（）{}

void  g（）{}

      }

      当A的一个对象a被第一个线程调用其f（）方法的时候，第二个线程不能调用a的synchronized方法例如f（），因为那是在试图在对象上加第二把锁。

但调用g（）却是可以的，因为并没有在同一对象上加两把锁的行为产生。

1．关于序列化和反序列化

      应该大家都大概知道Java中序列化和反序列化的意思，序列化就是把一个Java对象转换成二进制进行磁盘上传输或者网络流的传输，反序列化的意思就是把这个接受到的二进制流重新组装成原来的对象逆过程。

它们在Java中分别是通过ObjectInputStream和  ObjectOutStream这两个类来实现的（以下分别用ois和oos来简称）。

      oos的writeObject（）方法用来执行序列化的过程，ois的readObject（）用来执行反序列化的过程，在传输二进制流之前，需要讲这两个高层流对象连接到同一个Channel上，这个Channel可以是磁盘文件，也可以是socket底层流。

所以无论用哪种方式，底层流对象都是以构造函数参数的形式传递进oos和ois这两个高层流，连接完毕了才可以进行二进制数据传输的。

例子：

      可以是文件流通道

      file  =  new  File（“C:

/data.dat”）;

      oos  =  new  ObjectOutputStream（new  FileOutputStream（file））;

      ois  =  new  ObjectInputStream（new  FileInputStream（file））;

      或者网络流通道

      oos  =  new  ObjectOutputStream（socket.getOutputStream（））;

      ois  =  new  ObjectInputStream（socket.getInputStream（））;  

      不知道大家是否注意到oos总是在ois之前定义，这里不希望大家误解这个顺序是固定的么？

回答是否定的，那么有顺序要求么？

回答是肯定的。

原则是什么呢？

原则是互相对接的输入/输出流之间必须是output流先初始化然后再input流初始化，否则就会抛异常。

大家肯定会问为什么？

只要稍微看一看这两个类的源代码文件就大概知道了，output流的任务很简单，只要把对象转换成二进制往通道中写就可以了，但input流需要做很多准备工作来接受并最终重组这个Object，所以ObjectInputStream的构造函数中就需要用到output初始化发送过来的header信息，这个方法叫做  readStreamHeader（），它将会去读两个Short值用于决定用多大的缓存来存放通道发送过来的二进制流，这个缓存的size因jre的版本不同是不一样的。

所以output如果不先初始化，input的构造函