Featheast Lee 李羽东

当用Netbeans部署一个项目出现状况的时候，往往尝试着重新启动Glassfish，而这个时候更有可能你会发现Glassfish无法启动了，等待了很久之后报出了如下一段错误：

The Sun Java System Application Server could not start.
More information about the cause is in the Server log file.
Possible reasons include:
- IDE timeout: refresh the server node to see if it’s running now.
- Port conflicts. (use netstat -a to detect possible port numbers already used by the operating system.)
- Incorrect server configuration (domain.xml to be corrected manually)
- Corrupted Deployed Applications preventing the server to start.(This can be seen in the server.log file. In this case, domain.xml needs to be modified).
- Invalid installation location.
See the server log for details.
BUILD FAILED (total time: 5 minutes 20 seconds)

你甚至会发现无论你如何卸载重新安装Glassfish, Netbeans，你的服务器仍然无法顺利启动。

其实问题的关键不是在这里，而是在你的domain之下。找到\domains\domain1\imq\instances\imqbroker这个文件目录下，你会发现一个lock文件。将它删除掉，Glassfish就顺利复原了。

至于原因是什么，我在GOOGLE上也没搜出个大概，先知其然而不知其所以然吧。

在做简单的Swing开发中，会经常遇到这样的情况，需啊监听文本框的内容的变化。比如一个最简单的例子就是如果登陆框中用户名和密码都不为空的时候，登陆按钮才被激活。

在查看事件的时候，很多人第一眼看到的就是InputMethod下面的caretPositionChanged和inputMethodTextChanged。无论从文档还是从函数名字来看，这两个函数似乎都是我们所需要实现的方法。可惜当你填满了里面的内容，DEBUG的时候，会发现无论如何你改变你的输入框的内容，根本都不会触发这两个事件。在Sun的论坛上，有个人回了这样一句话来解决这个问题：“A component will only receive input method events from input methods if it also overrides getInputMethodRequests to return an InputMethodRequests instance.”

不愿意为这个问题多纠结，给出解决方案就是使用DocumentListener。这个接口提供了三个方法来侦听所绑定的文本的内容。对于我们需要的监听对象，直接添加这个侦听器，并实行其中的方法即可。

Document doc1 = jTextFieldId.getDocument();
doc1.addDocumentListener(new DocumentListener() {
            String name;
            String pwd;

            public void insertUpdate(DocumentEvent e) {
                name = jTextFieldId.getText();
                pwd = new String(jPasswordFieldPassword.getPassword());
                if(!name.equals("") && !pwd.equals("")){
                    jButtonSignIn.setEnabled(true);
                } else {
                    jButtonSignIn.setEnabled(false);
                }

            }

            public void removeUpdate(DocumentEvent e) {
                name = jTextFieldId.getText();
                pwd = new String(jPasswordFieldPassword.getPassword());
                if(!name.equals("") && !pwd.equals("")){
                    jButtonSignIn.setEnabled(true);
                } else {
                    jButtonSignIn.setEnabled(false);
                }
            }

            public void changedUpdate(DocumentEvent e) {

            }
        });

基础的只是大家都很清楚，对于原始类型如int, float，直接用==就可以比较。对于Class类型的，在Java中使用的是reference的比较，因此需要使用的是equals.

Integer a1 = new Integer(1);
Integer a2 = new Integer(1);
System.out.println(a1==a2); //false
System.out.println(a1.equals(a2)); //true

因此在上述代码中，尽管使用的看上去就是int，但是因为实际已经使用了Integer，所以单纯使用==是不能比较的。

对于自己定义的类型，如果直接使用equals来比较，将会同样返回非期望的值。因为新定义的类，一般不会去重写equals的方法，而会直接调用其父类的equals方法，将也是直接比较reference。如果我们需要比较自定义的类型的时候，只需要重写equals方法就可以了。

class MyClass{
        private int count;
        public MyClass(int a){
            this.count=a;
        }

