Java中易混淆的概念

Java中易混淆的概念

(1)谈谈final， finally， finalize的区别

final修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。

那也就意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了 final型的。你也可以明确的给final 类中的方法加上一个final，但这显然没有意义。

 

被声明为final的变量要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值，而在以后的引用中只能读取，不可修改。

如： final int i；//int型常量

注意：对于基本类型的变量，这样做并没有什么实际意义，因为基本类型的变量在调用方法时是传值的，也就是说你可以在方法中更改这个参数变量而不会影响到调用语句，然而对于对象变量，却显得很实用，因为对象变量在传递时是传递其引用，这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量，当你在方法中不需要改变作为参数的对象变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法。

 

如果方法被声明为final. 那就说明你已经知道这个方法提供的功能已经满足你要求，不需要进行扩展，并且也不允许任何从此类继承的类来覆写这个方法。     

但是继承仍然可以继承这个方法，也就是说可以直接使用

 

finally在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

finally代码总会被执行，而不管有无异常发生。

如：

class WithFinally{
 public void foo2() throws IOException{
   //在任一个空闲的端口上创建一个套接字
   ServerSocket ss = new ServerSocket(0);
   try {
     Socket socket = ss.accept();
     //此处的其他代码...
   }finally {
     ss.close();
   }
 }

}
finally 块确保 close 方法总被执行，而不管 try 块内是否发出异常。因此，可以确保在退出该方法之前总会调用 close 方法。这样您就可以确信套接字被关闭并且您没有泄漏资源。在此方法中不需要再有一个 catch 块。如果您确实提供了一个 catch 块，则 finally 块中的代码在 catch 块完成以后执行。
finally 块必须与 try 或 try/catch 块配合使用。此外，一般不可能退出 try 块而不执行其 finally 块。如果 finally 块存在，则它总会执行。即使在try 块使用了return语句强制函数返回，但finally中的还是要执行。

！！！但有一种方法可以退出 try 块而不执行 finally 块。如果代码在 try 内部执行一条 System.exit(0)“System.exit(0)   强行退出JVM”; 语句，则应用程序终止而不会执行 finally 执行。

附注：System.exit(0);是系统关闭,也就是你的平台虽然关闭了,但在你的内存还是占有着,
     dispose();是释放资源,也就将你的平台从内存中释放!(建议用这种)

 

finalize是位于Object类的一个方法，该方法的访问修饰符为protected，由于所有类为Object的子类，因此用户类很容易访问到这个方法。由于，finalize函数没有自动实现链式调用，我们必须手动的实现，因此finalize函数的最后一个语句通常super.finalize()。通过这种方式，我们可以实现从下到上实现finalize的调用，即先释放自己的资源，然后再释放父类的资源。根据Java语言规范，JVM保证调用finalize函数之前，这个对象是不可达的，但是JVM不保证这个函数一定会被调用。另外，规范还保证finalize函数最多运行一次。通常，finalize用于一些不容易控制、并且非常重要资源的释放，例如一些I/O的操作，数据的连接。这些资源的释放对整个应用程序是非常关键的。在这种情况下，程序员应该以通过程序本身管理(包括释放)这些资源为主，以finalize函数释放资源方式为辅，形成一种双保险的管理机制，而不应该仅仅依靠finalize来释放资源。

 

(2)abstract class和interface有什么区别?

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。
abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制，正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。
　　声明了方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法，但可以有具体实现的方法，抽象类里没有具体实现的方法必须指定为抽象类型，否则会出错的。抽象方法不能有方法体。

再次强调：一个类不能既被声明为 abstract的，又被声明为final的。
   接口（interface）是抽象类的变体，只可以定义却不能实现。在接口中，所有方法都是抽象的(即接口的方法都没方法体)。多继承性可通过实现这样的接口而获得。接口的实现与继承相似，除了该实现类不能从接口定义中继承行为。当类实现接口时，它必须定义或实现（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于是抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

从某种意义上说，interface是一种特殊形式的abstract class，也不能使用final修饰符

abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface

一个非抽象类（注意是非抽象类！）实现一个接口时，必须实现接口的所有方法，抽象类则不必实现所有方法。

