亚洲AV无码一区二区三区性色 ,久久久久亚洲爆乳少妇无,亚洲国产成人精品无码区在线秒播

好不�Ҏ(gu��)�� — Sun, 16 Nov 2014 00:39:00 GMT

　　抽象�c�d��是不能��用new�Ҏ(gu��)��q�行实例化的�c�，��x��有具体实例对象的�c�R��抽象类有点�c�M��“模板”的作用，目的是根据其格式来创建和修改新的�c�R��对象不能由抽象�cȝ��接创建，只可以通过抽象�c�L��生出新的子类�Q�再由其子类来创建对象。当一个类被声明�ؓ抽象�c�L��Q�要在这个类前面加上修饰�W�abstract.

　　在抽象类中的成员�Ҏ(gu��)��可以包括一般方法和抽象�Ҏ(gu��)��。抽象方法就是以abstract修饰的方法，�q�种�Ҏ(gu��)��只声明返回的数据�c�d��、方法名�U�和所需的参敎ͼ�没有�Ҏ(gu��)��体，也就是说抽象�Ҏ(gu��)��只需要声明而不需要实现。当一个方法�ؓ抽象�Ҏ(gu��)��Ӟ��意味着�q�个�Ҏ(gu��)��必须被子�cȝ��Ҏ(gu��)��所重写�Q�否则其子类的该�Ҏ(gu��)��仍然是abstract的，而这个子�c�M��必须是抽象的�Q�即声明为abstract.

　　抽象�c�M��不一定包含抽象方法，但是包含抽象�Ҏ(gu��)��的类一定要被声明�ؓ抽象�c�R��抽象类本��n不具备实际的功能�Q�只能用于派生其子类。抽象类中可以包含构造方法，但是构造方法不能被声明为抽象�?br />
　　调用抽象�c�M��的方法（抽象�Ҏ(gu��)��和非抽象�Ҏ(gu��)��Q�，如果�Ҏ(gu��)��是static的，直接抽象�c�R��方�?��可以了�Q�如果是非static的则必须需要一个��承的非抽象类�Q�然后用�q�个非抽象类的实例来调用�Ҏ(gu��)��?br />
　　抽象�c�d��以实现接口，接口中的�Ҏ(gu��)�� 在抽象类中可以不实现�Q�当有子�cȝ��?抽象�c�L��Q��ƈ且子�c�M��是抽象类�Ӟ��子类需要将抽象�c�M��?抽象�Ҏ(gu��)��和接口中的方法都实现托福�{�案

　　抽象�c�M��能用final来修饎ͼ�即一个类不能既是最�l�类又是抽象�c?strong>托福�{�案

　　�ȝ��Q?abstract不能与private、static、final、native�q�列修饰同一个方法�?/div>

好不�Ҏ(gu��)�� 2014-11-16 08:39 发表评论

好不�Ҏ(gu��)�� — Sat, 20 Sep 2014 07:01:00 GMT

　　FileUpload包下放了三个�c�：
　　OpenAndSave.java
　　TCPClient .java
　　TCPServer.java
　　1、OpenAndSave.java
　　package FileUpload;
　　import java.awt.*;
　　import javax.swing.*;
　　import java.util.*;
　　import java.io.*;
　　public class OpenAndSave extends JFrame {
　　// 选择打开文�g
　　public String getFile�Q�） {
　　String fileName="";
　　FileDialog fd = new FileDialog�Q�this, "请选择要传�l�zpc的文�?, FileDialog.LOAD�Q�；
　　fd.setDirectory�Q?C:\\"�Q�；
　　fd.setVisible�Q�true�Q�；
　　// 获取此文件对话框选定的文�?br />　　if �Q�fd.getFile�Q�）�Q? null�Q?{
　　fileName=fd.getDirectory�Q�） + fd.getFile�Q�）�Q?br />　　System.out.println�Q?已选择打开 " +fileName �Q�；
　　}
　　return fileName;
　　}
　　// 保存文�g
　　public OutputStream saveFile�Q�String fileName�Q?{
　　OutputStream os=null;
　　try {
　　FileDialog fd = new FileDialog�Q�this, "保存文�g", FileDialog.SAVE�Q�；
　　// 对话框打开时显�C�默认的目录
　　fd.setDirectory�Q?C:\\"�Q�；
　　fd.setFile�Q�fileName�Q�；
　　fd.setVisible�Q�true�Q�；
　　if �Q�fd.getFile�Q�） != null�Q?{
　　File myFile = new File�Q�fd.getDirectory�Q�）�Q?fd.getFile�Q�）�Q�；
　　os = new FileOutputStream�Q�myFile�Q�；
　　}
　　} catch �Q�IOException ioe�Q?{
　　JOptionPane.showMessageDialog�Q�this, "文�g保存发生错误�Q�已停止"�Q�；
　　}
　　return os;
　　}
　　}
　　2、TCPServer.java
　　/*
　　* Author:zpc
　　* Time:2014-5-1
　　*/
　　package FileUpload;
　　import java.io.*;
　　import java.net.*;
　　import java.util.Random;
　　import javax.swing.*;
　　//每接受一个客��L(f��ng)��h��单开一个线�E�处�?br />　　class UploadProcess implements Runnable {
　　private Socket s;
　　public UploadProcess�Q�Socket s�Q?{
　　this.s = s;
　　}
　　public void run�Q�） {
　　OutputStream fos = null;
　　try {
　　DataInputStream fis = new DataInputStream�Q�s.getInputStream�Q�）�Q�；// 和复制文件不同的是网�l�上传文件是从Socket中获取的I/O��对�?br />　　String fileName = fis.readUTF�Q�）�Q?br />　　DataOutputStream fos1= new DataOutputStream�Q�s.getOutputStream�Q�）�Q�；//写回信息�Q?br />　　if �Q�（JOptionPane.showOptionDialog�Q�null,
　　"�(zh��n)�想接受文�g" + fileName + "吗？", "消息",
　　JOptionPane.YES_NO_OPTION, 0, null, null, null�Q�） == 0�Q?{
　　System.out.println�Q?我已选择接受文�g�Q?�Q�；
　　String message1="服务器已接收�Q?;
　　fos1.writeUTF�Q�message1�Q�；
　　fos = new OpenAndSave�Q�）。saveFile�Q�fileName�Q�；
　　int len = 0;
　　byte[] bytes = new byte[1024];
　　if �Q�fis != null�Q?{
　　while �Q�（len = fis.read�Q�bytes�Q�） != -1�Q?{
　　fos.write�Q�bytes, 0, len�Q�；
　　}
　　}
　　JOptionPane.showMessageDialog�Q�null, "文�g保存成功�Q?�Q�；
　　if �Q�fis != null�Q?br />　　fis.close�Q�）�Q?br />　　if �Q�fos != null�Q?br />　　fos.close�Q�）�Q?br />　　}
　　else {
　　System.out.println�Q?我选择了拒�l�接受！"�Q�；
　　String message2="提示�Q�对方已拒绝接受�Q?;
　　fos1.writeUTF�Q�message2�Q�；
　　}
　　} catch �Q�Exception e�Q?{
　　System.out.println�Q?接受文�g��p�|�Q?�Q�；
　　}
　　}
　　}
　　public class TCPServer {
　　public static void main�Q�String[] args�Q?throws IOException {
　　// 建立服务器端的socket对象ServerSocket
　　ServerSocket ss = new ServerSocket�Q?0001�Q�；
　　while �Q�true�Q?{
　　Socket s = ss.accept�Q�）�Q?br />　　// 每个客户端的��h��创徏一个Socket对象�Q�单开一个线�E�处�?br />　　new Thread�Q�new UploadProcess�Q�s�Q�）。start�Q�）�Q?br />　　}
　　}
　　}
　　3、TCPClient .java
　　/*
　　* Author:zpc
　　* Function:上传文�g�l�用户zpc
　　* Time:2014-5-1
　　*/
　　package FileUpload;
　　import java.io.*;
　　import java.net.*;
　　public class TCPClient {
　　public static void main�Q�String[] args�Q?throws UnknownHostException{
　　// �q�行文�g的读取。数据源SAT�{�案
　　OpenAndSave open = new OpenAndSave�Q�）�Q?br />　　String fileName = open.getFile�Q�）�Q?br />　　File myFile = new File�Q�fileName�Q�；
　　InputStream in = null;
　　try {
　　in = new FileInputStream�Q�myFile�Q�；
　　} catch �Q�FileNotFoundException e1�Q?{
　　System.out.println�Q?未选中文�g�Q?�Q�；
　　}
　　// 数据目的地是另一��C��机，通过Socket获取I/O��?br />　　if �Q�in != null�Q?{
　　Socket s = null;
　　try {
　　s = new Socket�Q?127.0.0.1", 10001�Q�；//�q�里写好目标机器IP地址和�Q意一个开攄��未被其它�E�序占用的端口号
　　DataOutputStream os = new DataOutputStream�Q�s.getOutputStream�Q�）�Q�；托福�{�案
　　os.writeUTF�Q�fileName�Q�；
　　byte[] b = new byte[1024];
　　int len = 0;
　　while �Q�（len = in.read�Q�b�Q�） != -1�Q?{
　　os.write�Q�b, 0, len�Q�；
　　}
　　//System.out.println�Q?message"�Q�；
　　DataInputStream fis = new DataInputStream�Q�s.getInputStream�Q�）�Q�；
　　String message = fis.readUTF�Q�）�Q?br />　　System.out.println�Q�message�Q�；
　　if �Q�os != null�Q?br />　　os.close�Q�）�Q?br />　　if �Q�in != null�Q?br />　　in.close�Q�）�Q?br />　　} catch �Q�Exception e�Q?{
　　System.out.println�Q?貌似zpc不在�U�，�E�后再传�Q�！"�Q�；
　　}
　　} else {
　　System.out.println�Q?文�g��d��p�|�Q�in = null�Q�！"�Q�；
　　}
　　}

好不�Ҏ(gu��)�� 2014-09-20 15:01 发表评论

JAVA中运用数�l�的四种排序�Ҏ(gu��)��

好不�Ҏ(gu��)�� — Sat, 20 Sep 2014 06:57:00 GMT

　　JAVA中在�q�用数组�q�行排序功能�Ӟ��一般有四种�Ҏ(gu��)��Q�快速排序法、冒泡法、选择排序法、插入排序法�?br />　　快速排序法主要是运用了Arrays中的一个方法Arrays.sort�Q�）实现�?strong>托福�{�案
　　冒��法是�q�用遍历数组�q�行比较�Q�通过不断的比较将最��值或者最大��g��个一个的遍历出来�?br />　　选择排序法是��数�l�的�W�一个数据作为最大或者最��的��|��然后通过比较循环�Q�输出有序的数组�?br />　　插入排序是选择一个数�l�中的数据，通过不断的插入比较最后进行排序。下面我��将他们的实现方法一一详解供大家参考�?br />　　<1>利用Arrays带有的排序方法快速排�?strong>SAT�{�案
　　1 import java.util.Arrays;
　　2 public class Test2{
　　3 public static void main�Q�String[] args�Q�{
　　4 int[] a={5,4,2,4,9,1};
　　5 Arrays.sort�Q�a�Q�； //�q�行排序
　　6 for�Q�int i: a�Q�{
　　7 System.out.print�Q�i�Q�；
　　8 }
　　9 }
　　10 }
　　<2>冒��排序��法
　　1 public static int[] bubbleSort�Q�int[] args�Q�{//冒��排序��法
　　2 for�Q�int i=0;i　　3 for�Q�int j=i+1;j　　4 if �Q�args[i]>args[j]�Q�{
　　5 int temp=args[i];
　　6 args[i]=args[j];
　　7 args[j]=temp;
　　8 }
　　9 }
　　10 }
　　11 return args;
　　12 }
　　<3>选择排序��法
　　1 public static int[] selectSort�Q�int[] args�Q�{//选择排序��法
　　2 for �Q�int i=0;i　　3 int min=i;
　　4 for �Q�int j=i+1;j　　5 if �Q�args[min]>args[j]�Q�{
　　6 min=j;
　　7 }
　　8 }
　　9 if �Q�min!=i�Q�{
　　10 int temp=args[i];
　　11 args[i]=args[min];
　　12 args[min]=temp;
　　13 }
　　14 }
　　15 return args;
　　16 }
　　<4>插入排序��法
　　1 public static int[] insertSort�Q�int[] args�Q�{//插入排序��法
　　2 for�Q�int i=1;i　　3 for�Q�int j=i;j>0;j--�Q�{
　　4 if �Q�args[j]　　5 int temp=args[j-1];
　　6 args[j-1]=args[j];
　　7 args[j]=temp;
　　8 }else break;
　　9 }
　　10 }
　　11 return args;
　　12 }
　　以上��是java中的四种排序�Ҏ(gu��)��。不同的�Ҏ(gu��)��效率不一��P��下面是不同的��法的比较和数据交换时的大O表示�?br />　　冒��排序�Q�比较O�Q�N2�Q?数据交换O�Q�N2�Q?br />　　选择排序�Q�比较O�Q�N2�Q?数据交换O�Q�N�Q?br />　　插入排序�Q�比较O�Q�N2�Q?复制数据O�Q�N�Q?br />　　在实际应用中�Q�我们要��量选择效率高的��法�?/p>

好不�Ҏ(gu��)�� 2014-09-20 14:57 发表评论

用Guava辅助Throwable异常处理

好不�Ҏ(gu��)�� — Sat, 20 Sep 2014 06:52:00 GMT

