Java基础部分（11~20）

11、"=="和 equals 方法究竟有什么区别?

(单独把一个东西说清楚,然后再说清楚另一个,这样,它们的区别自然就出来了,混在一起说,则很难说清楚)

　　==操作符专门用来比较两个变量的值是否相等,也就是用于比较变量所对应的内存中所存储的数值是否相同,要比较两个基本类型的数据或两个引用变量是否相等,只能用==操作符。

如果一个变量指向的数据是对象类型的,那么,这时候涉及了两块内存,对象本身占用一块 内存(堆内存),变量也占用一块内存,例如 Objet obj = newObject();变量 obj 是一个内存, new Object()是另一个内存,此时,变量 obj 所对应的内存中存储的数值就是对象占用的那 块内存的首地址。对于指向对象类型的变量,如果要比较两个变量是否指向同一个对象,即 要看这两个变量所对应的内存中的数值是否相等,这时候就需要用==操作符进行比较。

equals 方法是用于比较两个独立对象的内容是否相同,就好比去比较两个人的长相是否相 同,它比较的两个对象是独立的。例如,对于下面的代码:

String a=new String("foo");

String b=new String("foo");

两条 new 语句创建了两个对象,然后用 a/b 这两个变量分别指向了其中一个对象,这是两 个不同的对象,它们的首地址是不同的,即 a 和 b 中存储的数值是不相同的,所以,表达 式 a==b 将返回 false,而这两个对象中的内容是相同的,所以,表达式 a.equals(b)将返回 true。

在实际开发中,我们经常要比较传递进行来的字符串内容是否等,例如,String input= ...;input.equals(“quit”),许多人稍不注意就使用==进行比较了,这是错误的,随便从网上 找几个项目实战的教学视频看看,里面就有大量这样的错误。记住,字符串的比较基本上都 是使用 equals 方法。

如果一个类没有自己定义 equals 方法,那么它将继承 Object 类的 equals 方法,Object 类 的 equals 方法的实现代码如下:

boolean equals(Object o){ return this==o;
}

这说明,如果一个类没有自己定义 equals 方法,它默认的 equals 方法(从 Object 类继承
的)就是使用==操作符,也是在比较两个变量指向的对象是否是同一对象,这时候使用
equals 和使用==会得到同样的结果,如果比较的是两个独立的对象则总返回 false。如果你
编写的类希望能够比较该类创建的两个实例对象的内容是否相同,那么你必须覆盖 equals
方法,由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

java中 == 与 equal 的区别

　　　　 String str1 = new String("str");
        String str2 = new String("str");
        System.out.println("==比较 ："+ str1 == str2);
        System.out.println("equal比较："+ str1.equals(str2));
        String str3 = "str1";
        String str4 = "str1";
        System.out.println("==比较 ："+ str3 == str4);
        System.out.println("equal比较："+ str3.equals(str4));

输出的答案：

　　根据打印的可以发现使用equal比较时无论是使用自动装箱来实例化还是用new来实例化，返回的都true，而用==则不一样了，自动装箱来实例化的返回的是true，而用new来实例化的返回的确是false;先不急着解决为什么，先来了解下equals和==的区别，到时候就可以知道答案了

equals方法最初是在所有类的基类Object中进行定义的，源码是

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

可以看出这里定义的equals与==是等效的，但上面的怎么还会不一样呢？
原因就是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;
    }

这里对equals重新需要注意五点：

1   自反性：对任意引用值X，x.equals(x)的返回值一定为true. 
2   对称性：对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true; 
3   传递性：如果x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true 
4   一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变 
5   非空性：任何非空的引用值X，x.equals(null)的返回值一定为false

经过重写后就跟==有本质的区别了：

equal:是用来比较两个对象内部的内容是否相等的，由于所有的类都是继承自java.lang.Object类的，所以如果没有对该方法进行覆盖的话，调用
的仍然是Object类中的方法，而Object中的equal方法返回的却是==的判断，因此，如果在没有进行该方法的覆盖后，调用该方法是没有
任何意义的。在java面向对象的处理中我们一般在javabean中都要选择重写equals方法，使用hibernate后，我们要生成数据库的映射文件与实体

类，这是我们就最好在实体类中进行equals方法的重写，重写时我们可以根据自己的定义来实现该方法只要遵守那五条原则，例如对于一个student类