一个Interface的方所有法访问权限（visibility)自动被声明为public,确却的说，一个Interface的所有方法只能是public的，你可以显式声明一个方法是public（不推荐),但是不能声明它是private或protected.但是当一个类实现某个接口，定义接口的方法时，必须且只能声明为public，否则编译将通不过。

 

(3) Static Nested Class 和 Inner Class的不同。Anonymous Inner Class （匿名内部类） 是否可以extends（继承）其它类，是否可以implements（实现）interface（接口）？

   Inner Class（内部类）定义在类中的类。

Nested Class（嵌套类）是静态（static）内部类。1. 要创建嵌套类的对象，并不需要其外围类的对象。  2. 不能从嵌套类的对象中访问非静态的外围类对象。

Anonymous Inner Class （匿名内部类）匿名的内部类是没有名字的内部类。

匿名的内部类不能extends（继承）其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

嵌套类可以作为接口的内部类。正常情况下，你不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，因为它是static 的。只是将嵌套类置于接口的命名空间内，这并不违反接口的规则。

内部类被继承,由于内部类有一个指向外围类对象的秘密引用，所以在继承内部类的时候，该秘密引用必须被初始化。解决方法是enclosingClassReference.super();语法，看一下代码：

class Outer
...{
     class Inner
      ...{
      }
}
class AnoClass extends Outer.Inner
...{
     AnoClass (Outer wi)
        ...{
             wi.super();
        }
}

匿名类（Anonymous Class）
　　当一个内部类的类声名只是在创建此类对象时用了一次，而且要产生的新类需继承于一个已有的父类或实现一个接口，才能考虑用匿名类，由于匿名类本身无名，因此它也就不存在构造方法，它需要显示地调用一个无参的父类的构造方法，并且重写父类的方法。

。。。。。。。。。。。。

f.addMouseMotionListener(new MouseMotionAdapter(){ //匿名类开始
　　　　　　　public void mouseDragged(MouseEvent e){
　　　　　　　　String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
　　　　　　　　tf.setText(s); }
　　　　　　} ); //匿名类结束

　　存在它的原因是:
　　1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。即内部类实例对包含它的哪个类的实例来说，是特权的。
　　2.对于同一个包中的其他类来说,内部类能够隐藏起来,换句话说，内部类不管方法的可见性如何，那怕是public，除了包容类，其他类都无法使用它。
　　3.匿名内部类可以很方便的定义回调。
　　4.使用内部类可以非常方便的编写事件驱动程序。
其实它真正的目的仅仅为了定义回调－－进一步就是事件驱动。

　在使用匿名内部类时，要记住以下几个原则： 
　　·匿名内部类不能有构造方法。  
　　·匿名内部类不能定义任何静态成员、方法和类。  
　　·匿名内部类不能是public,protected,private,static。  
　　·只能创建匿名内部类的一个实例。 
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。  
　　·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。  

匿名类和内部类中的中的this :
 有时候，我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。 这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。

 

(4)Hashtable和HashMap
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许
还有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以理论性能不会有很大的差异。

但HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。 Hashtable 类似于 HashMap，不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

 

 

(1)    String s="abce" 与 String s=new String("abcd") 的区别

   String   s="abce"是一种非常特殊的形式,和new   有本质的区别.  
   
  它是java中唯一不需要new   就可以产生对象的途径.  
   
  以   String   s="abce";形式赋值在java中叫直接量,它是在常量池中而不是象new   一样放在压缩堆中.  
  这种形式的字符串,在JVM内部发生字符串拘留,即当声明这样的一个字符串后,JVM会在常量池中先查找有有没有一个值为"abcd"的对象,如果有,就会把它赋给当前引用.即原来那个引用和现在这个引用指点向了同一对象,如果没有,则在常量池中新创建一个"abcd",下一次如果有String   s1   =   "abcd";又会将s1指向"abcd"这个对象,即以这形式声明的字符串,只要值相等,任何多个引用都指向同一对象.  
   
  而String   s   =   new   String("abcd");和其它任何对象一样.每调用一次就产生一个对象.只到它们调用  
  intern()方法时才会产生上面那种效果.

 

(2)    请问String.equals()和String.equalsIgnoreCase()有什么区别啊？

 

String.equals()对大小写敏感，而String.equalsIgnoreCase()忽略大小写