　　Guava�?Throwables 工具常常可以让exception处理更方�ѝ�?br />　　Propagation
　　有时候，你会��x��捕获的exception抛到上一个try/catch块。对�?RuntimeException �?Error ��ؓ如此�Q�它们不需�?try/catch 块，但可能被其他�?try/catch 块无意捕莗��?br />　　Guava 提供了一些工��h��化propagate exception。例如：
　　try{
　　someMethodThatCouldThrowAnything();
　　}catch(IKnowWhatToDoWithThisException e){
　　handle(e);
　　}catch(Throwable t){
　　Throwables.propagateIfInstanceOf(t, IOException.class);
　　Throwables.propagateIfInstanceOf(t, SQLException.class);
　　throw Throwables.propagate(t);
　　}
　　�q�里的每个方法都会抛出它们自��q��exception�Q�但是throw最�l�结�?—— 如，throw Throwables.propagate(t) —— 对编译检查有指示作用�Q�提�C��里肯定会抛出一个exception�?br />　　�q�里是Guava提供的propagation�Ҏ(gu��)��的简单�ȝ��Q?br />　　参数形式解释
　　RuntimeException propagate(Throwable)如果参数throwable�?RuntimeException �?Error 则原样propagate�Q�否则将它包�?RuntimeException 中抛出。保证抛出。返回值是 RuntimeException �c�d��Q�因此你可以像上面那样写 throw Throwables.propagate(t) �Q�这样Java�~�译器会明白�q�一行肯定会抛出一个exception�?br />　　void propagateIfInstanceOf(Throwable, Class) throws X仅当参数throwable�?X �c�d��Ӟ��原样propagate�?br />　　void propagateIfPossible(Throwable)仅当参数throwable�?RuntimeException �?Error �c�d��Ӟ��原样propagate�?br />　　void propagateIfPossible(Throwable, Class) throws X仅当参数 throwable �?RuntimeException �?Error �?X �c�d��Ӟ��原样propagate�?br />　　Throwables.propagate的用�?模仿Java 7的多重catch和重新throw
　　一般来��_��调用者如果想要让exception沿着调用栈传播，他只要不�?catch 块就可以了。既然他不打��在exception后恢复，他恐怕也不需要写入log或者采取什么其他行动。他可能需要进行一些清理工作，但是无论有没有expction都会需要，因此清理工作会放�?finally 块中。尽��如此，会重新throw�?catch 块有时还是有意义的：也许调用者想要在传播exception之前先更新崩溃计数器�Q�或者他只想在特定条件下传播exception�?br />　　只有一�U�exception的时候，catch和重新throw是简单直接的。麻烦的是有多种exception的时候：
　　@Overridepublicvoid run(){
　　try{
　　delegate.run();
　　}catch(RuntimeException e){
　　failures.increment();
　　throw e;
　　}catch(Error e){
　　failures.increment();
　　throw e;
　　}
　　}
　　Java 7�?multicatch 来解册��个问�?
　　}catch(RuntimeException|Error e){
　　failures.increment();
　　throw e;
　　}
　　但不用Java 7的用户就没办法了。他们也惛_��如下的代码，但编译器不允许抛出Throwable�c�d��的变�?
　　}catch(Throwable t){
　　failures.increment();
　　throw t;
　　}
　　解决�Ҏ(gu��)��是用 throw Throwables.propagate(t) 来替�?throw t 。仅��p��U�情况而言�Q?Throwables.propagate 跟之前代码的功能完全相同。但是，代码里写 Throwables.propagate 很容易有一�U�隐藏的副作用。具体来��_��要注意上面这�U�模式只适用�?RuntimeException �?Error。如�?catch 块可能捕捉checked exception�Q�你�q�需要调�?propagateIfInstanceOf 来保证正常功能，因�ؓ Throwables.propagate 无法直接传播checked exception�?br />　　��M��来说�Q�这�U?propagate 的用法效果一般。在Java 7下没必要�q�样做。在其他版本的Java下，�q�样能略微减��重复，但是一个简单的Extract Method重构也可以达到同��h��果。另外，使用 propagate makes it easy to accidentally wrap checked exceptions.
　　无用功：�?throws Throwable 转化�?throws Exception
　　某些API�Q�尤其是Java reflection API �?(相应�? JUnit�Q�有抛出 Throwable 的方法。运用这些API可能很麻烦，因�ؓ��q��是最通用的API一般也只声明throws Exception�?Throwables.propagate 是�ؓ�?Exception �Q�非 Error �?Throwable 准备的。这个例子声明了一个执行JUnit��试�?Callable :
　　public void call() throws Exception{
　　try{
　　FooTest.super.runTest();
　　}catch(Throwable t){
　　Throwables.propagateIfPossible(t,Exception.class);
　　Throwables.propagate(t);
　　}
　　return null;
　　}
　　�q�里没必要propagate()�Q��ƈ且第二行�?"throw new RuntimeException(t)"�{��h(hu��n)�?(��Z��说一句：�q�个例子也提醒了�?propagateIfPossible 可能令�h�q�h��Q�因为它不仅传播参数指定的类型，也传�?Error �?RuntimeException�?
　　�q�种模式 (或者类似的写法�Q�如"throw new RuntimeException(t)") 在Google的代码库里至��出�?30 �ơ�?搜烦'propagateIfPossible[^;]* Exception.class[)];'试试�? 采用"throw new RuntimeException(t)"写法的略占多数。我们也有可能想要一�?throwWrappingWeirdThrowable"�Ҏ(gu��)��来做Throwable到Exception的�{换，但是既然两行��p��搞定�Q�这个方法还是没有太大必要，除非我们要废除propagateIfPossible�Ҏ(gu��)��?strong>sat�{�案
　　Throwables.propagate有争议的用法有争议：�?checked exception 转化�?unchecked exception
　　理论上，unchecked exception表示有bug�Q�checked exceptions表示在你控制范围之外的问题。但在实践上�Q�即使JDK有时也会用错 (臛_��Q�对于某些方法，没有普遍认同的正��答�?�?br />　　因此�Q�有时调用者需要让�q�两�U�exception�c�d��怺�转化�Q?br />　　try{
　　return Integer.parseInt(userInput);
　　}catch(NumberFormatException e){
　　throw new InvalidInputException(e);
　　}
　　try{
　　return publicInterfaceMethod.invoke();
　　}catch(IllegalAccessException e){
　　throw new AssertionError(e);
　　}
　　有时候，�q�些调用者会�?Throwables.propagate 。有什么坏处呢?最主要的问题是代码的含义不太明显。throw Throwables.propagate(ioException) 有什么效�?throw new RuntimeException(ioException) 有什么效�?�q�两行代码功能是相同的，但后者更直白。前者��人生疑："�q�是在做什�?应该不只是打包成 RuntimeException �?如果只�ؓ�q�个�Q��ؓ何不写一个wrapper�Ҏ(gu��)��?"只能承认�Q�部分问题在�?propagate"�q�个名字很含�p��?它是一个抛出未声明exception的方式吗?) 也许换成"wrapIfChecked"会好一些。但即��叫这个名字，在已知checked exception上调用它也没有什么优�ѝ��可能还会有副作�? 也许会有比普�?RuntimeException 更合适的抛出�c�d�� -- 比如�Q?IllegalArgumentException�?br />　　我们有时也会看到在exception仅仅有可能是checked exception时用 propagate 。相�Ҏ(gu��)��_��q�种做法后果��一些，也不那么直白�Q?br />　　}catch(RuntimeException e){
　　throw e;
　　}catch(Exception e){
　　throw new RuntimeException(e);
　　}
　　}catch(Exception e){
　　throw Throwables.propagate(e);
　　}
　　��管如此�Q�这里不可忽视的问题在于��checked exception转化为unchecked exception的行为本�w�。在某些情况下是无可厚非的，但更多的时候这样做是在逃避对常�?checked exception 的处理。这让我们思考checked exception本��n是否��是一个坏��L��。我不想说得�q�么深入。姑且说 �Q�Throwables.propagate 不是�?Java 使用者用来忽�?IOException 及类似异常的�?br />　　有争�? Exception隧道托福�{�案
　　但是当你实现一个不允许throw exception的方法时怎么办呢?有时你需要把exception打包在unchecked exception中。这��h��问题�Q�但同样的，对于单纯的打�?propagate 没有必要。事实上�Q�自己实现打包会更好一些：如果你把每个exception(而不只是checked exception)打包�Q�那��可以在另一端解包，减少�Ҏ(gu��)��处理。另外，最好打包成自定义的exception�c�d��?br />　　有争�? 重新抛出其他�U�程的exception
　　try{
　　return future.get();
　　}catch(ExecutionException e){
　　throw Throwables.propagate(e.getCause());
　　}
　　�q�里有几件要考虑的事�Q?br />　　对于checked exception�Q�参见上面的"�?checked exception 转化�?unchecked exception"一节。但如果此处已知不会抛出checked exception�? (也许�?Runnable 的结果�? 如上所�q�ͼ�你可以catch�q�个exception然后抛出 AssertionError ;propagate 没有什么用。特别的是，对于Future�Q�也可以考虑Futures.get�?br />　　对于非Exception�Q�非Error的Throwable�?好吧�Q�这个可能性不大，但是如果你试囄��接重新throw它，�~�译器会��你考虑�q�种可能) 参考上面的 "�?throws Throwable 转化�?throws Exception" 一�?
　　对于unchecked exception或error。那么它会直接被重新throw。不�q�的是，它的stack trace会显�C�原先��生exception的线�E�，而不是当前传播到的线�E�。一般最好的�l�果是把两个�U�程的stack trace都包括在exception chain中，��像 get 抛出�?ExecutionException 一栗��?�q�其实不�?propagate 的问�? �q�是所有把 exception 在另一个线�E�抛出的共同问题�?
　　因果�?br />　　Guava让研�I�一个exception的因果链(causal chain)更简单了一些，它提供了以下3个很有用的方法，功能��֐�思义:
　　Throwable getRootCause(Throwable)
　　List getCausalChain(Throwable)
　　String getStackTraceAsString(Throwable)

好不�Ҏ(gu��)�� 2014-09-20 14:52 发表评论

好不�Ҏ(gu��)�� — Wed, 10 Sep 2014 14:29:00 GMT

　　本文章介�l�了java下static关键字的用法�Q�大部分内容摘自原作者，在此学习(f��n)�q�分享给大家�?br />　　Static关键字可以修��C��?
　　从以下测试可以看出， static 可以修饰:
　　1. 语句�?br />　　2. 成员变量(但是不能修饰局部变�?
　　3. �Ҏ(gu��)��
　　4. 接口(内部接口)
　　5. �c?只能修饰在类中的�c�，即静态内部类)
　　6. jdk 1.5 中新增的静态导�?br />　　那么static 修饰的表�C�Z��么呢? 当创��Z��个类�Ӟ��是在创��Z��个新�c�d��Q�描�q�这个类的对象的外观和行为，除非用new创徏出那个类的对象，数据存储�I�间才被分配�Q�其�Ҏ(gu��)��才供外界调用。那么当声明一个事物�ؓstatic�Ӟ��意味着�q�个域或者方法不会与包含它的那个�cȝ��M��对象兌��在一��P��也就是说�Q�它不依赖类特定的实例，被类的所有实例共享，只要�q�个�c�被加蝲�Q�Java虚拟机就能根据类名在�q�行时数据区的方法区内定扑ֈ�他们。因此，static对象可以在它的�Q何对象创��Z��前访问，无需引用��M��对象�?br />　　1. static 修饰语句�?
　　static{} 可以有多处，执行��序按照他们的声明顺序。当JVM加蝲�q�个�cȝ��时候，��׃��执行此语句块�Q��ƈ且只执行一�ơ�?br />　　2. static 变量:
　　static 变量�Q�可以被�cȝ��所有对象共享，�q�且它只有一份存储空��_��JVM只�ؓ静态分配一�ơ内存，在加载类的过�E�中完成静态变量的内存分配。那么在引用static变量的时候，使用(�c�d��.变量�?是首选的方式�Q�因��Z��不仅��它是static�l�构�Q�而且在某些情况下会�ؓ�~�译器进行优化提供更好的��Z��?br />　　使用�c�d��直接引用static变量是比较力荐的�Q�这样就很明��的告诉大家该变量或属性是static�l�构或是被static修饰�?br />　　但是我想说一个更重要的知识点。static 在类中当变量的重要��用方法，首先��g��先运行一下下面代码试试：
　　public class Person {
　　static int[] arr = new int[3];
　　public static void main(String[] args){
　　Person per1 = new Person();
　　Person per2 = new Person();
　　Person per3 = new Person();
　　System.out.println("----改变之前-----");
　　System.out.print("per1-->");
　　per1.show();
　　System.out.print("per2-->");
　　per2.show();
　　System.out.print("per3-->");
　　per3.show();
　　//现在我改变它的�?br />　　Person.arr[2]=10;//�q�种�Ҏ(gu��)��是徏议的
　　per1.arr[0]=1;//一般不用这�U�方�?br />　　System.out.println("----改变之后-----");
　　System.out.print("per1-->");
　　per1.show();
　　System.out.print("per2-->");
　　per2.show();
　　System.out.print("per3-->");
　　per3.show();
　　}
　　//��Z��方便�Q�封装一个方法，来解�?br />　　public void show(){
　　for(int i=0; i
　　System.out.print(arr[i] + "t");
　　}
　　System.out.println("");
　　}
　　}Output�Q?br />　　----改变之前-----
　　per1-->0t0t0t
　　per2-->0t0t0t
　　per3-->0t0t0t
　　----改变之后-----
　　per1-->1t0t10t
　　per2-->1t0t10t
　　per3-->1t0t10t
　　�c�M��的�Ş式同样应用在使用static修饰的方法上�?�U�Cؓ静态方�?。它可以像普通方法一样��用对象来引用�Q�也可以通过�Ҏ(gu��)��的语法�Ş式来调用如：“�c�d��”+“ . ”+“�Ҏ(gu��)��”(); 定义静态方法的方式与定义静态变量一��P��
　　public class StaticTest2 {
　　static void method(){ ("�q�是静态方�?); }
　　}
　　普通的调用�Ҏ(gu��)��Q�StaticTest2 st = new StaticTest2(); 因�ؓmethod是static修饰�?静态方�?�Q�所以可以这栯��用：StaticTest2.()�?br />　　3. static�Ҏ(gu��)��:
　　static�Ҏ(gu��)��与非static�Ҏ(gu��)��的区别在�? static�Ҏ(gu��)��可以用类名直接访问在static内部的变量和�Ҏ(gu��)��Q�而不能引用非static的变量或者方法，但是你可以通过传递参数的方式传递一个引用，让这个引用去调用非静态数据�?br />　　4. static 接口:
　　内部接口(inner interface)本��n��默认是static�Q�所以static关键词加与不加都是一��L(f��ng)��Q?如此例中的接�?TestInInterface�Q�TestInClass 实现此接口，以下语句�Q?br />　　StaticDescription.TestInInterface a = new StaticDescription.TestInClass();
　　a.print();
　　我们��L��static关键字也是一��L(f��ng)��Q?但还是受讉K��权限控制TestInterface和FF�?br />　　5. static 修饰�c?(后部分会详细说明)
　　表示它是一个静态内部类�Q�它在引用外部类的事物时�Q�必��M��是static的。而且�Q?静态内部类在创��q��对象�Ӟ�� 是不需要外围类的存在。就好像下面的部分：
　　class Member {
　　static int classVar = 0; //�c�d��?br />　　int instanceVar; //实例变量
　　Member(int instanceVar) {
　　this.instanceVar = instanceVar;
　　}
　　static void setClassVar(int i) {
　　classVar=i;
　　//instanceVar=i; // �c�L��法不能访问实例变量，只能讉K��c�d��?br />　　}
　　static int getClassVar() {//�c�L��?br />　　return classVar;
　　}
　　void setInstanceVar(int i) {
　　classVar=i; //实例�Ҏ(gu��)��不但可以讉K��c�d��量，也可以实例变�?br />　　instanceVar=i;
　　}
　　int getInstanceVar() {
　　return instanceVar;
　　}
　　}
　　Member未实例化�Q?Member实例化之后：

1
　　对于非静态数据成员，每个�c�d��象都有自��q��拯��。而静态数据成员被当作是类的成员。无��个类的对象被定义了多��个�Q�静态数据成员在�E�序中也只有一份拷贝，��p��c�d��的所有对象共享访问。也��是��_��静态数据成员是该类的所有对象所共有的。对该类的多个对象来��_��静态数据成员只分配一�ơ内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一��L(f��ng)��Q�它的值可以更�?
　　Member m1 = new Member();
　　Member m2 = new Member();
　　内存分配

2
　　引用static变量有两�U�方法。如前例所�C�，可以通过一个对象去定位它，如m1.classVar; 也可以通过其类名直接引用，如Member.classVar�Q�而对于非静态成员则不行�?br />　　��管当static作用于某个字�D�|��Q�肯定会改变数据的创建方�?因�ؓ一个static字段�Ҏ(gu��)��个类来说都只有一份存储空��_��而非static字段则是�Ҏ(gu��)��个对象都有一个存储空�?�Q�但是如果static用于某个�Ҏ(gu��)��Q�差别却没有那么大。static�Ҏ(gu��)��的一个重要用法就是在不创��Z�Q何对象的前提下就可以调用它。这一点，对定义main()�Ҏ(gu��)��很重要，�q�个�Ҏ(gu��)��是运行一个应用时的入口点�?br />　　static�Ҏ(gu��)��是没有this的方法。在static�Ҏ(gu��)��的内部不能调用非静态方法，反过来倒是可以的。而且可以在没有创��Z�Q何对象的前提下，仅仅通过�c�L��w�来调用static�Ҏ(gu��)��。这实际上正是static�Ҏ(gu��)��的主要用途。它很像全局�Ҏ(gu��)��。Java中禁止��用全局�Ҏ(gu��)��Q�但你在�c�M��|�入static�Ҏ(gu��)��可以访问其他static�Ҏ(gu��)��和static域�?br />　　和其他�Q何方法一��P��static�Ҏ(gu��)��可以创徏或��用与其类型相同的被命名对象，因此�Q�static�Ҏ(gu��)��通常拿来�?#8220;牧羊�?#8221;的角�Ԍ��负责看护与其奴隶同一�c�d��的实例群�?br />　　不过�Q�要是在代码中出现大量的static�Ҏ(gu��)��Q�就该重新考虑自己的设计了sat�{�案 www.jszj123.com

好不�Ҏ(gu��)�� 2014-09-10 22:29 发表评论

最短�\径之Dijkstra��法详细讲解

好不�Ҏ(gu��)�� — Wed, 10 Sep 2014 14:21:00 GMT

　　1 最短�\径算�?br />
　　在日常生�z�M��Q�我们如果需要常常往�q�A地区和B地区之间�Q�我们最希望知道的可能是从A地区到B地区间的众多路径中，那一条�\径的路途最短。最短�\径问题是图论研究中的一个经典算法问题，旨在��L��?��q��点和路径�l�成�?中两�l�点之间的最短�\径�?��法具体的�Ş式包括：

　　(1)��定��L(f��ng)��的最短�\径问题：卛_��知�v始结点，求最短�\径的问题�?br />
　　(2)��定�l�点的最短�\径问题：与确定�v点的问题相反�Q�该问题是已知终�l�结点，求最短�\径的问题。在无向图中该问题与��定��L(f��ng)��的问题完全等同，在有向图中该问题�{�同于把所有�\径方向反转的��定��L(f��ng)��的问题�?br />
　　(3)��定��L(f��ng)��l�点的最短�\径问题：卛_��知�v点和�l�点�Q�求两结点之间的最短�\径�?br />
　　(4)全局最短�\径问题：求图中所有的最短�\径�?br />
　　用于解决最短�\径问题的��法被称�?#8220;最短�\径算�?#8221;�Q?有时被简�U�C��“路径��法”�?最常用的�\径算法有�Q�Dijkstra��法、A*��法、Bellman-Ford��法、Floyd-Warshall��法、Johnson��法�?br />
　　本文主要研究Dijkstra��法的单源算法�?br />
　　2 Dijkstra��法

　　2.1 Dijkstra��法

　　Dijkstra��法是典型最短�\��法�Q�用于计��一个节点到其他所有节点的最短�\径。主要特�Ҏ(gu��)��以�v始点��Z��心向外层层扩展，直到扩展到终点�ؓ止。Dijkstra��法能得出最短�\径的最优解�Q�但�׃��它遍历计��的节点很多�Q�所以效率低�?br />
　　Dijkstra��法是很有代表性的最短�\��法�Q�在很多专业评��中都作�ؓ基本内容有详�l�的介绍�Q�如数据�l�构�Q�图论，�q�筹学等�{��?br />
　　2.2 Dijkstra��法思想

　　Dijkstra��法思想为：设G=(V,E)是一个带权有向图�Q�把图中��点集合V分成两组�Q�第一�l��ؓ已求出最短�\径的��点集合(用S表示�Q�初始时S中只有一个源点，以后每求得一条最短�\�?, ��将加入到集合S中，直到全部��点都加入到S中，��法��q��束了)�Q�第二组为其余未��定最短�\径的��点集合(用U表示)�Q�按最短�\径长度的递增�ơ序依次把第二组的顶点加入S中。在加入的过�E�中�Q��M��持从源点v到S中各��点的最短�\径长度不大于从源点v到U中�Q何顶点的最短�\径长度。此外，每个��点对应一个距��，S中的��点的距��d��是从v到此��点的最短�\径长度，U中的��点的距��，是从v到此��点只包括S中的��点��Z��间顶点的当前最短�\径长�?strong>sat�{�案 www.jszj123.com

　　2.3 Dijkstra��法具体步骤

　　(1)初始�Ӟ��S只包含源点，即S=�Q�v的距��Mؓ0。U包含除v外的其他��点�Q�U中顶点u距离��上的�?若v与u有边)�?)(若u不是v的出辚w��接点)�?br />
　　(2)从U中选取一个距��v最��的��点k�Q�把k�Q�加入S�?该选定的距��d��是v到k的最短�\径长�?�?br />
　　(3)以k为新考虑的中间点�Q�修改U中各��点的距��?若从源点v到顶点u(u U)的距��?�l�过��点k)比原来距��?不经�q�顶点k)短，则修攚w��点u的距��d��|��修改后的距离值的��点k的距��d��上边上的权�?br />
　　(4)重复步骤(2)�?3)直到所有顶炚w��包含在S中�?br />
　　2.4 Dijkstra��法举例说明

　　如下图，设A为源点，求A到其他各��点(B、C、D、E、F)的最短�\径。线上所标注为相�?c��)��D�之间的距离�Q�即权倹{�?注：此图为随意所画，其相邻顶炚w��的距��M��图中的目视长度不能一一对等)

　　图一�Q�Dijkstra无向�?img border="0" alt="" src="http://www.tkk7.com/images/blogjava_net/haosola/1.jpg" width="345" height="204" />

　　��法执行步骤如下表：【注�Q�图片要是看不到请到“相册--日志相册”中，名�ؓ“Dijkstra��法�q�程”的图��是了�?br />

好不�Ҏ(gu��)�� 2014-09-10 22:21 发表评论

Java实现�ȝ��E�等待子�U�程

好不�Ҏ(gu��)�� — Mon, 25 Aug 2014 14:00:00 GMT

　　本文介绍两种�ȝ��E�等待子�U�程的实现方式，�?个子�U�程来说明：
　　1、��用Thread的join�Q�）�Ҏ(gu��)��Q�join�Q�）�Ҏ(gu��)��会阻塞主�U�程�l�箋向下执行�?br />　　2、��用java.util.concurrent中的CountDownLatch,是一个倒数计数器。初始化时先讄��一个倒数计数初始��|��每调用一�ơcountDown�Q�）�Ҏ(gu��)��Q�倒数值减一�Q�他的await�Q�）�Ҏ(gu��)��会阻塞当前进�E�，直到倒数�?.
　　join方式代码如下�Q?br />　　package com.test.thread;
　　import java.util.ArrayList;
　　import java.util.List;
　　public class MyThread extends Thread
　　{
　　public MyThread�Q�String name�Q?br />　　{
　　this.setName�Q�name�Q�；
　　}
　　@Override
　　public void run�Q�）
　　{
　　System.out.println�Q�this.getName�Q�） + " staring…"�Q�；
　　System.out.println�Q�this.getName�Q�） + " end…"�Q�；
　　}
　　/**
　　* @param args
　　*/
　　public static void main�Q�String[] args�Q?br />　　{
　　System.out.println�Q?main thread starting…"�Q�；
　　List list = new ArrayList�Q�）�Q?br />　　for �Q�int i = 1; i <= 5; i++�Q?br />　　{
　　MyThread my = new MyThread�Q?Thrad " + i�Q�；
　　my.start�Q�）�Q?br />　　list.add�Q�my�Q�；
　　}
　　try
　　{
　　for �Q�MyThread my : list�Q?br />　　{
　　my.join�Q�）�Q?br />　　}
　　}
　　catch �Q�InterruptedException e�Q?br />　　{
　　e.printStackTrace�Q�）�Q?br />　　}
　　System.out.println�Q?main thread end…"�Q�；
　　}
　　}
　　�q�行�l�果如下�Q?br />　　main thread starting…
　　Thrad 2 staring…
　　Thrad 2 end…
　　Thrad 4 staring…
　　Thrad 4 end…
　　Thrad 1 staring…
　　Thrad 1 end…
　　Thrad 3 staring…
　　Thrad 3 end…
　　Thrad 5 staring…
　　Thrad 5 end…
　　main thread end…
　　CountDownLatch方式代码如下�Q?br />　　package com.test.thread;
　　import java.util.concurrent.CountDownLatch;
　　public class MyThread2 extends Thread
　　{
　　private CountDownLatch count;
　　public MyThread2�Q�CountDownLatch count, String name�Q?br />　　{
　　this.count = count;
　　this.setName�Q�name�Q�；
　　}
　　@Override
　　public void run�Q�）
　　{
　　System.out.println�Q�this.getName�Q�） + " staring…"�Q�；
　　System.out.println�Q�this.getName�Q�） + " end…"�Q�；
　　this.count.countDown�Q�）�Q?br />　　}
　　/**
　　* @param args
　　*/
　　public static void main�Q�String[] args�Q?br />　　{
　　System.out.println�Q?main thread starting…"�Q�；
　　CountDownLatch count = new CountDownLatch�Q?�Q�；
　　for �Q�int i = 1; i <= 5; i++�Q?br />　　{
　　MyThread2 my = new MyThread2�Q�count, "Thread " + i�Q�；
　　my.start�Q�）�Q?br />　　}
　　try
　　{
　　count.await�Q�）�Q?br />　　}
　　catch �Q�InterruptedException e�Q?br />　　{
　　e.printStackTrace�Q�）�Q?br />　　}
　　System.out.println�Q?main thread end…"�Q�；
　　}
　　}
　　�q�行�l�果如下�Q?br />　　main thread starting…
　　Thread 2 staring…
　　Thread 2 end…
　　Thread 4 staring…
　　Thread 4 end…
　　Thread 1 staring…
　　Thread 1 end…
　　Thread 3 staring…
　　Thread 3 end…
　　Thread 5 staring…
　　Thread 5 end…
　　main thread end…托福�{�案

好不�Ҏ(gu��)�� 2014-08-25 22:00 发表评论

好不�Ҏ(gu��)�� — Mon, 25 Aug 2014 13:54:00 GMT

　　Java下static关键字用法详�?br />　　本文章介�l�了java下static关键字的用法�Q�大部分内容摘自原作者，在此学习(f��n)�q�分享给大家�?br />　　Static关键字可以修��C��?
　　从以下测试可以看出， static 可以修饰:
　　1. 语句�?br />　　2. 成员变量(但是不能修饰局部变�?
　　3. �Ҏ(gu��)��
　　4. 接口(内部接口)
　　5. �c?只能修饰在类中的�c�，即静态内部类)
　　6. jdk 1.5 中新增的静态导�?br />　　那么static 修饰的表�C�Z��么呢? 当创��Z��个类�Ӟ��是在创��Z��个新�c�d��Q�描�q�这个类的对象的外观和行为，除非用new创徏出那个类的对象，数据存储�I�间才被分配�Q�其�Ҏ(gu��)��才供外界调用。那么当声明一个事物�ؓstatic�Ӟ��意味着�q�个域或者方法不会与包含它的那个�cȝ��M��对象兌��在一��P��也就是说�Q�它不依赖类特定的实例，被类的所有实例共享，只要�q�个�c�被加蝲�Q�Java虚拟机就能根据类名在�q�行时数据区的方法区内定扑ֈ�他们。因此，static对象可以在它的�Q何对象创��Z��前访问，无需引用��M��对象�?br />　　1. static 修饰语句�?
　　static{} 可以有多处，执行��序按照他们的声明顺序。当JVM加蝲�q�个�cȝ��时候，��׃��执行此语句块�Q��ƈ且只执行一�ơ�?br />　　2. static 变量:
　　static 变量�Q�可以被�cȝ��所有对象共享，�q�且它只有一份存储空��_��JVM只�ؓ静态分配一�ơ内存，在加载类的过�E�中完成静态变量的内存分配。那么在引用static变量的时候，使用(�c�d��.变量�?是首选的方式�Q�因��Z��不仅��它是static�l�构�Q�而且在某些情况下会�ؓ�~�译器进行优化提供更好的��Z��?br />　　使用�c�d��直接引用static变量是比较力荐的�Q�这样就很明��的告诉大家该变量或属性是static�l�构或是被static修饰�?br />　　但是我想说一个更重要的知识点。static 在类中当变量的重要��用方法，首先��g��先运行一下下面代码试试：
　　public class Person {
　　static int[] arr = new int[3];
　　public static void main(String[] args){
　　Person per1 = new Person();
　　Person per2 = new Person();
　　Person per3 = new Person();
　　System.out.println("----改变之前-----");
　　System.out.print("per1-->");
　　per1.show();
　　System.out.print("per2-->");
　　per2.show();
　　System.out.print("per3-->");
　　per3.show();
　　//现在我改变它的�?br />　　Person.arr[2]=10;//�q�种�Ҏ(gu��)��是徏议的
　　per1.arr[0]=1;//一般不用这�U�方�?br />　　System.out.println("----改变之后-----");
　　System.out.print("per1-->");
　　per1.show();
　　System.out.print("per2-->");
　　per2.show();
　　System.out.print("per3-->");
　　per3.show();
　　}
　　//��Z��方便�Q�封装一个方法，来解�?br />　　public void show(){
　　for(int i=0; i
　　System.out.print(arr[i] + "t");
　　}
　　System.out.println("");
　　}
　　}Output�Q?br />　　----改变之前-----
　　per1-->0t0t0t
　　per2-->0t0t0t
　　per3-->0t0t0t
　　----改变之后-----
　　per1-->1t0t10t
　　per2-->1t0t10t
　　per3-->1t0t10t
　　�c�M��的�Ş式同样应用在使用static修饰的方法上�?�U�Cؓ静态方�?。它可以像普通方法一样��用对象来引用�Q�也可以通过�Ҏ(gu��)��的语法�Ş式来调用如：“�c�d��”+“ . ”+“�Ҏ(gu��)��”(); 定义静态方法的方式与定义静态变量一��P��
　　public class StaticTest2 {
　　static void method(){ ("�q�是静态方�?); }
　　}
　　普通的调用�Ҏ(gu��)��Q�StaticTest2 st = new StaticTest2(); 因�ؓmethod是static修饰�?静态方�?�Q�所以可以这栯��用：StaticTest2.()�?br />　　3. static�Ҏ(gu��)��:
　　static�Ҏ(gu��)��与非static�Ҏ(gu��)��的区别在�? static�Ҏ(gu��)��可以用类名直接访问在static内部的变量和�Ҏ(gu��)��Q�而不能引用非static的变量或者方法，但是你可以通过传递参数的方式传递一个引用，让这个引用去调用非静态数据�?br />　　4. static 接口:
　　内部接口(inner interface)本��n��默认是static�Q�所以static关键词加与不加都是一��L(f��ng)��Q?如此例中的接�?TestInInterface�Q�TestInClass 实现此接口，以下语句�Q?br />　　StaticDescription.TestInInterface a = new StaticDescription.TestInClass();
　　a.print();
　　我们��L��static关键字也是一��L(f��ng)��Q?但还是受讉K��权限控制TestInterface和FF�?br />　　5. static 修饰�c?
　　表示它是一个静态内部类�Q�它在引用外部类的事物时�Q�必��M��是static的。而且�Q?静态内部类在创��q��对象�Ӟ�� 是不需要外围类的存在。就好像下面的部分：
　　class Member {
　　static int classVar = 0; //�c�d��?br />　　int instanceVar; //实例变量
　　Member(int instanceVar) {
　　this.instanceVar = instanceVar;
　　}
　　static void setClassVar(int i) {
　　classVar=i;
　　//instanceVar=i; // �c�L��法不能访问实例变量，只能讉K��c�d��?br />　　}
　　static int getClassVar() {//�c�L��?br />　　return classVar;
　　}
　　void setInstanceVar(int i) {
　　classVar=i; //实例�Ҏ(gu��)��不但可以讉K��c�d��量，也可以实例变�?br />　　instanceVar=i;
　　}
　　int getInstanceVar() {
　　return instanceVar;
　　}
　　}
　　Member未实例化�Q?Member实例化之后：
1
　　对于非静态数据成员，每个�c�d��象都有自��q��拯��。而静态数据成员被当作是类的成员。无��个类的对象被定义了多��个�Q�静态数据成员在�E�序中也只有一份拷贝，��p��c�d��的所有对象共享访问。也��是��_��静态数据成员是该类的所有对象所共有的。对该类的多个对象来��_��静态数据成员只分配一�ơ内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一��L(f��ng)��Q�它的值可以更�?strong>托福�{�案
　　Member m1 = new Member();
　　Member m2 = new Member();
　　内存分配
2
　　引用static变量有两�U�方法。如前例所�C�，可以通过一个对象去定位它，如m1.classVar; 也可以通过其类名直接引用，如Member.classVar�Q�而对于非静态成员则不行�?br />　　��管当static作用于某个字�D�|��Q�肯定会改变数据的创建方�?因�ؓ一个static字段�Ҏ(gu��)��个类来说都只有一份存储空��_��而非static字段则是�Ҏ(gu��)��个对象都有一个存储空�?�Q�但是如果static用于某个�Ҏ(gu��)��Q�差别却没有那么大。static�Ҏ(gu��)��的一个重要用法就是在不创��Z�Q何对象的前提下就可以调用它。这一点，对定义main()�Ҏ(gu��)��很重要，�q�个�Ҏ(gu��)��是运行一个应用时的入口点�?br />　　static�Ҏ(gu��)��是没有this的方法。在static�Ҏ(gu��)��的内部不能调用非静态方法，反过来倒是可以的。而且可以在没有创��Z�Q何对象的前提下，仅仅通过�c�L��w�来调用static�Ҏ(gu��)��。这实际上正是static�Ҏ(gu��)��的主要用途。它很像全局�Ҏ(gu��)��。Java中禁止��用全局�Ҏ(gu��)��Q�但你在�c�M��|�入static�Ҏ(gu��)��可以访问其他static�Ҏ(gu��)��和static�?strong>托福�{�案
　　和其他�Q何方法一��P��static�Ҏ(gu��)��可以创徏或��用与其类型相同的被命名对象，因此�Q�static�Ҏ(gu��)��通常拿来�?#8220;牧羊�?#8221;的角�Ԍ��负责看护与其奴隶同一�c�d��的实例群�?br />　　不过�Q�要是在代码中出现大量的static�Ҏ(gu��)��Q�就该重新考虑自己的设计了

好不�Ҏ(gu��)�� 2014-08-25 21:54 发表评论

Java多线�E�中使用synchronized说明

好不�Ҏ(gu��)�� — Thu, 15 May 2014 03:35:00 GMT

　　1.在类中方法上加上
　　synchronized关键字，是对整个对象加锁�Q�当一个线�E�访问带有synchronized的方法时�Q�其他带有synchronized的方法的讉K��都会阻塞�?br />　　样例�Q?br />　　public class ThreadTest {
　　public static void main�Q�String[] args�Q?{
　　Stu stu = new Stu�Q�）�Q?br />　　StuThread1 t1 = new StuThread1�Q�stu�Q�；
　　t1.start�Q�）�Q?br />　　StuThread2 t2 = new StuThread2�Q�stu�Q�；
　　t2.start�Q�）�Q?br />　　}
　　}
　　class StuThread1 extends Thread {
　　Stu stu;
　　public StuThread1�Q�Stu stu�Q?{
　　this.stu = stu;
　　}
　　public void run�Q�） {
　　stu.read1�Q�）�Q?br />　　}
　　}
　　class StuThread2 extends Thread {
　　Stu stu;
　　public StuThread2�Q�Stu stu�Q?{
　　this.stu = stu;
　　}
　　public void run�Q�） {
　　stu.read2�Q�）�Q?br />　　}
　　}
　　class Stu {
　　public synchronized void read1�Q�） {
　　System.out.println�Q?read1 begin"�Q�；
　　try {
　　Thread.currentThread�Q�）。sleep�Q?000�Q�；
　　} catch �Q�InterruptedException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　}
　　System.out.println�Q?read1 end"�Q�；
　　}
　　public synchronized void read2�Q�） {
　　System.out.println�Q?read2 begin"�Q�；
　　try {
　　Thread.currentThread�Q�）。sleep�Q?000�Q�；
　　} catch �Q�InterruptedException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　}
　　System.out.println�Q?read2 end"�Q�；
　　}
　　}
　　打印�l�果为（两个�U�程是顺序执行的�Q�：
　　read1 begin
　　read1 end
　　read2 begin
　　read2 end
　　如果��L��read2前面的synchronized关键字，打印为（�U�程出现了交叉执行）�Q?br />　　read1 begin
　　read2 begin
　　read2 end
　　read1 end
　　修改read2�Ҏ(gu��)��Q?br />　　public void read2�Q�） {
　　synchronized�Q�this�Q?br />　　{
　　System.out.println�Q?read2 begin"�Q�；
　　try {
　　Thread.currentThread�Q�）。sleep�Q?000�Q�；
　　} catch �Q�InterruptedException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　}
　　System.out.println�Q?read2 end"�Q�；
　　}
　　}
　　对this�q�行加锁�Q�结果同一�ơ，�U�程是顺序执行的托福�{�案

好不�Ҏ(gu��)�� 2014-05-15 11:35 发表评论

好不�Ҏ(gu��)�� — Thu, 15 May 2014 03:29:00 GMT

　　Java实现快速批量移动文�?br />　　文�g�U�d��是计��机资源��理常用的一个操作，�q�在操作�pȝ��中可以通过文�g的剪切与复制或鼠标拖动来实现。但是在Java文�g的编�E�实��C��Q�大多是通过复制文�g到目的地�Q�再删除所有文件来实现的。这对于��文件来说看不出什么弊端，但是如果�U�d��几个大的文�g�Q�则会��操作�~�慢�q�且��费�pȝ��资源。本实例��通过File�cȝ��renameTo()�Ҏ(gu��)��直接实现文�g的快速移动，哪怕是�U�d��几GB的文件也不会需要等待太长时间�?br />　　思�\分析�Q?br />　　首先是视囑ֱ�。在�q�里有个��Q�因为在某些控�g的事件中�Q�常�怼�讉K��其他控�g�Q�且控�g的事件方法用到的参数几乎��是固定的ActionEvent�c�，很少传递别的参数。因此即使视图是用拖动控件自动生成的�Q�也要在代码中把�q�些控�g设�ؓ�cȝ��成员变量。在本实例中�Q�要用到JPanel控�g作�ؓ其他控�g的容器，JLabel控�g用来昄��固定信息�Q�JTextField控�g用来昄��要移动的文�g和目标文件夹�Q�JButton控�g用来选择源文件夹、目标文件夹以及实现�U�d��和关闭程序，JScrollPane用来昄��条�Ş柱，以及JTextArea控�g用来昄��操作记录托福�{�案
　　然后是模型层。对于浏览按钮，要获取源文�g夹中的文件名数组和目标文件夹的�\径，�q�就需要定义一个File型数�l�成员变量保存文件名�Q�再定义一个File型成员变量保存目标�\径�?br />　　选择源文件的��览按钮后，首先创徏一个JFileChooser文�g选择器，使用JFileChooser�cȝ��setMultiSelectionEnabled(true);�Ҏ(gu��)��讄��可以多选，通过JFileChooser�cȝ��showOpenDialog(this);�Ҏ(gu��)��昄��文�g选择对话框，若用��L(f��ng)��认则使用JFileChooser�cȝ��getSelectedFiles()�Ҏ(gu��)��获取选中的文件数�l��ƈ赋值给之前定义的File型数�l�成员变量，通过JTextField()�cȝ��setText("")�Ҏ(gu��)��清空文本框以除去上一�ơ操作的记录�Q�新��Z��个StringBuilder对象�Q��用foreach()循环遍历文�g数组�Q�通过StringBuilder�cȝ��append()�Ҏ(gu��)��q�接文�g名称�Q�因为最前面多了�?#8220;�?#8221;�Q�再使用StringBuilder�cȝ��substring()�Ҏ(gu��)��获取所有文件名�U�的字符�Ԍ��通过JTextFieldl�cȝ��setText()�Ҏ(gu��)��文件名�U�字�W�串昄��到文本框�?br />　　对于选择目标文�g夹的��览按钮�Q�首先创��Z��个JFileChooser文�g选择器，使用JFileChooser�cȝ��setFileSelectionMode()�Ҏ(gu��)��讄��选择器只�Ҏ(gu��)��件夹生效�Q�通过JFileChooser�cȝ��showOpenDialog()�Ҏ(gu��)��昄��文�g打开对话框，使用JFileChooser�cȝ��getSelectedFile()�Ҏ(gu��)��获取选择的文件夹�Q�最后用JTextField控�g的setText()�Ҏ(gu��)��昄��文�g夹到文本框�?br />　　对于�U�d��按钮的事件处理方法，首先使用数组的length属性判断文件数�l�有无元素，若有则��用foreach()循环遍历文�g数组�Q�对数组中的每一个文件元素创建移动目标文�Ӟ��通过JTextArea控�g的append()�Ҏ(gu��)��昄��U�d��记录�Q��用File�cȝ��renameTo()�Ҏ(gu��)��实现文�g�U�d��Q�最后��用JTextArea控�g的append()�Ҏ(gu��)��昄��U�d��完成信息�?br />　　对于关闭按钮的事件处理方法，使用System�cȝ��exit()�Ҏ(gu��)��退出程序�?br />　　代码如下�Q?br />　　import java.awt.EventQueue;
　　public class QuickMoveFiles extends JFrame {
　　/**
　　*
　　*/
　　private static final long serialVersionUID = -666045931923008374L;
　　private JPanel contentPane;
　　private JTextArea infoArea;
　　private JTextField sourceFolderField;
　　private JTextField targetFolderField;
　　private File[] files;
　　private File dir;
　　/**
　　* Launch the application.
　　*/
　　public static void main(String[] args) {
　　EventQueue.invokeLater(new Runnable() {
　　public void run() {
　　try {
　　QuickMoveFiles frame = new QuickMoveFiles();
　　frame.setVisible(true);
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　}
　　});
　　}
　　/**
　　* Create the frame.
　　*/
　　public QuickMoveFiles() {
　　setTitle("\u5FEB\u901F\u6279\u91CF\u79FB\u52A8\u6587\u4EF6");
　　setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
　　setBounds(100, 100, 507, 299);
　　contentPane = new JPanel();
　　contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
　　setContentPane(contentPane);
　　GridBagLayout gbl_contentPane = new GridBagLayout();
　　gbl_contentPane.columnWidths = new int[] { 0, 178, 0, 0, 0, 0 };
　　gbl_contentPane.rowHeights = new int[] { 0, 0, 169, 0, 0 };
　　gbl_contentPane.columnWeights = new double[] { 0.0, 1.0, 0.0, 0.0, 0.0,
　　Double.MIN_VALUE };
　　gbl_contentPane.rowWeights = new double[] { 0.0, 0.0, 1.0, 0.0,
　　Double.MIN_VALUE };
　　contentPane.setLayout(gbl_contentPane);
　　JLabel label = new JLabel("\u9009\u62E9\u6E90\u6587\u4EF6\uFF1A");
　　GridBagConstraints gbc_label = new GridBagConstraints();
　　gbc_label.anchor = GridBagConstraints.EAST;
　　gbc_label.insets = new Insets(0, 0, 5, 5);
　　gbc_label.gridx = 0;
　　gbc_label.gridy = 0;
　　contentPane.add(label, gbc_label);
　　sourceFolderField = new JTextField();
　　GridBagConstraints gbc_sourceFolderField = new GridBagConstraints();
　　gbc_sourceFolderField.gridwidth = 3;
　　gbc_sourceFolderField.insets = new Insets(0, 0, 5, 5);
　　gbc_sourceFolderField.fill = GridBagConstraints.HORIZONTAL;
　　gbc_sourceFolderField.gridx = 1;
　　gbc_sourceFolderField.gridy = 0;
　　contentPane.add(sourceFolderField, gbc_sourceFolderField);
　　sourceFolderField.setColumns(10);
　　JButton browserButton1 = new JButton("\u6D4F\u89C8");
　　browserButton1.addActionListener(new ActionListener() {
　　public void actionPerformed(ActionEvent e) {
　　do_browserButton1_actionPerformed(e);
　　}
　　});
　　GridBagConstraints gbc_browserButton1 = new GridBagConstraints();
　　gbc_browserButton1.insets = new Insets(0, 0, 5, 0);
　　gbc_browserButton1.gridx = 4;
　　gbc_browserButton1.gridy = 0;
　　contentPane.add(browserButton1, gbc_browserButton1);
　　JLabel label_1 = new JLabel(
　　"\u9009\u62E9\u76EE\u6807\u6587\u4EF6\u5939\uFF1A");
　　GridBagConstraints gbc_label_1 = new GridBagConstraints();
　　gbc_label_1.anchor = GridBagConstraints.EAST;
　　gbc_label_1.insets = new Insets(0, 0, 5, 5);
　　gbc_label_1.gridx = 0;
　　gbc_label_1.gridy = 1;
　　contentPane.add(label_1, gbc_label_1);
　　targetFolderField = new JTextField();
　　GridBagConstraints gbc_targetFolderField = new GridBagConstraints();
　　gbc_targetFolderField.gridwidth = 3;
　　gbc_targetFolderField.insets = new Insets(0, 0, 5, 5);
　　gbc_targetFolderField.fill = GridBagConstraints.HORIZONTAL;
　　gbc_targetFolderField.gridx = 1;
　　gbc_targetFolderField.gridy = 1;
　　contentPane.add(targetFolderField, gbc_targetFolderField);
　　targetFolderField.setColumns(10);
　　JButton browserButton2 = new JButton("\u6D4F\u89C8");
　　browserButton2.addActionListener(new ActionListener() {
　　public void actionPerformed(ActionEvent e) {
　　do_browserButton2_actionPerformed(e);
　　}
　　});
　　GridBagConstraints gbc_browserButton2 = new GridBagConstraints();
　　gbc_browserButton2.insets = new Insets(0, 0, 5, 0);
　　gbc_browserButton2.gridx = 4;
　　gbc_browserButton2.gridy = 1;
　　contentPane.add(browserButton2, gbc_browserButton2);
　　JLabel label_2 = new JLabel("\u64CD\u4F5C\u8BB0\u5F55\uFF1A");
　　GridBagConstraints gbc_label_2 = new GridBagConstraints();
　　gbc_label_2.anchor = GridBagConstraints.EAST;
　　gbc_label_2.insets = new Insets(0, 0, 5, 5);
　　gbc_label_2.gridx = 0;
　　gbc_label_2.gridy = 2;
　　contentPane.add(label_2, gbc_label_2);
　　JScrollPane scrollPane = new JScrollPane();
　　GridBagConstraints gbc_scrollPane = new GridBagConstraints();
　　gbc_scrollPane.gridwidth = 4;
　　gbc_scrollPane.insets = new Insets(0, 0, 5, 0);
　　gbc_scrollPane.fill = GridBagConstraints.BOTH;
　　gbc_scrollPane.gridx = 1;
　　gbc_scrollPane.gridy = 2;
　　contentPane.add(scrollPane, gbc_scrollPane);
　　infoArea = new JTextArea();
　　scrollPane.setViewportView(infoArea);
　　JButton moveButton = new JButton("\u79FB\u52A8");
　　moveButton.addActionListener(new ActionListener() {
　　public void actionPerformed(ActionEvent e) {
　　do_moveButton_actionPerformed(e);
　　}
　　});
　　GridBagConstraints gbc_moveButton = new GridBagConstraints();
　　gbc_moveButton.insets = new Insets(0, 0, 0, 5);
　　gbc_moveButton.gridx = 1;
　　gbc_moveButton.gridy = 3;
　　contentPane.add(moveButton, gbc_moveButton);
　　JButton closeButton = new JButton("\u5173\u95ED");
　　closeButton.addActionListener(new ActionListener() {
　　public void actionPerformed(ActionEvent e) {
　　do_closeButton_actionPerformed(e);
　　}
　　});
　　GridBagConstraints gbc_closeButton = new GridBagConstraints();
　　gbc_closeButton.insets = new Insets(0, 0, 0, 5);
　　gbc_closeButton.gridx = 2;
　　gbc_closeButton.gridy = 3;
　　contentPane.add(closeButton, gbc_closeButton);
　　}
　　/**
　　* 选择源文件的��览按钮
　　*
　　* @param e
　　*/
　　protected void do_browserButton1_actionPerformed(ActionEvent e) {
　　JFileChooser chooser = new JFileChooser();// 创徏文�g选择�?br />　　chooser.setMultiSelectionEnabled(true);// 讄��文�g多�?br />　　int option = chooser.showOpenDialog(this);// 昄��文�g打开对话�?br />　　if (option == JFileChooser.APPROVE_OPTION) {
　　files = chooser.getSelectedFiles();// 获取选择的文件数�l?br />　　sourceFolderField.setText("");// 清空文本�?br />　　StringBuilder filesStr = new StringBuilder();
　　for (File file : files) {// 遍历文�g数组托福�{�案
　　filesStr.append("�? + file.getName());// �q�接文�g名称
　　}
　　String str = filesStr.substring(1);// 获取所有文件名�U�的字符�?br />　　sourceFolderField.setText(str);// 讄��文�g名称信息到文本框
　　} else {
　　files = new File[0];
　　sourceFolderField.setText("");// 清空文本�?br />　　}
　　}
　　/**
　　* 选择目标文�g夹的��览按钮
　　*
　　* @param e
　　*/
　　protected void do_browserButton2_actionPerformed(ActionEvent e) {
　　JFileChooser chooser = new JFileChooser();// 创徏文�g选择�?br />　　// 讄��选择器只针对文�g夹生�?br />　　chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
　　int option = chooser.showOpenDialog(this);// 昄��文�g打开对话�?br />　　if (option == JFileChooser.APPROVE_OPTION) {
　　dir = chooser.getSelectedFile();// 获取选择的文件夹
　　targetFolderField.setText(dir.toString());// 昄��文�g夹到文本�?br />　　} else {
　　dir = null;
　　targetFolderField.setText("");
　　}
　　}
　　/**
　　* 关闭按钮的事件处理方�?br />　　*
　　* @param e
　　*/
　　protected void do_closeButton_actionPerformed(ActionEvent e) {
　　System.exit(0);
　　}
　　/**
　　* �U�d��按钮的事件处理方�?br />　　*
　　* @param e
　　*/
　　protected void do_moveButton_actionPerformed(ActionEvent e) {
　　if (files.length <= 0 || dir == null)// 判断文�g数组有无元素
　　return;
　　for (File file : files) {// 遍历文�g数组托福�{�案
　　File newFile = new File(dir, file.getName());// 创徏�U�d��目标文�g
　　infoArea.append(file.getName() + "\t�U�d��到\t" + dir);// 昄��U�d��记录
　　file.renameTo(newFile);// 文�g�U�d��
　　infoArea.append("------完成\n");// 昄��U�d��完成信息
　　}
　　// 昄��操作完成
　　infoArea.append("##################操作完成###################\n");
　　}
　　}

好不�Ҏ(gu��)�� 2014-05-15 11:29 发表评论

好不�Ҏ(gu��)�� — Sat, 26 Apr 2014 05:38:00 GMT

　　一、线�E�的学习(f��n)
　　�U�程��是�E�序中执行单个�Q务的��序的流�E��?br />　　�U�程创徏的两�U�方式：
　　1、��承Thread�c?br />　　publicstaticvoidmain�Q�String[]args�Q?br />　　{
　　//�l�承Thread�c�覆盖父�c�run�Ҏ(gu��)��
　　Threadthread=newThread�Q�）
　　{
　　@Override
　　publicvoidrun�Q�）
　　{
　　while�Q�true�Q?br />　　{
　　System.out.println�Q�Thread.currentThread�Q�）。getName�Q�）�Q�；
　　}
　　}
　　};
　　thread.start�Q�）�Q?br />　　}
　　2、实现Runnable接口的run�Ҏ(gu��)��
　　publicstaticvoidmain�Q�String[]args�Q?br />　　{
　　Threadthread=newThread�Q�newRunnable�Q�）
　　{
　　@Override
　　publicvoidrun�Q�）
　　{
　　while�Q�true�Q?br />　　{
　　System.out.println�Q�Thread.currentThread�Q�）。getName�Q�）�Q�；
　　}
　　}
　　}�Q�；
　　thread.start�Q�）�Q?br />　　}
　　�ȝ��Q�以上是Java实现多线�E�的两种方式�Q��承Thread�c�d��Runnable接口�Q�由于Java�cȝ��单��承性，接口又可以实现多�l�承以及使用Runnable接口可以很好地将需要执行的��d��代码与线�E�类分离�Q�所以推荐��用实现Runnable接口的方法去实现多��ѝ��但不管怎样最�l�都需要��用Thread.start�Q�）�Ҏ(gu��)��来�ɾU�程处于可运行状态吐舌头
　　3、线�E�中start�Q�） �Ҏ(gu��)��与run�Q�） �Ҏ(gu��)��的区�?strong>托福�{�案
　　1、start�Q�）�Ҏ(gu��)��
　　调用start�Q�）�Ҏ(gu��)��是��Z��告诉�pȝ��我这儿有一个线�E�已�l�处于可�q�行状态，�q�没有开始运行，如果cpu分配了时间片�Q�那么JVM��׃��调用本线�E�的run�Q�）�Ҏ(gu��)��来运行线�E�；run�Q�）�Ҏ(gu��)��一旦执行结束，则本�U�程�l�止�?br />　　2、run�Q�）�Ҏ(gu��)��
　　run�Q�）�Ҏ(gu��)��只是�cȝ��一个普通方法，如果直接调用run�Q�）�Ҏ(gu��)��Q�那么程序中只会存在一个主�U�程�Q�在调用run�Q�）�Ҏ(gu��)��以后的代码，必须�{�待run�Q�）�Ҏ(gu��)��执行完成后才能执行，直接调用其他普通方法一��h��有区�?strong>雅思答�?/font>
　　�ȝ��Q�调用start�Q�）�Ҏ(gu��)��可以开启一个新的线�E�，�q�在新的�U�程中运行run�Q�）�Ҏ(gu��)��Q�而直接调用run�Q�）�Ҏ(gu��)��则不会开启新�U�程�Q�run�Q�）�Ҏ(gu��)��q�是执行于主�U�程中�?br />　　4.�U�程的运行结�?br />　　public static void main�Q�String[] args�Q?br />　　{
　　Thread thread = new Thread�Q�new Runnable�Q�）
　　{
　　//实现了Runnable接口的run�Q�）�Ҏ(gu��)��
　　@Override
　　public void run�Q�）
　　{
　　System.out.println�Q?Runnable:" + Thread.currentThread�Q�）。getName�Q�）�Q�；
　　}
　　}�Q?br />　　{
　　//�l�承了Thread�c?�q�覆盖了Thread�cȝ��run�Q�）�Ҏ(gu��)��
　　@Override
　　public void run�Q�）
　　{
　　System.out.println�Q?Thread:" + Thread.currentThread�Q�）。getName�Q�）�Q�；
　　}
　　};
　　thread.start�Q�）�Q?br />　　}

　　�ȝ��Q�Thread的子�c�覆盖了父类的run�Q�）�Ҏ(gu��)��Q�所以执行了子类的run�Q�）�Ҏ(gu��)��Q�在子类的run�Q�）�Ҏ(gu��)��中又没有调用传入的接口实现类的run�Q�）�Ҏ(gu��)��?/p>

好不�Ҏ(gu��)�� 2014-04-26 13:38 发表评论

好不�Ҏ(gu��)�� — Sat, 26 Apr 2014 05:33:00 GMT

　　要求
　　�l�定一没有重复元素的旋转数�l�（它对应的原数�l�是有序的）�Q�求�l�定元素在旋转数�l�内的下标（不存在的�q�回-1�Q��?br />　　例如
　　有序数组为{0,1,2,4,5,6,7},它的一个旋转数�l��ؓ{4,5,6,7,0,1,2}.
　　元素6在旋转数�l�内�Q�返�?
　　元素3不在旋�{数组内，�q�回-1
　　分析托福�{�案
　　遍历一遍，可以��L��搞定�Q�时间复杂度为O�Q�n�Q�，因�ؓ是有序数�l�旋转得刎ͼ��q�样做肯定不是最优解。有序，本能反映用二分查找，举个例子看看特点
　　可以看出中间位置两段��L(f��ng)��有一个是有序的（不是左边�Q�就是右边）�Q�那么就可以在有序的范围内��用二分查找；如果不再有序范围内，��到另一半去找�?br />　　参考代�?br />　　复制代码
　　int search�Q�int A[], int n, int target�Q?{
　　int beg = 0;
　　int end = n - 1;
　　while �Q�beg <= end�Q?br />　　{
　　int mid = beg + �Q�end - beg�Q?/ 2;
　　if�Q�A[mid] == target�Q?br />　　return mid;
　　if�Q�A[beg] <= A[mid]�Q?br />　　{
　　if�Q�A[beg] <= target && target < A[mid]�Q?br />　　end = mid - 1;
　　else
　　beg = mid + 1;
　　}
　　else
　　{
　　if�Q�A[mid] < target && target <= A[end]�Q?br />　　beg = mid + 1;
　　else
　　end = mid - 1;
　　}
　　}
　　return -1;
　　}
　　复制代码
　　扩展
　　上边的有求是没有重复的元素，现在�E�微扩展下，可以有重复的元素�Q�其他的要求不变�?br />　　思�\雅思答�?/font>
　　大致思�\与原来相同，�q�是需要比较A[beg] �?A[mid]的关�p?br />　　A[beg] < A[mid] ----左边有序
　　A[beg] > A[mid] ----双��有序
　　A[beg] = A[mid] ----++beg
　　复制代码
　　bool search�Q�int A[], int n, int target�Q?{
　　int beg = 0;
　　int end = n - 1;
　　while �Q�beg <= end�Q?br />　　{
　　int mid = beg + �Q�end - beg�Q?/ 2;
　　if�Q�A[mid] == target�Q?br />　　return true;
　　if�Q�A[beg] < A[mid]�Q?br />　　{
　　if�Q�A[beg] <= target && target < A[mid]�Q?br />　　end = mid - 1;
　　else
　　beg = mid + 1;
　　}
　　else if�Q�A[beg] > A[mid]�Q?br />　　{
　　if�Q�A[mid] < target && target <= A[end]�Q?br />　　beg = mid + 1;
　　else
　　end = mid - 1;
　　}
　　else
　　++beg;
　　}
　　return false;
　　}

好不�Ҏ(gu��)�� 2014-04-26 13:33 发表评论

java web�pȝ��U�初始化工作

好不�Ҏ(gu��)�� — Sun, 20 Apr 2014 01:23:00 GMT

　　通常我们在做web开发时�Q�有些系�l��参数希望在web启动时就�q�行一�ơ性初始化�Q�供整个工程调用使用。如�Q�系�l�配�|�参敎ͼ��可以结合hibernate二��~�存�Q�进行一�ơ性获取�ƈ�q�行�׃�n。这时就可以采用监听�?br />　　ServletContext �?Servlet �E�序用来�?Web 容器通信。例如写日志�Q��{发请求。每一�?Web 应用�E�序含有一个Context,被Web应用内的各个�E�序�׃�n。因为Context可以用来保存资源�q�且�׃�n�Q�所以我所知道�?ServletContext 的最大应用是Web�~�存----把不�l�常更改的内容读入内存，所以服务器响应��h��的时候就不需要进行慢速的��盘I(y��)/O了�?br />　　ServletContextListener �?ServletContext 的监听者，如果 ServletContext 发生变化�Q�如服务器启动时 ServletContext 被创建，服务器关闭时 ServletContext ��要被销毁�?br />　　在JSP文�g中，application �?ServletContext 的实例，由JSP容器默认创徏。Servlet 中调�?getServletContext�Q�）�Ҏ(gu��)��得到 ServletContext 的实例�?br />　　我们使用�~�存的思�\大概是：
　　服务器启动时�Q�ServletContextListener �?contextInitialized�Q�）�Ҏ(gu��)��被调用，所以在里面创徏好缓存。可以从文�g中或者从数据库中��d��取缓存内容生成类�Q�用 ervletContext.setAttribute�Q�）�Ҏ(gu��)��缓存类保存�?ServletContext 的实例中�?br />　　�E�序使用 ServletContext.getAttribute�Q�）��d��~�存。如果是 JSP,使用a pplication.getAttribute�Q�）。如果是 Servlet,使用 getServletContext�Q�）。getAttribute�Q�）。如果缓存发生变化（如访问计敎ͼ��Q�你可以同时更改�~�存和文�?数据库。或者你�{�变化积累到一定程序再保存�Q�也可以在下一步保�?strong>托福�{�案
　　服务器将要关闭时�Q�ServletContextListener �?contextDestroyed�Q�）�Ҏ(gu��)��被调用，所以在里面保存�~�存的更攏V��将更改后的�~�存保存回文件或者数据库�Q�更新原来的内容�?br />　　利用Servlet 容器的特性我们可以更优雅的实现系�l�的初始化工作�?我们可以写一个listener让它实现ServletContextListener接口�Q�在contextInitialized�Q�）�Ҏ(gu��)��中做惛_��的事情。将此listener配置到web.xml中，Servlet容器如tomcat会在启动该web应用�E�序时调用此�Ҏ(gu��)��?br />　　1. projectInit.java 文�g
　　package com.zzcatv.util;
　　import javax.servlet.ServletContextEvent;
　　import javax.servlet.ServletContextListener;
　　import javax.servlet.http.HttpServletRequest;
　　public class projectInit implements ServletContextListener {
　　HttpServletRequest request;
　　public void contextDestroyed�Q�ServletContextEvent arg0�Q?{
　　// TODO Auto-generated method stub
　　System.out.println�Q?==========初始化信息进行销�?========="�Q�；
　　}
　　public void contextInitialized�Q�ServletContextEvent arg0�Q?{
　　// TODO Auto-generated method stub
　　System.out.println�Q?==========�pȝ��初始�?========="�Q�；
　　request.getSession�Q�）。setAttribute�Q?User", "yangguozhi"�Q�；
　　// 初始化系�l�全局变量
　　// …
　　// 加蝲自定义配�|�文�?br />　　// …
　　// 启动定时��d��
　　// …
　　}
　　}
　　2.web.xml
　　com.zzcatv.util.projectInit
　　以上��实��C��pȝ��的初始化工作�?/p>

好不�Ҏ(gu��)�� 2014-04-20 09:23 发表评论

Java中测试异常的多种方式

好不�Ҏ(gu��)�� — Sun, 20 Apr 2014 01:20:00 GMT

　　使用JUnit来测试Java代码中的异常有很多种方式�Q�你知道几种�Q?br />　　�l�定�q�样一个class.
　　Person.java
　　public class Person {
　　private String name;
　　private int age;
　　public String getName�Q�） {
　　return name;
　　}
　　public void setName�Q�String name�Q?{
　　this.name = name;
　　}
　　public int getAge�Q�） {
　　return age;
　　}
　　public void setAge�Q�int age�Q?{
　　if �Q�age < 0 �Q?{
　　throw new IllegalArgumentException�Q?age is invalid"�Q�；
　　}
　　this.age = age;
　　}
　　}
　　我们来测试setAge�Ҏ(gu��)��?br />　　Try-catch 方式
　　@Test
　　public void shouldGetExceptionWhenAgeLessThan0�Q�） {
　　Person person = new Person�Q�）�Q?br />　　try {
　　person.setAge�Q?1�Q�；
　　fail�Q?should get IllegalArgumentException"�Q�；
　　} catch �Q�IllegalArgumentException ex�Q?{
　　assertThat�Q�ex.getMessage�Q�）�Q�containsString�Q?age is invalid"�Q�）�Q?br />　　}
　　}
　　�q�是最�Ҏ(gu��)��惛_��的一�U�方式，但是太啰嗦�?br />　　JUnit annotation方式托福�{�案 www.qcwy123.com
　　JUnit中提供了一个expected的annotation来检查异常�?br />　　@Test�Q�expected = IllegalArgumentException.class�Q?br />　　public void shouldGetExceptionWhenAgeLessThan0�Q�） {
　　Person person = new Person�Q�）�Q?br />　　person.setAge�Q?1�Q�；
　　}
　　�q�种方式看�v来要��z�多了，但是无法��查异�怸�的消息�?br />　　ExpectedException rule
　　JUnit7以后提供了一个叫做ExpectedException的Rule来实现对异常的测试�?br />　　@Rule
　　public ExpectedException exception = ExpectedException.none�Q�）�Q?br />　　@Test
　　public void shouldGetExceptionWhenAgeLessThan0�Q�） {
　　Person person = new Person�Q�）�Q?br />　　exception.expect�Q�IllegalArgumentException.class�Q�；
　　exception.expectMessage�Q�containsString�Q?age is invalid"�Q�）�Q?br />　　person.setAge�Q?1�Q�；
　　}
　　�q�种方式既可以检查异常类型，也可以验证异�怸�的消息�?br />　　使用catch-exception�?br />　　有个catch-exception库也可以实现对异常的��试�?br />　　首先引用该库�?br />　　pom.xml
　　
　　com.googlecode.catch-exception
　　catch-exception
　　1.2.0
　　test
　　
　　然后�q�样书写��试�?br />　　@Test
　　public void shouldGetExceptionWhenAgeLessThan0�Q�） {
　　Person person = new Person�Q�）�Q?br />　　catchException�Q�person�Q�。setAge�Q?1�Q�；
　　assertThat�Q�caughtException�Q�）�Q�instanceOf�Q�IllegalArgumentException.class�Q�）�Q?br />　　assertThat�Q�caughtException�Q�）。getMessage�Q�）�Q?containsString�Q?age is invalid"�Q�）�Q?br />　　}
　　�q�样的好处是可以�_�և�的验证异常是被测�Ҏ(gu��)��抛出来的�Q�而不是其它方法抛出来的�?br />　　catch-exception库还提供了多�U�API来进行测�?strong>雅思答�?/font> www.tygj123.com
　　先加载fest-assertion库�?br />　　
　　org.easytesting
　　fest-assert-core
　　2.0M10
　　
　　然后可以书写BDD风格的测试�?br />　　@Test
　　public void shouldGetExceptionWhenAgeLessThan0�Q�） {
　　// given
　　Person person = new Person�Q�）�Q?br />　　// when
　　when�Q�person�Q�。setAge�Q?1�Q�；
　　// then
　　then�Q�caughtException�Q�）�Q?br />　　.isInstanceOf�Q�IllegalArgumentException.class�Q?br />　　.hasMessage�Q?age is invalid"�Q?br />　　.hasNoCause�Q�）�Q?br />　　}
　　如果喜欢Hamcrest风格的验证风格的话，catch-exception也提供了相应的Matcher API.
　　@Test
　　public void shouldGetExceptionWhenAgeLessThan0�Q�） {
　　// given
　　Person person = new Person�Q�）�Q?br />　　// when
　　when�Q�person�Q�。setAge�Q?1�Q�；
　　// then
　　assertThat�Q�caughtException�Q�）�Q?allOf�Q?br />　　instanceOf�Q�IllegalArgumentException.class�Q?br />　　, hasMessage�Q?age is invalid"�Q?br />　　,hasNoCause�Q�）�Q�）�Q?br />　　}
　　�W�一�U�最土鳖�Q�第二种最��z�，�W�四�U�最靠谱�?/p>

好不�Ҏ(gu��)�� 2014-04-20 09:20 发表评论

好不�Ҏ(gu��)�� — Fri, 04 Apr 2014 01:29:00 GMT

　　Java的反��破坏单例的�U�有构造函��C��护，最典型的就是Spring的Bean注入�Q�我们可以通过攚w��私有构造函数来防止�?br />　　在Singleton中，我们只对外提供工厂方法（获取单例�Q�，而私有化构造函敎ͼ�来防止外面多余的创徏�?br />　　对于一般的外部调用来说�Q�私有构造函数已�l�很安全了�?br />　　public class Singleton {
　　private Singleton�Q�）{}
　　private static volatile Singleton instance = null;
　　public static SingletongetInstance�Q�） throws Exception {
　　if �Q�instance ==null�Q?{ //��Z��z�度�Q�暂不考虑�U�程安全
　　instance =new Singleton�Q�）�Q?br />　　}
　　returninstance;
　　}
　　}
　　Class singletonClass = Class.forName�Q?com.jscai.spring.demo.Singleton"�Q�；
　　Constructor[] cts =singletonClass.getConstructors�Q�）�Q?br />　　System.out.println�Q�cts.length�Q?www.yztrans.com
　　一般的外部调用�Q�编译器会校验，直接提示�~�译错误。而正常的反射也是找不到私有构造函数的�Q�所以上面的输出�?.
　　但是一些特权用户可以通过反射来访问私有构造函敎ͼ��q�且实例化：
　　Constructor[] cts = singletonClass.getDeclaredConstructors�Q�）�Q?br />　　System.out.println�Q�cts.length�Q�；
　　cts[0].setAccessible�Q�true�Q�；
　　Singletonsingleton = �Q�Singleton�Q?cts[0].newInstance�Q�）�Q?br />　　上述代码首先通过反射的getDeclaredConstructors�Q�）来获取所有构造函敎ͼ�public,protected,default * �Q�package�Q?access, andprivate constructors�Q�，当然�q�个函数会校验调用者的权限�?br />　　此时默认�q�是不能调用�U�有构造函数的�Q�还需要把讉K��权限打开setAccessible�Q�true�Q�，��可以访问私有构造函��C��Q�这��L(f��ng)��坏了单例的私有构造函��C��护�?br />　　如果要防御这��L(f��ng)��反射侵入�Q�可以修�Ҏ(gu��)��造函敎ͼ�加上�W�二�ơ实例化的检查。（上面的getInstance�Q�）�l�过多线�E�（DoubleCheck�Q�处理后�Q�就不会出现�U�程冲突来触发这个异常）
　　private static int cntInstance = 0;
　　private Singleton�Q�）throws Exception {
　　if �Q?+cntInstance > 1 �Q?{
　　throw new Exception�Q?Can'tcreate another instance."�Q�；
　　}
　　}
　　另外�Q�在Spring的Bean注入中，即��你私有化构造函敎ͼ�默认他还是会去调用你的私有构造函数去实例化�?【通过BeanFactory来装配Bean,和上面的逻辑如出一辙�?br />　　所以，如果我们想保证实例的单一性，��p��在定�?lt;bean>时加上factory-method=""的属性，�q�且在私有构造函��C��d��防�M机制。单例的getInstance�Q�）可能会添加一些逻辑�Q�而Spring的默认调用构造函数去创徏�Q�就不能保证�q�䆾逻辑的准��性，所以会带来隐�?zh��n)��?br />　　我们可以通过scope="prototype"来测试单例是否被多次创徏�Q?br />　　
　　BeanFactory bf = new ClassPathXmlApplicationContext�Q?demoAppTestContext.xml"�Q�；
　　Singleton test1 = �Q�Singleton�Q?bf.getBean�Q?singleton"�Q�；
　　Singleton test2 = �Q�Singleton�Q?bf.getBean�Q?singleton"�Q�；
　　发现防�M机制生效�Q�抛�?Can't create another instance."的异常，证明Spring能正常调用私有的构造函数来创徏Bean,�q�且创徏了多�ơ�?br />　　�q�时候我们要使用factory-method来指定工厂方法，才能辑ֈ�我们惌��的效�?www.tygj123.com
　　

好不�Ҏ(gu��)�� 2014-04-04 09:29 发表评论

好不�Ҏ(gu��)�� — Sun, 23 Mar 2014 01:54:00 GMT

　　java写入文�g的几�U�方法小�l?br />　　一�Q�FileWritter写入文�g
　　FileWritter, 字符��写入字�W�到文�g。默认情况下�Q�它会��用新的内容取代所有现有的内容�Q�然而，当指定一个true �Q�布?y��u)��(d��ng)）��g��为FileWritter构造函数的�W�二个参敎ͼ�它会保留现有的内容，�q�追加新内容在文件的末尾 www.jx-jf.com
　　1. 替换所有现有的内容与新的内宏V�?br />　　new FileWriter�Q�file�Q�；2. 保留现有的内容和附加在该文�g的末��新内宏V�?br />　　代码如下
　　new FileWriter�Q�file,true�Q�；
　　�q�加文�g�C�Z��
　　一个文本文�Ӟ��命名�?javaio-appendfile.txt",�q�包含以下内宏V�?br />　　ABC Hello�q�加新内�?new FileWriter�Q�file,true�Q?br />　　代码如下
　　package com.yiibai.file;
　　import java.io.File;
　　import java.io.FileWriter;
　　import java.io.BufferedWriter;
　　import java.io.IOException;
　　public class AppendToFileExample
　　{
　　public static void main�Q?String[] args �Q?br />　　{
　　try{
　　String data = " This content will append to the end of the file";
　　File file =new File�Q?javaio-appendfile.txt"�Q�；
　　//if file doesnt exists, then create it
　　if�Q�！file.exists�Q�）�Q�{
　　file.createNewFile�Q�）�Q?br />　　}
　　//true = append file
　　FileWriter fileWritter = new FileWriter�Q�file.getName�Q�）�Q�true�Q�；
　　BufferedWriter bufferWritter = new BufferedWriter�Q�fileWritter�Q�；
　　bufferWritter.write�Q�data�Q�；
　　bufferWritter.close�Q�）�Q?br />　　System.out.println�Q?Done"�Q�；
　　}catch�Q�IOException e�Q�{
　　e.printStackTrace�Q�）�Q?br />　　}
　　}
　　}
　　�l�果
　　现在�Q�文本文�?javaio-appendfile.txt"内容更新如下�Q?br />　　ABC Hello This content will append to the end of the file
　　二，BufferedWriter写入文�g
　　�~�冲字符�Q�BufferedWriter �Q�是一个字�W�流�c�L��处理字符数据。不同于字节��（数据转换成字节）�Q�你可以直接写字�W�串�Q�数�l�或字符数据保存到文件�?br />　　代码如下
　　package com.yiibai.iofile;
　　import java.io.BufferedWriter;
　　import java.io.File;
　　import java.io.FileWriter;
　　import java.io.IOException;
　　public class WriteToFileExample {
　　public static void main�Q�String[] args�Q?{
　　try {
　　String content = "This is the content to write into file";
　　File file = new File�Q?/users/mkyong/filename.txt"�Q�；
　　// if file doesnt exists, then create it
　　if �Q�！file.exists�Q�）�Q?{
　　file.createNewFile�Q�）�Q?br />　　}
　　FileWriter fw = new FileWriter�Q�file.getAbsoluteFile�Q�）�Q�；
　　BufferedWriter bw = new BufferedWriter�Q�fw�Q�；
　　bw.write�Q�content�Q�；
　　bw.close�Q�）�Q?br />　　System.out.println�Q?Done"�Q�；
　　} catch �Q�IOException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　}
　　}
　　}
　　三，FileOutputStream写入文�g www.jx-jf.com
　　文�g输出��是一�U�用于处理原始二�q�制数据的字节流�c�R��ؓ了将数据写入到文件中�Q�必��d��数据转换为字节，�q�保存到文�g。请参阅下面的完整的例子�?br />　　代码如下
　　package com.yiibai.io;
　　import java.io.File;
　　import java.io.FileOutputStream;
　　import java.io.IOException;
　　public class WriteFileExample {
　　public static void main�Q�String[] args�Q?{
　　FileOutputStream fop = null;
　　File file;
　　String content = "This is the text content";
　　try {
　　file = new File�Q?c:/newfile.txt"�Q�；
　　fop = new FileOutputStream�Q�file�Q�；
　　// if file doesnt exists, then create it
　　if �Q�！file.exists�Q�）�Q?{
　　file.createNewFile�Q�）�Q?br />　　}
　　// get the content in bytes
　　byte[] contentInBytes = content.getBytes�Q�）�Q?br />　　fop.write�Q�contentInBytes�Q�；
　　fop.flush�Q�）�Q?br />　　fop.close�Q�）�Q?br />　　System.out.println�Q?Done"�Q�；
　　} catch �Q�IOException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　} finally {
　　try {
　　if �Q�fop != null�Q?{
　　fop.close�Q�）�Q?br />　　}
　　} catch �Q�IOException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　}
　　}
　　}
　　}
　　更新的JDK7例如�Q�www.111cn.net使用新的"��试资源关闭"的方法来��L��处理文�g�?br />　　package com.yiibai.io;
　　import java.io.File;
　　import java.io.FileOutputStream;
　　import java.io.IOException;
　　public class WriteFileExample {
　　public static void main�Q�String[] args�Q?{
　　File file = new File�Q?c:/newfile.txt"�Q�；
　　String content = "This is the text content";
　　try �Q�FileOutputStream fop = new FileOutputStream�Q�file�Q�） {
　　// if file doesn't exists, then create it
　　if �Q�！file.exists�Q�）�Q?{
　　file.createNewFile�Q�）�Q?br />　　}
　　// get the content in bytes
　　byte[] contentInBytes = content.getBytes�Q�）�Q?br />　　fop.write�Q�contentInBytes�Q�；
　　fop.flush�Q�）�Q?br />　　fop.close�Q�）�Q?br />　　System.out.println�Q?Done"�Q�；
　　} catch �Q�IOException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　}
　　}
　　}

好不�Ҏ(gu��)�� 2014-03-23 09:54 发表评论

java中接口之间的�l�承

好不�Ҏ(gu��)�� — Sun, 23 Mar 2014 01:49:00 GMT

　　最�q�在��M��些源码的时候突然发��C��一个很��奇的东西，它的原始形态是�q�样的：
　　在这行代码中�Q�BlockingDeque、BlockingQueue和Deque是三个接口。刚发现�q�个问题�Ӟ��我是十分吃惊的，因�ؓ即��在《Thinking in Java》中也没有提到接口之间的�l�承。所以我立即把这个疑问提交到了stackoverflow上面�?br />　　正如在stackoverflow上面所讨论的一��P��一个类只能extends一个父�c�，但可以implements多个接口。java通过使用接口的概忉|��取代C++中多�l�承。与此同�Ӟ��一个接口则可以同时extends多个接口�Q�却不能implements��M��接口。因而，Java中的接口是支持多�l�承的�?br />　　然后我又做了个实验，来验证如果多个父子接口中有多个相同的�Ҏ(gu��)��声明�Q�然后在实现�q�个最�l�的接口的时候，相同的方法声明在实现的时候会不会有冲�H�呢�Q?br />　　首先写了个接口：TestInterfaceA.java:
　　1 package com.peter.java.dsa.interfaces;
　　2
　　3 public interface TestInterfaceA {
　　4 String pri_key = "guess what the private key is";
　　5
　　6 int add�Q�int x, int y�Q�；
　　7
　　8 String encryt�Q�byte[] result�Q�；
　　9
　　10 int get�Q�）�Q?br />　　11 }
　　注意�Q�里面声明了三个�Ҏ(gu��)��和一个变量；
　　然后再与了一个接口：TestInterfaceB.java:
　　1 package com.peter.java.dsa.interfaces;
　　2
　　3 public interface TestInterfaceB {
　　4 String pub_key = "guess what the public key is";
　　5
　　6 int minus�Q�int x, int y�Q�；
　　7
　　8 byte[] decryt�Q�String src�Q�；
　　9
　　10 int get�Q�）�Q?br />　　11 }
　　里面也声明了三个�Ҏ(gu��)��和一个变量；
　　然后再定义了一个接口InterfaceMultiInheritance.java同时�l�承了接口TestInterfaceA.java和接口TestInterfaceB.java:
　　1 package com.peter.java.dsa.interfaces;
　　2
　　3 public interface InterfaceMultiInheritance extends TestInterfaceA,
　　4 TestInterfaceB {
　　5 int num = 1024;
　　6
　　7 double divide�Q�int x, int y�Q�；
　　8
　　9 int get�Q�）�Q?br />　　10 }
　　里面声明了两个方法和一个变量；
　　注意�Q�在�q�三个接口中�Q�有一个共同的�Ҏ(gu��)��声明�Q�get�Q�）。这个都是要讨论的主题�?br />　　最后在一个类InterfaceImplementTest.java中实��C��接口InterfaceMultiInheritance.java,源码如下�Q?br />　　1 package com.peter.java.dsa.common;
　　2
　　3 import com.peter.java.dsa.interfaces.InterfaceMultiInheritance;
　　4 import com.sun.org.apache.xml.internal.security.exceptions.Base64DecodingException;
　　5 import com.sun.org.apache.xml.internal.security.utils.Base64;
　　6
　　7 public class InterfaceImplementTest implements InterfaceMultiInheritance {
　　8
　　9 @Override
　　10 public int add�Q�int x, int y�Q?{
　　11 // TODO Auto-generated method stub
　　12 return x + y;
　　13 }
　　14
　　15 @Override
　　16 public String encryt�Q�byte[] result�Q?{
　　17 // TODO Auto-generated method stub
　　18 return Base64.encode�Q�result�Q�；
　　19 }
　　20
　　21 @Override
　　22 public int minus�Q�int x, int y�Q?{
　　23 // TODO Auto-generated method stub
　　24 return x - y;
　　25 }
　　26
　　27 @Override
　　28 public byte[] decryt�Q�String src�Q?{

　　29 // TODO Auto-generated method stub
　　30 try {
　　31 return Base64.decode�Q�src�Q�；
　　32 } catch �Q�Base64DecodingException e�Q?{
　　33 // TODO Auto-generated catch block
　　34 e.printStackTrace�Q�）�Q?br />　　35 }
　　36 return null;
　　37 }
　　38
　　39 @Override
　　40 public double divide�Q�int x, int y�Q?{
　　41 // TODO Auto-generated method stub
　　42 return x/y;
　　43 }
　　44
　　45 @Override
　　46 public int get�Q�） {
　　47 // TODO Auto-generated method stub
　　48 return num;
　　49 }
　　50
　　51 public void print�Q�） {
　　52 System.out.println�Q?The public key is: "+pub_key+"\nThe private key is: "+pri_key�Q�；
　　53 }
　　54
　　55 }
　　在这个类中，只有一个get�Ҏ(gu��)��实现了，同时也没有�ؓ有多个get要实现而冲�H�。同�Ӟ��如果删除了接口InterfaceMultiInheritance.java中的get�Ҏ(gu��)��Q�也只有一个get�Ҏ(gu��)��得到了实现�ƈ且没有�ؓ多个get要实现而出��C��么冲�H��?br />　　所以，我们可以得到一个结论，当编译器在实现接口的时候会依然��查接口InterfaceMultiInheritance.java、TestInterfaceA.java和TestInterfaceB.java中的�Ҏ(gu��)��声明�Q�如果后两者有与前者相冲突的方法声明，�~�译器将只要求类实现前者的声明�Q�而后两者中相同的方法声明将自动被忽略。而当只有后两者中有相同的�Ҏ(gu��)��声明�Ӟ��~�译器将实现其中的一个即可。就好像是编译器中有一个专门存储方法声明的Set一��P��在有�l�承关系的接口中�Q�只保存一�ơ相同的�Ҏ(gu��)��声明 www.jx-jf.com

好不�Ҏ(gu��)�� 2014-03-23 09:49 发表评论

好不�Ҏ(gu��)�� — Tue, 18 Mar 2014 09:21:00 GMT

　　在正常情况下�Q�需要先有一个类的完整�\径引入之后才可以按照固定的格式��生实例话对象�Q�但是在Java中也允许通过一个实例话对象扑ֈ�一个类的完整信息。那么这��是Class�cȝ��功能�?br />　　实际上类是Java反射的源��_��实际上所谓反��从�E�序的运行结果来看也很好理解�Q�即可以通过对象的反��求出类的名�U��?br />　　实例化Class�c�，获得字节码文件的�Ҏ(gu��)��有三�U�：
　　�W�一�U�：通过forName�Q�）�Ҏ(gu��)��Q�第二种�Q�类。class�W�三�U�：对象。getClass�Q�）
　　package toto.learn;
　　class X1{}
　　publicclass GetClassDemo02 {
　　publicstaticvoid main�Q�String[] args�Q?{
　　Class c1=null;//指定泛型
　　Class c2=null;//指定泛型
　　Class c3=null;//指定泛型
　　try{
　　c1=Class.forName�Q?toto.learn.X"�Q�；//最常用的�Ş式，�q�种方式��字节码文�g加蝲到内存中�?br />　　}catch�Q�ClassNotFoundException e�Q�{
　　e.printStackTrace�Q�）�Q?br />　　}
　　c2 = new X1�Q�）。getClass�Q�）�Q?/通过Object�c�M��的方法实�?br />　　c3 = X1.class;//通过�c�class实例�?br />　　System.out.println�Q?�c�d��U�ͼ�"+c1.getName�Q�）�Q�；//得到�cȝ��名称
　　System.out.println�Q?�c�d��U�ͼ�"+c2.getName�Q�）�Q�；//得到�cȝ��名称
　　System.out.println�Q?�c�d��U�ͼ�"+c3.getName�Q�）�Q�；//得到�cȝ��名称
　　}
　　}
　　通过以上�Ҏ(gu��)��获得�c�d��U�的方式得到的是包名+�c�d��
　　如果要想通过Class�c�L��w�实例化其他�cȝ��对象�Q�则可以使用newInstance�Q�）�Ҏ(gu��)��Q�但是必��要保证被实例化的类中必��d��在一个无参够造方法�?br />　　被实例化对象的类中必��d��在无参构造方法，如果不存在的话，则肯定是无法实例化的�?br />　　1�?通过Class�c�M��的getConstructors�Q�）取得本类中的全部构造方�?br />　　2�?向构造方法中传递一个对象数�l�进去，里面包含了构造方法中所需的各个参�?br />　　3�?之后通过Constructor实例化对象�?br />　　package org.lxh.demo15.instancedemo;
　　import java.lang.reflect.Constructor;
　　publicclass InstanceDemo03 {
　　publicstaticvoid main�Q�String[] args�Q?{
　　Class c = null;
　　try {
　　c = Class.forName�Q?org.lxh.demo15.instancedemo.Person"�Q�； // 声明Class对象
　　} catch �Q�ClassNotFoundException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　}
　　Person per = null; // 声明Person对象
　　Constructor cons[] = null; // 声明一个表�C�构造方法的数组
　　cons = c.getConstructors�Q�）�Q?// 通过反射�Q�取得全部构�?br />　　try {// 向构造方法中传递参敎ͼ�此方法��用可变参数接�Ӟ��q�实例化对象
　　per = �Q�Person�Q?cons[0].newInstance�Q?李兴�?, 30�Q�；
　　} catch �Q�Exception e�Q?{ // 因�ؓ只有一个构造，所以数�l�下标�ؓ0
　　e.printStackTrace�Q�）�Q?br />　　}
　　System.out.println�Q�per�Q�； // 输出对象
　　}
　　}
　　per = �Q�Person�Q�cons[0].newInstance�Q?李兴�?, 30�Q�； //此处是调用�ƈ使用构造方法的部分�?br />　　在声明对象数�l�的时候，必须考虑到构造方法中参数的类型顺序，所以第一个参数的�c�d��为Stirng,�W�二个参数的�c�d��WieInteger�Q�在使用是可以自动拆��）
　　Constructorcons[]=null;//实例化构造方法的数组
　　Cons =c.getConstructors�Q�）�Q?/取得全部构�?br />　　//向构造方法中传递参敎ͼ�此方使用可变参数接收�Q��ƈ实例化对�?br />　　Per = �Q�Person�Q�cons[0].newInstance�Q?李兴�?,30�Q�；
　　讄��构造方法的参数内容
　　publicPerson�Q�String name,int age�Q�{//通过构造设�|�属性内�?br />　　}
　　反射的应�?br />　　可以使用反射取得实现的全部接�?br />　　可以使用反射取得一个类所�l�承的父�c?br />　　可以使用反射取得一个类中的全部构造方�?br />　　可以使用反射取得一个类中的全部�Ҏ(gu��)��
　　可以使用反射取得一个类中的全部属�?br />　　在实际开发中发，以上的程序就是反��应用最多的地方�Q�当然反��机制所提供的功能远不如此，�q�可以通过反射得到一个类中的完整构造，那么�q�就要��用到java.lang.reflect包中的一下几个类�?br />　　Constructor:表示�c�M��的构造方�?br />　　Field:表示�c�M��的属�?br />　　Method:表示�c�M��的方�?br />　　�q�三个类都是AccessibleObject�c�M��的子�c�R�?br />　　要想取得一个类中所实现的全部接口，则必��M��用Class�c�M��的getInterfaces�Q�）�Ҏ(gu��)��。此�Ҏ(gu��)��定义如下�Q?br />　　publicClass[] getInterfaces�Q�）�Q?br />　　此方法返回一个Class�cȝ��对象数组�Q�之后就可以直接利用Class�c�M��的getName�Q�）�Ҏ(gu��)��输出卛_��?br />　　通过反射取得实现的全部接�?br />　　package org.lxh.demo15;
　　publicclass GetInterfaceDemo {
　　publicstaticvoid main�Q�String[] args�Q?{
　　Class c1 =null;//声明Class对象
　　try{
　　c1 = Class.forName�Q?org.lxh.demo15.Person"�Q�；//实例化Class对象
　　}catch�Q�ClassNotFoundException e�Q�{
　　e.printStackTrace�Q�）�Q?br />　　}
　　Class c[] = c1.getInterfaces�Q�）�Q?/取得实现的全部接�?br />　　for�Q�int i=0;i
　　System.out.println�Q?实现的接口名�U�ͼ�"+c[i].getName�Q�）�Q�；//输出接口名称
　　}
　　}
　　}
　　一个类中可以实现多个接口，但是只能�l�承一个父�c�，所以如果要惛_��得一个类的父�c�，可以直接使用Class�c�M��的getSuperclass�Q�）�Ҏ(gu��)��。此�Ҏ(gu��)��定义如下�Q?br />　　PublicClass getSuperclass�Q�）
　　此方法返回的是Class实例�Q�和之前的得到接口一��P��可以通过getName�Q�）�Ҏ(gu��)��取得名称�?br />　　取得构造方法的例子�Q?br />　　package org.lxh.demo15;
　　import java.lang.reflect.Constructor;//导入反射操作�?br />　　publicclass GetConstructorDemo01 {
　　publicstaticvoid main�Q�String[] args�Q?{
　　Class c1 = null;//声明Class对象
　　try{
　　c1 = Class.forName�Q?org.lxh.demo15.Person"�Q�；
　　}catch�Q�ClassNotFoundException e�Q�{
　　e.printStackTrace�Q�）�Q?br />　　}
　　Constructor con[]=c1.getConstructors�Q�）�Q?/得到全部构造方�?br />　　for�Q�int i=0;i
　　System.out.println�Q?构造方法："+con[i]�Q�；//直接打印输出
　　}
　　}
　　}
　　�q�原修饰�W?br />　　在整个Java中对于方法的修饰�W��用一定的数字表示出来的，而如果要��x��q�个数字�q�原成用户可以看懂的关键字，则必��M��靠Modifier�c�d��成，此类定义在java.lang.reflect包中。直接��用Modifer�cȝ��一下方法可修饰�W�：
　　publicstatic String toString�Q�int mod�Q?br />　　int mo = con[i].getModifiers�Q�）�Q?br />　　System.out.print�Q�Modifier.toString�Q�mo�Q?""�Q�； //�q�原权限
　　getDeclaredMethods�Q�）�Ҏ(gu��)��Q�此�Ҏ(gu��)��q�回一个Method�cȝ��对象数组�Q�而如果要惌��一步取得方法具体信息，例如�Q�方法的参数�Q�抛出的异常声明�{�等�Q�则��是必须依靠Method�c?br />　　再反��操作中同样可以取得一个类中的全部属性，但是在取得属性的时候有以下两种不同的操作：
　　得到实现的接口或父类中的公共属性：public Field[] getFields�Q�） throwsSecurityException
　　得到本类中自己定义的的全部属性：public Field[] getDeclaredFields�Q�） throws SecurityException
　　如果要��用反��调用类中的�Ҏ(gu��)��可以通过Method�c�d��成，操作步骤如下�Q?br />　　1�?通过Class�cȝ��getMethod�Q�Stringname,Class…parameterTypes�Q�方法取得一个Method的对象，�q�设�|�此�Ҏ(gu��)��操作时所需的参数类型�?br />　　2�?之后才可以��用invoke�q�行调用�Q��ƈ向方法中传递要讄��的参�?strong>托福�{�案 www.jamo123.com
　　在Proxy�c�M��的newProxyInstance�Q�）�Ҏ(gu��)��中，需要一个ClassLoader�cȝ��实例�Q�ClassLoader实际上对应的是类加蝲器，在Java中主要有以下三种�c�d��载器�Q?br />　　BootstrapClassLoader:此加载器采用C++ �~�写�Q�一般开发中是看不到的；
　　ExtensionClassLoader:用来�q�行扩展�cȝ��加蝲�Q�一般对应的是jre\lib\ext目录中的�c�；
　　AppClassLoader:加蝲classpath指定的类�Q�是最常用使用的一�U�加载器�?br />　　通过forName�Q�）加蝲�c�M��ơ时�Q�此时的�c�d��加蝲了一��?br />　　如果有以下代码：
　　Object obj= new VipUser�Q�）�Q?/�q�里VipUser是User的子�c�，它��承了User
　　if�Q�obj instanceof User�Q�{
　　System.out.println�Q?instanceof判断是一个user"�Q�；
　　User user = �Q�User�Q�obj;
　　}
　　当��用以上代码中的instanceof来判断时�Q�此时obj��是一个User了，但实际上它不是。它只是User的一个子�c�R�?br />　　�ȝ��Q��用instanceof时主要用来判断是否实��C��后面的接口�?br />　　if�Q�obj.getClass�Q�）==User.class�Q�{
　　System.out.println�Q?getClass判断�Q�是一个user"�Q�；
　　User user = �Q�User�Q�obj;
　　}
　　而getClass�Q�）用于判断对象的准��类型�?br />　　在后面用到的�c�：
　　package toto.learn1;
　　publicclass User {
　　private String name;
　　private String password;
　　private String gender;
　　public User�Q�String name, String password, String gender�Q?{
　　super�Q�）�Q?br />　　this.name = name;
　　this.password = password;
　　this.gender = gender;
　　}
　　public User�Q�） {
　　super�Q�）�Q?br />　　// TODO Auto-generatedconstructor stub
　　}
　　public User�Q�String name, String password�Q?{
　　super�Q�）�Q?br />　　this.name = name;
　　this.password = password;
　　}
　　public String getName�Q�） {
　　returnname;
　　}
　　publicvoid setName�Q�String name�Q?{
　　this.name = name;
　　}
　　public String getPassword�Q�） {
　　returnpassword;
　　}
　　publicvoid setPassword�Q�String password�Q?{
　　this.password = password;
　　}
　　public String getGender�Q�） {
　　returngender;
　　}
　　publicvoid setGender�Q�String gender�Q?{
　　this.gender = gender;
　　}
　　publicvoid run�Q�String str, int num�Q�{
　　System.out.println�Q?run"�Q�；
　　}
　　publicvoid run�Q�String name�Q�{
　　System.out.println�Q?hello:"+name�Q�；
　　}
　　}
　　以下是关于反��的部分�?br />　　package toto.learn1;
　　import java.lang.reflect.Constructor;
　　import java.lang.reflect.Field;
　　import java.lang.reflect.Method;
　　import java.lang.reflect.Modifier;
　　publicclass Demo2 {
　　/**
　　* 反射
　　* @throwsIllegalAccessException
　　* @throwsInstantiationException
　　* @throwsNoSuchMethodException
　　* @throwsSecurityException
　　*/
　　publicstaticvoid main�Q�String[] args�Q?throws Exception {
　　Class clazz = User.class;
　　//构造方�?br />　　//获得构造方�?br />　　Constructor[] cons = clazz.getConstructors�Q�）�Q?br />　　for�Q�Constructor con : cons�Q�{
　　//参数列表�Q�获得的�U�定是完整的参数�c�d��Q�包括这�U�类型坐在的包�?br />　　Class[] types = con.getParameterTypes�Q�）�Q?br />　　System.out.println�Q?参数�c�d��为："�Q�；
　　for�Q�Class type:types�Q�{
　　System.out.println�Q�type.getName�Q�）+"…"�Q�；
　　}
　　System.out.println�Q�）�Q?br />　　}
　　//获得指定的构造方�?创徏对象
　　try {
　　Object obj = clazz.newInstance�Q�）�Q?/默认调用无参的构造方�?br />　　System.out.println�Q�obj.getClass�Q�）�Q�；
　　} catch �Q�InstantiationException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　} catch �Q�IllegalAccessException e�Q?{
　　e.printStackTrace�Q�）�Q?br />　　}
　　/**参数�c�d��为：
　　java.lang.String…
　　java.lang.String…
　　参数�c�d��为：
　　java.lang.String…
　　java.lang.String…
　　java.lang.String…
　　class toto.learn1.User*/
　　System.out.println�Q?-------------------------"�Q�；
　　//获得指定的构造方�? 创徏对象
　　Object obj = clazz.newInstance�Q�）�Q?/默认调用无参的构造方�?br />　　Constructor constructor = clazz.getConstructor�Q�String.class,String.class�Q�；//此处调用有两个参数的构造方�?br />　　//String.class是因为构造方法中有带有年个参数的构造方法的形参都是String�cȝ��?br />　　User usr = �Q�User�Q�constructor.newInstance�Q?toto","查看"�Q�；//传递两个参数�?br />　　System.out.println�Q�usr.getName�Q�）+" "+usr.getPassword�Q�）�Q�；//�l�果�Q�toto 查看
　　//�Ҏ(gu��)��
　　//获得�c�L��有的�Ҏ(gu��)��
　　Method [] methods = clazz.getMethods�Q�）�Q?br />　　for�Q�Method method:methods�Q�{
　　System.out.println�Q�method.getName�Q�）�Q�；
　　}
　　/**通过getMethods�Q�）�Ҏ(gu��)��获得的类中包含有父类的方法，�q�且拿到的是共有的方�?br />　　* run
　　run
　　getName
　　setName
　　getPassword
　　setPassword
　　getGender
　　setGender
　　wait
　　wait
　　wait
　　hashCode
　　getClass
　　equals
　　toString
　　notify
　　notifyAll
　　* */
　　//如果惌��得声明的所有方法，包括非public的，不包括��承的�Q�可以��用一下途径实现
　　System.out.println�Q?-----------------------"�Q�；
　　Method [] methods2 = clazz.getDeclaredMethods�Q�）�Q?br />　　for�Q�Method method:methods2�Q�{
　　System.out.println�Q�method.getName�Q�）�Q�；
　　}
　　/**�l�果是：
　　* run
　　run
　　getName
　　setName
　　getPassword
　　setPassword
　　getGender
　　setGender*/
　　//获得指定的方法，调用�Ҏ(gu��)��
　　Method runMethod = clazz.getMethod�Q?run", String.class�Q�； /**�W�一个表�C��调用那个�Ҏ(gu��)��
　　�W�二个参数是可变参数�Q�表�C��用的润方法的参数�c�d��?/
　　//获得了方法后�Q�要执行�Ӟ��得给��Z��个对象，在这里要执行的对象是User,故作如下实例
　　User usr1 = new User�Q�）�Q?br />　　runMethod.invoke�Q�usr1, "toto"�Q�；//表示执行usr1对象中的runMethod�Ҏ(gu��)��Q��ƈ且向�Ҏ(gu��)��中传递了参数�?br />　　/**
　　* �q�行�l�果�Q�hello:toto 此�ؓUser�c�M��run�Q�String name�Q�；�Ҏ(gu��)��输出的结果，其中name即�ؓtoto*/
　　//属�?strong>托福�{�案 www.lefeng123.com
　　//获得对象的属性，先创��Z��个对�?br />　　Object object = new User�Q?toto","123","male"�Q�；//调用User中的构造方法：
　　//�׃��获得对象的私有属性，得获得get�Ҏ(gu��)��Q�故得先获得对象的字节码文�g�Q�通过�q�个文�g获得get�Ҏ(gu��)��
　　Class objectClazz = object.getClass�Q�）�Q?br />　　//获得get�Ҏ(gu��)��
　　Method runMethod2 = clazz.getMethod�Q?getName"�Q�； //�׃��该方法没有参敎ͼ�故不用在向里面传递参�?br />　　//执行此方法，输出参数
　　Object name = runMethod2.invoke�Q�object�Q�；
　　System.out.println�Q�name�Q�；//�׃��上面传递了name��|��故此处返回的�l�果��gؓ�Q�toto
　　//获得所有属�?br />　　System.out.println�Q?-------------------------------"�Q�；
　　//Field[] fields =clazz.getFields�Q�）�Q?/此方法拿到的是public的属性，�׃��User�c�M��没有共有的属�?br />　　Field[] fields = clazz.getDeclaredFields�Q�）�Q?/拿到声明的属�?br />　　for�Q�Field fd : fields�Q�{
　　System.out.println�Q�fd.getName�Q�）+"属性类型： "+fd.getType�Q�）�Q�；
　　}
　　/** �l�果为：
　　* name属性类型： class java.lang.String
　　password属性类型： class java.lang.String
　　gender属性类型： class java.lang.String*/
　　//为对象的password属性赋��|��
　　User user2 = new User�Q�）�Q?br />　　String fieldName = "password";//作�ؓ变量来处理的�Q�可以传递�Q意的属性名�U?br />　　//getpw是通过反射拿到的属性，其实��是password
　　Field getpw = user2.getClass�Q�）。getDeclaredField�Q�fieldName�Q�；
　　//判断属性是否�ؓ�U�有�Q?br />　　int num = getpw.getModifiers�Q�）�Q?/�q�回的是整型的倹{�?br />　　if�Q�num == Modifier.PRIVATE�Q�{//获得的是
　　System.out.println�Q?属性是�U�有�?�Q�；
　　//让java虚拟��Z��查访问权�?br />　　//getpw.setAccessible�Q�true�Q�；
　　}
　　//System.out.println�Q�getpw�Q�；//�l�果private java.lang.Stringtoto.learn1.User.password
　　getpw.set�Q�user2, 234567�Q�；//前一个参数表�C�的是�ؓ那个对象赋密码�?br />　　System.out.println�Q�user2.getPassword�Q�）�Q�；
　　}
　　}
　　通过Field�c�访问对象属性时�Q�需要注意访问权限的问题�Q�若对象的属性被声明为私有，则无法访问，此时需要打开java语言��查filed.setAccessible�Q�true�Q�；
　　Method�c�M��表某个类中的一个成员方法通过invoke�Ҏ(gu��)��可以调用Method表示的方法，此时同样需要传递对象给Method,若被调用的方法�ؓ静态，则传入一个null�?br />　　注意�Q�jdk1.4和jdk1.5的invoke�Ҏ(gu��)��的区别：
　　Jdk1.5:public Object invoke�Q�Objectobj,Object… args�Q?br />　　Jdk1.4:public Object invoke�Q�Objectobj,Object[] args�Q?br />　　当传入一个数�l�时�Q��ؓ了向后兼容，虚拟��Z��优先考虑考虑调用JDK1.4的方�?/p>

好不�Ҏ(gu��)�� 2014-03-18 17:21 发表评论

使用UrlRewriteFilter对url�q�行更替

好不�Ҏ(gu��)�� — Mon, 17 Mar 2014 13:06:00 GMT

一般来��_��使用struts之后url的访问实际上讉K��的是action的地址�Q��ؓ了不让该地址暴露�l�别人，可以采用UrlRewriteFilter来对url�q�行重写�?br />首先�Q�在web.xml里面配置�Q?br />
UrlRewriteFilter
org.tuckey.web.filters.urlrewrite.UrlRewriteFilter

confReloadCheckInterval
60

confPath
/WEB-INF/urlrewrite.xml

UrlRewriteFilter
REQUEST
FORWARD
/*

注意�Q�要在struts的mapping里面加上�Q�要不然会出错的�Q�这个花了我半天才搞定。还有一点：UrlRewriteFilter要放在struts Filter之前。web.xml里面�q��o器需要讲�I��序，一般是�q�样子的��序�Q�字�W�编码过滤器�Q�hibernate open session in view �q��o器，Urlrewrite�q��o器，struts�q��o器�?br />REQUEST
FORWARD
然后在WEB-INF里面新徏urlrewrite.xml文�g�Q�该文�g为UrlRewriteFilter的配�|�文�Ӟ��通过在里面定义rule规则对URL�q�行更替�?br />
下面是urlrewrite.xml

"http://tuckey.org/res/dtds/urlrewrite3.2.dtd">

/anything

/url/test.action

以上只是��单的实现�Q�具体的替换需要用到正则表辑ּ��?br />如下例：
/content/�Q�[0-9]+�Q?list
/IssuedContentAction.do?dispatch=vContentListBySubid&scope=vmcontent&columninfoid=$1
需要注意的地方是：用括��h��h��的正则表辑ּ�为变量，如to标签里面�?1表示的是上面from里面的第一个括号内宏V��url里面的参数间隔符 '&'应该写�ؓ'&'.
值得注意的是标签�Q�可以��用该标签替换��面里面的url托福�{�案 www.yztrans.com
��单的正则表达式：
. 匚w��除换行符以外的�Q意字�W?br />\w 匚w��字母或数字或下划�U�或汉字
\s 匚w��L��的空白符
\d 匚w��数字
\b 匚w��单词的开始或�l�束
^ 匚w��字符串的开�?br />$ 匚w��字符串的�l�束

好不�Ҏ(gu��)�� 2014-03-17 21:06 发表评论