我们定义只要在学号相同时我们就认为这两个对象时相等的；同时我们还要重写hashcode方法http://www.cnblogs.com/shenliang123/archive/2012/04/16/2452206.html
==：是用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。

12、静态变量和实例变量的区别?
在语法定义上的区别:静态变量前要加 static 关键字,而实例变量前则不加。
在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变

量才会被分配空间,才能使用这个实例变量。静态变量不属于某个实例对象,而是属于类, 所以也称为类变量,只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被 分配空间,静态变量就可以被使用了。总之,实例变量必须创建对象后才可以通过这个对象 来使用,静态变量则可以直接使用类名来引用。

例如,对于下面的程序,无论创建多少个实例对象,永远都只分配了一个 staticVar 变量, 并且每创建一个实例对象,这个 staticVar 就会加1;但是,每创建一个实例对象,就会分配 一个 instanceVar,即可能分配多个 instanceVar,并且每个 instanceVar 的值都只自加了1 次。

public class VariantTest{

　　public static int staticVar = 0;

　　public int instanceVar = 0;

　　public VariantTest(){

　　　　staticVar++;

　　　　instanceVar++;
　　　　System.out.println(“staticVar=” + staticVar + ”,instanceVar=”+ instanceVar);

　　}

}

备注:这个解答除了说清楚两者的区别外,最后还用一个具体的应用例子来说明两者的差异,
体现了自己有很好的解说问题和设计案例的能力,思维敏捷,超过一般程序员,有写作能力!

13、是否可以从一个 static 方法内部发出对非 static 方法的调用?

　　不可以。因为非 static 方法是要与对象关联在一起的,必须创建一个对象后,才可以在该对
象上进行方法调用,而 static 方法调用时不需要创建对象,可以直接调用。也就是说,当一
个 static 方法被调用时,可能还没有创建任何实例对象,如果从一个 static 方法中发出对非
static 方法的调用,那个非 static 方法是关联到哪个对象上的呢?这个逻辑无法成立,所以,
一个 static 方法内部发出对非 static 方法的调用。

14、Integer 与 int 的区别

　　int 是 java 提供的8种原始数据类型之一。

　　Java 为每个原始类型提供了封装类,Integer 是 java
为 int 提供的封装类。

　　int 的默认值为0,而 Integer 的默认值为 null,即 Integer 可以区分出
未赋值和值为0的区别,int 则无法表达出未赋值的情况。

　　例如,要想表达出没有参加考试和
考试成绩为0的区别,则只能使用 Integer。在 JSP 开发中,Integer 的默认为 null,所以用
el 表达式在文本框中显示时,值为空白字符串,而 int 默认的默认值为0,所以用 el 表达式
在文本框中显示时,结果为0,所以,int 不适合作为 web 层的表单数据的类型。

在 Hibernate 中,如果将 OID 定义为 Integer 类型,那么 Hibernate 就可以根据其值是否为
null 而判断一个对象是否是临时的,如果将 OID 定义为了 int 类型,还需要在 hbm 映射文
件中设置其 unsaved-value 属性为0。

另外,Integer 提供了多个与整数相关的操作方法,例如,将一个字符串转换成整数,Integer
中还定义了表示整数的最大值和最小值的常量。

15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

　　Math 类中提供了三个与取整有关的方法:ceil、floor、round,这些方法的作用与它们的英
文名称的含义相对应,例如,ceil 的英文意义是天花板,该方法就表示向上取整,
Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11;floor 的英文意义是地板,该方法
就表示向下取整,Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12;最难掌握的是
round 方法,它表示“四舍五入”,算法为 Math.floor(x+0.5),即将原来的数字加上0.5后再向
下取整,所以,Math.round(11.5)的结果为12,Math.round(-11.5)的结果为-11。

16、下面的代码有什么不妥之处?