    @Override
    public boolean equals(Object obj) {
        MyClass newmc = (MyClass)obj;
        return this.count==newmc.count ? true : false;
    }

MyClass m1 = new MyClass(1);
MyClass m2 = new MyClass(1);
System.out.println(m1==m2);
System.out.println(m1.equals(m2));

在编程语言中，有两种binding方式，一是在compile期间binding，被称作Early-binding，一种是在execute期间binding，被称作Late-binding。
在Java中，更多的采用的是Late-binding这种方式。要做一个比较好的解释，可以看看关于继承的例子。以下这段代码显示了一个很简单的继承关系，父类是Shape，子类是Circle和Rectangle，其中分别实现了各自的draw()方法。

public class Shape {
    public void draw(){
        System.out.println("Draw shape");
    }
}

public class Circle extends Shape{
    public void draw(){
        System.out.println("Draw circle");
    }
}

public class Rectangle extends Shape{
    public void draw(){
        System.out.println("Draw rectangle");
    }
}

public class Test {
    public static void main(String[] args){
            Shape shape = new Shape();
            shape.draw();
            Shape shape1 = new Rectangle();
            shape1.draw();
            Shape shape2 = new Circle();
            shape2.draw();
        }
}

在以上的示例中，我们在main函数中看到生成了三个分别是以上三个类的实例，但是它们共用了同样的Shape声明。这也就是Java最重要的多态的之所在。不过不是本文的重点，略过。我们发现既然三个实例享有同样的声明，在编译期间，编译器是无法判断到底每一个实例属于的是哪一个类，需要调用的是哪一个draw方法。而在执行期间，run-time会自动根据new关键字对应的类型，将其binding上。这就是所谓的late-binding。在传统的大多数非OOP语言中，early-binding占据绝大多数。总之，early-binding意味着在程序编译期间，运行时系统将确定需要调用的函数的地址，而late-binding则会在系统运行时根据当时情况动态决定。（在C++中，也支持类似的late-binding，不过需要显示的加以virtual关键字）

测试代码：

public class Test{
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}

自认为接触了这么多年的Java，考点小考试应该问题不大，但是一复习起来做起题，发现问题多多。特别是一个关于DecimalFormat的问题，几乎耗费了两个小时。这些都是以前完全不关心的东西，把这些点小小的总结一下可算是查漏补缺。

DecimalFormat
大家都很熟悉在println中通过各种形式来规定输出格式，DecimalFormat也是一个相似的功能，服务于各种数据。其最基本的几个替换符为：
0 — 代替所有的0-9的数字，必须出现
# — 代替除0外的1-9数字，0的时候不出现
. — 小数点
E — 指数符号
% — 百分号
，– 用来分组的占位符，在西方表达中常见如1,234,568
还有一些，不列出来了，自己可以再文档中查到。我主要想说以下关于前四个最基本的组合。

给出一个数字67890.78987这个数字基本上可以吧我要提到的问题都囊括在里面。
首先前面的示例性的生成Pattern就几乎省略了，DecimalFormat df = new DecimalFormat(”/*这个里面插入你的模式*/”);

模式        结果                注释
0000.0000    67890.7899            0代表必须有的位数，小数点4位，小数点后4位。由于实际中小数点前比4位多，保留。小数点后比5位多，自动进位，四舍五入。
00000.000    67890.790            小数点后有3位，同时后面进位，所以变为790
000000.000    067890.790            小数点前有6位，实际数字只有5位，所以最前面一位必须用0补齐。
0000.000000    67890.789870             小数点后有6位，实际数字只有5位，用0补齐

####.####    67890.7899            同样小数点前最多4位，小数点后最多4位。同样因为实际数字小数点前比4位多，保留。后面四舍五入。
####.###    67890.79            小数点后最多3位，应该是790，但是由于是#，所以0可以去掉。
######.###    67890.79            小数点前最多6位，实际为5位，第一位补0，去掉。
####.######    67890.78987            小数点后最多6位，实际为5位，最后一位补0，去掉。

##0.00#    67890.79            在0和#组合中，仍然符合以上规则。小数点后最后一位补0，是#，去掉。

科学技术法的判断位数方法和前面的有所不同。首先，小数点前面的位数和小数点后的位数代表的都不再是实际看到的小数点前后的位数，而是后面的实际数字的情况。在最大整数位比最小整数位差距在1之上的情况下，E的指数大小为小数点前最多位数的整数倍。但是尾数的位数是最大整数尾数和最大小数位数之和。
000000.##E0    67890.79–678907.9E-1
00000.##E0    67890.79–67890.79E0        小数点前5位，尾数一共5+2=7位。指数为0。
#0000.##E0    67890.79–67890.79E0        同上
##000.##E0    67890.79–67890.79E0        小数点前最小3位，和本来5位差距在1之上，因此指数为5的倍数。
0000.##E0    67890.79–6789.08E1        小数点前4位，尾数一共4+2=6位。指数为1。
#000.##E0    67890.79–6.78908E4        小数点前最小3位，和本来5位差距在1之上，因此指数为4的倍数。
##00.##E0    67890.79–6.78908E4        小数点前最小2位，和本来5位差距在1之上。
000.##E0    67890.79–678.91E2
#00.##E0    67890.79–67.891E3        小数点前最小2位，和本来5位差距在1之上，指数为3的倍数。
##0.##E0    67890.79–67.891E3
00.##E0    67890.79–67.89E3
#0.##E0    67890.79–6.789E4
##.##E0    67890.79–6.789E4
0.##E0        67890.79–6.79E4
#.##E0        67890.79–6.79E4