Java基础知识陷阱(五)

本文发表于本人博客。

今天我来说说关于静态变量初始化、数组、==与equals的问题，看下面代码：

public class Test{
    private final int age;

    private String name;

    public Test(){
        age = 30;
    }

    public Test(String name){
        this.name = name;
    }
}

我想上面的代码好多人都知道了会编译报错的，原因是在代餐构造函数中未对age进行复制操作。

对于终态变量final程序中是可以再2个地方赋值的，一是申明后赋值，二是构造函数中赋值，上面的代码带参构造修改成如下：

    public Test(String name){
        age = 30;
        this.name = name;
    }

这样编译就没问题可以通过了。那现在我们把这个age变量的修饰符增加static，看代码：

public class Test{
    private static final int age;

    private String name;

    public Test(){
        age = 30;
    }

    public Test(String name){
        age = 30;
        this.name = name;
    }
}

说说这样编译能通过吗！这样也是不行的，分析下当这个age变量变味static时它已经不属于任何对象了是属于类Test的了，那么如果在构造对象的时候还去赋值修改原有的值那肯定不行了，它只有在申明时候赋值，代码修改如下：

public class Test{
    private static final int age = 30;

    private String name;

    public Test(){
    }

    public Test(String name){
        this.name = name;
    }
}

继续看下面代码，看看这个能编译吗？

public class Test{
    public static final StringBuffer sb = new StringBuffer();
    public static void main(String[] args){
        sb.append("www.luoliang.me");
    }
}

这个比较简单，竟然sb为类常量，那么由于是类，它的引用地址是不能再修改了，但是这个指向的地址的内容是可以被修改的。

继续看下面代码，试问编译通过吗？如果不通过，哪里有问题？

interface I{}
public class demo{
    public static void main(String[] args){
        I[] iArray = new I[2];
        I i = new I();
    }
}

上面的代码大家看了就知道，接口interface是不能实例化的，那么new I()肯定是不行的。至于这个new来实例化I的数组，这个可以吗，先解析下，由于数组里面的元素是对象，那么对象是可以为null的，这样的话new I[2]表示长度为2的I对象数组，至于数组的元素一定是要继承接口I了，比如：

class Test implements I{
}
iArray[0] = new Test();

现在我们来看看这个==与equals的问题，在网上也好多了，现在自己再复习下，看下面代码：

public class Test{
    public static void main(String[] args){
        String str1 = new String("luoliang.me");
        String str2 = new String("luoliang.me");
        System.out.println(str1 == str2);
        System.out.println(str1.equals(str2));
    }
}

试问输出什么？这个倒是简单很多人都知道了，如果是基本类型==比较的是其值，如果是引用类型比较的是其地址。那equals这个方法呢，所有对象都是Object的子类，那我们查看下jdk源码中的Object，可以看到：

    public boolean equals(Object obj) {
        return (this == obj);
    }

他们是直接比较的地址啊，是==。那字符串呢，先不说我们看看String类的equals方法：

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = count;
            if (n == anotherString.count) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = offset;
            int j = anotherString.offset;
            while (n-- != 0) {
                if (v1[i++] != v2[j++])
                return false;
            }
            return true;
            }
        }
        return false;
    }

可以看到起源码是先比较是否是同一个字符串，如果是的话返回true，如果不是的话继续比较他们各次的字符。那现在我们就知道答案了，输出如下：

false
true

接下来我们来看如下代码：

class Person{
    public String name;
    public Person(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}

现在如果2个Person对象进行比较，如果是名称name相同则判断是同一个人，怎么做？先分析一下：判断是否同一个人，这个对象是继承基类Object的，本身有equals方法，那按照String类的方法重写Override一下应该就可以解决了，看下面：

class Person{
    public String name;
    public Person(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    @Override
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof Person) {
            Person person = (Person)anObject;
            if(person.name.equals(this.name)){
                return true;
            }
        }
        return false;
    }
}

调用如下：

        Person p1 = new Person("luoliang");
        Person p2 = new Person("luoliang");
        System.out.println(p1 == p2);
        System.out.println(p1.equals(p2));

输出结果：

false
true

这次先到这里。坚持记录点点滴滴！