　　1. if(username.equals(“zxx”){}
　　username 可能为 NULL,会报空指针错误;改为"zxx".equals(username)

　　2. int x=1;

　　return x==1?true:false;

　　这个改成 return x==1;就可以!

17、请说出作用域 public,private,protected,以及不写时的区别

　　这四个作用域的可见范围如下表所示。
说明:如果在修饰的元素上面没有写任何访问修饰符,则表示 friendly。

作用域 　　当前类　　同一package　　子孙类　　其他package

public 　　　√　　　　 √ 　　　　　　 √　　　　　  √　　　　　
protected    √            √　　　　　　  √　　　　　　×
friendly 　　√            √　　　　　　　×　　　　　  ×
private　　  √　　　　 × 　　　　　　 ×　　　　　  ×

备注:只要记住了有4种访问权限,4个访问范围,然后将全选和范围在水平和垂直方向上
分别按排从小到大或从大到小的顺序排列,就很容易画出上面的图了。

18、Overload 和 Override 的区别。Overloaded 的方法是否可以改变返回值
的类型?

 

　　Overload 是重载的意思,Override 是覆盖的意思,也就是重写。
　　重载 Overload 表示同一个类中可以有多个名称相同的方法,但这些方法的参数列表各不相同(即参数个数或类型不同)。

　　重写 Override 表示子类中的方法可以与父类中的某个方法的名称和参数完全相同,通过子
类创建的实例对象调用这个方法时,将调用子类中的定义方法,这相当于把父类中定义的那
个完全相同的方法给覆盖了,这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时,只能比父类抛出更少的异常,或者是抛出父类抛出的异常的子异常,因为子类可以解
决父类的一些问题,不能比父类有更多的问题。子类方法的访问权限只能比父类的更大,不
能更小。如果父类的方法是 private 类型,那么,子类则不存在覆盖的限制,相当于子类中
增加了一个全新的方法。

　　至于 Overloaded 的方法是否可以改变返回值的类型这个问题,要看你倒底想问什么呢?这
个题目很模糊。如果几个 Overloaded 的方法的参数列表不一样,它们的返回者类型当然也
可以不一样。但我估计你想问的问题是:如果两个方法的参数列表完全一样,是否可以让它
们的返回值不同来实现重载 Overload。这是不行的,我们可以用反证法来说明这个问题,
因为我们有时候调用一个方法时也可以不定义返回结果变量,即不要关心其返回结果,例如,
我们调用 map.remove(key)方法时,虽然remove 方法有返回值,但是我们通常都不会定义
接收返回结果的变量,这时候假设该类中有两个名称和参数列表完全相同的方法,仅仅是返
回类型不同,java 就无法确定编程者倒底是想调用哪个方法了,因为它无法通过返回结果
类型来判断。

　　override 可以翻译为覆盖,从字面就可以知道,它是覆盖了一个方法并且对其重写,以求达
到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现,在接口中一般只是对方法
进行了声明,而我们在实现时,就需要实现接口声明的所有方法。除了这个典型的用法以外,
我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点:

　　1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配,才能达到覆盖的效果;

　　2、覆盖的方法的返回值必须和被覆盖的方法的返回一致;

　　3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致,或者是其子类;

　　4、被覆盖的方法不能为 private,否则在其子类中只是新定义了一个方法,并没有对其进行
覆盖。

　　overload 对我们来说可能比较熟悉,可以翻译为重载,它是指我们可以定义一些名称相同
的方法,通过定义不同的输入参数来区分这些方法,然后再调用时,VM 就会根据不同的参
数样式,来选择合适的方法执行。在使用重载要注意以下的几点:

　　1、在使用重载时只能通过不同的参数样式。例如,不同的参数类型,不同的参数个数,不
同的参数顺序(当然,同一方法内的几个参数类型必须不一样,例如可以是 fun(int,float),但是不能为 fun(int,int));

　　2、不能通过访问权限、返回类型、抛出的异常进行重载;

　　3、方法的异常类型和数目不会对重载造成影响;

　　4、对于继承来说,如果某一方法在父类中是访问权限是 priavte,那么就不能在子类对其进
行重载,如果定义的话,也只是定义了一个新方法,而不会达到重载的效果。

19、构造器 Constructor 是否可被 override?
　　构造器 Constructor 不能被继承,因此不能重写 Override,但可以被重载 Overload。

20、接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可
继承具体类(concrete class)?抽象类中是否可以有静态的 main 方法?

　　接口可以继承接口。抽象类可以实现(implements)接口,抽象类可以继承具体类。抽象类中可以有静态的 main 方法。

备注:只要明白了接口和抽象类的本质和作用,这些问题都很好回答,你想想,如果你是 java
语言的设计者,你是否会提供这样的支持,如果不提供的话,有什么理由吗?如果你没有道
理不提供,那答案就是肯定的了。

只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有 abstract 方法。