Java牛角尖【011】： Java中只支持单继承吗？

又是一个牛角尖，只是语言不够严谨而已，Java中只支持类的单继承，接口之间的继承同样也是使用extends关键字，但是接口之间是支持多继承的，如下面的例子： 
Java代码 
1.  interface IP1 {    
2.  }    
3.      
4.  interface IP2 {    
5.  }    
6.      
7.  public interface ISub extends IP1, IP2 {    
8.      
9.  }    
    
很明显，上面的代码是没有问题的。所以标题中的应该是不严谨的，严格的说应该是Java中类的继承只支持单继承。 
  当然，这样我们自然会想到多继承的问题，如果两个父接口中有同样的方法，那么子接口中怎么办呢？ 
Java代码 
1.  interface IP1 {    
2.      public void test();    
3.  }    
4.      
5.  interface IP2 {    
6.      public void test();    
7.  }    
8.      
9.  public interface ISub extends IP1, IP2 {    
10.     
11. }    

  其实这个问题不用担心，因为接口只是对方法的一个声明，并没有具体的实现，所以子接口中的方法属于哪个父接口并不重要，重要的是当实现这个接口的时候只需有一个该方法的实现就可以了，这个方法的实现应该同时属于两个父接口。 
  很明显，这不是真正的问题，真正的问题是如果在两个父接口中分别定义了名称和参数都相同，而返回结果却不同的方法： 
Java代码 
1.  interface IP1 {    
2.      public void test();    
3.  }    
4.      
5.  interface IP2 {    
6.      public String test();    
7.  }    
8.      
9.  public interface ISub extends IP1, IP2 {    
10.     
11. }  
  
  这同已经有问题了，这时会有编译时错误，原因很简单，方法的重载只能是相同的方法名，不同的输入参数;而对于这两个方法，它们具有相同的方法名，相同的输入参数，只是不同的返回参数，是不能作为重载方法的，所以对于编译器来说，这里是一个方法的重复定义，明显是不能通过编译的。 
  同样，这样的问题也存在于一个类同时实现多个接口的情况，所以，在这些情况下，我们必须注意一点，就是具有相同方法名，相同输入参数的方法，是不能出现在同一个类或接口中的。 
Java牛角尖【012】： JDBC开发时为什么要用Class.forName("") 
  前几天看到一个帖子中提出一个问题，在JDBC的开发中为什么要使用Class.forName，可以不用这句吗？ 
  我们从代码出发，来分析一下这个问题。 
  下面是一段我们常用的JDBC开发中的代码(注：本文中例子使用Mysql为例子。为方便演示，代码中忽略异常处理) 

Java代码 
1.  Class.forName("com.mysql.jdbc.Driver");    
2.  conn = DriverManager.getConnection(    
3.          "jdbc:mysql://localhost:3306/mysql", "root", "");    
4.  stmt = conn.createStatement();    
5.  rs = stmt.executeQuery("select count(0) from user");    
6.  while (rs != null && rs.next()) {    
7.      System.out.println(rs.getInt(1));    
8.  }    

  运行代码，结果正常，打印出了Mysql数据库中的用户数。 
  我们先尝试将第一句拿掉，看是不是也可以运行。 

Java代码 
1.  // 拿掉Class.forName语句，看一下运行结果    
2.  // Class.forName("com.mysql.jdbc.Driver");    
3.  conn = DriverManager.getConnection(    
4.          "jdbc:mysql://localhost:3306/mysql", "root", "");    
5.  stmt = conn.createStatement();    
6.  rs = stmt.executeQuery("select count(0) from user");    
7.  while (rs != null && rs.next()) {    
8.      System.out.println(rs.getInt(1));    
9.  }   

  运行代码，报如下错误： 

Java代码 
1.  java.sql.SQLException: No suitable driver found for jdbc:mysql://localhost:3306/mysql    
2.      at java.sql.DriverManager.getConnection(DriverManager.java:602)    
3.      at java.sql.DriverManager.getConnection(DriverManager.java:185)    
4.      at net.moon.jdbc.demo.Demo.main(Demo.java:18)    

  看来是不行，那让我们来分析一下，Class.forName(String clz)这样一个方法到底做了什么呢？ 
  看一下API，API中Class.forName方法的声明如下： 

Java代码 
1.  public static Class<?> forName(String className)    
2.                          throws ClassNotFoundException    

  该方法是根据一个字符串，得到这个字符串所表示的类，但是我们上面代码中并没有一个引用指向这个返回的结果，也就是代码并不关注返回的结果，那为什么还要执行这句话呢，继续往下看API中的说明，有这样一句：“A call to forName("X") causes the class named X to be initialized”。 
  问题似乎有点眉目了，原来在执行Class.forName("com.mysql.jdbc.Driver")这个语句时，com.mysql.jdbc.Driver这个类被初始化了，那一定是在初始化中做了什么动作。为了证实这点，我们对上面的代码做一点修改： 

Java代码 
1.  // Class.forName("com.mysql.jdbc.Driver");    
2.  // 新建一个Driver对象，同样不关注返回的结果    
3.  new com.mysql.jdbc.Driver();    
4.  conn = DriverManager.getConnection(    
5.          "jdbc:mysql://localhost:3306/mysql", "root", "");    
6.  stmt = conn.createStatement();    
7.  rs = stmt.executeQuery("select count(0) from user");    
8.  while (rs != null && rs.next()) {    
9.      System.out.println(rs.getInt(1));    
10. }    

  运行代码，和预想的一样，同样可以得到运行结果。 
  我们再来想一下，com.mysql.jdbc.Driver这个类在初始化的时候到底执行了什么？先来回忆一下以前的一篇文章：Java牛角尖【003】：类初始化时的执行顺序。明白了，好像有这样一个概念：静态代码块。 
  一定是在com.mysql.jdbc.Driver这个类中有一段静态代码段，这段代码执行了某些动作。 
  之所以用Mysql做为例子，还有另外一个优点，那就是开源，开源也就是说我们可以看到它的代码，所以下个任务就是找到com.mysql.jdbc.Driver这个类的源码来看一下了。 
  代码如下： 

Java代码 
1.  static {    
2.      try {    
3.          java.sql.DriverManager.registerDriver(new Driver());    
4.      } catch (SQLException E) {    
5.          throw new RuntimeException("Can't register driver!");    
6.      }    
7.  }  
  
  这段代码似乎比我们想象的要简单，是透过java.sql.DriverManager这个类的静态方法registerDriver这个方法注册这个JDBC驱动。 
  最后一个问题就是为什么这里要调用registerDriver方法呢，那就是来看一下DrvierManager的API了，如下： 
Java代码 
   
1.  registerDriver    
2.  public static void registerDriver(Driver driver)    
3.                             throws SQLException    
4.      
5.  向 DriverManager 注册给定驱动程序。新加载的驱动程序类应该调用 registerDriver 方法让 DriverManager 知道自己。     
6.      
7.  参数：    
8.  driver - 将向 DriverManager 注册的新的 JDBC Driver     
9.  抛出：     
10. SQLException - 如果发生数据库访问错误    

Java牛角尖【013】： finally块中的代码一定会执行吗？ 
  在Sun Tutorial中有这样一句话：The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs.  看来finally块中的语句应该是总会执行的。 
  先来写一个最常见的写法： 
Java代码 
public class Test {    
        public static void main(String[] args) {    
            try {    
                System.out.println(args[0]);    
                System.out.println("I'm nomal");    
            } catch (Exception ex) {    
                System.out.println("I'm exception");    
            } finally {    
                System.out.println("I'm finally.");    
            }    
        }    
    }   

  运行这段代码，很明显，不论是否有参考输入，"I'm finally."这句话都会打印出来。这是最常用的写法，很显然与Tutorial中的说明是相符的。 
  下面我们再进一步想一下，假如在try或是catch块中使用了return语句，那么会怎么样呢？ 
  我们将代码稍做修改： 

Java代码 
public class Test {    
        public static void main(String[] args) {    
            try {    
                System.out.println(args[0]);    
                System.out.println("I'm nomal");    
                            return;    
            } catch (Exception ex) {    
                System.out.println("I'm exception");    
                            return;    
            } finally {    
                System.out.println("I'm finally.");    
            }    
        }    
    }    

  代码的修改很简单，只是在try和catch块的结束位置分别加了一个return语句。 
  这样运行结果是什么呢？可能会有两种猜想了，或是直接退出，或是仍会打印"I'm finally."。验证真理的方法是实践，我们运行这段代码，看一下结果： 
Java代码 
>java Test    
I'm exception    
I'm finally.    
    
>java Test hello    
hello    
I'm nomal    
I'm finally.  
  
  上面分别是输入和不输入参数时运行的结果，很明显，finally中的代码还是执行了。那是不是说try和catch块中的return语句并不起作用吗？我们再次简单修改代码： 

Java代码 
public class Test {    
        public static void main(String[] args) {    
            try {    
                System.out.println(args[0]);    
                System.out.println("I'm nomal");    
                            return;    
            } catch (Exception ex) {    
                System.out.println("I'm exception");    
                            return;    
            } finally {    
                System.out.println("I'm finally.");    
            }    
                    System.out.println("Out of try.");    
        }    
    }    

  在try语句外面再加入一名打印代码，再次编译。 
  编译错误，结果如下： 

Java代码 
Exception in thread "main" java.lang.Error: Unresolved compilation problem:     
    Unreachable code    

  提示代码不可达，看来return还是有用的，只是在退出方法呼叫之前，会先去执行finally中的代码。 
  现在似乎说明了另外一个问题，是不是return语句还不够厉害，“让暴风雨来的更猛烈些吧”，我们再次修改代码，将return语句修改成System.exit()，看一下执行结果。 

Java代码 
public class Test {    
        public static void main(String[] args) {    
            try {    
                System.out.println(args[0]);    
                System.out.println("I'm nomal");    
                            System.exit(0);    
            } catch (Exception ex) {    
                System.out.println("I'm exception");    
                            System.exit(0);    
            } finally {    
                System.out.println("I'm finally.");    
            }    
        }    
    }    

  运行代码，终于，"I'm finally."不见了。 
  为什么System.exit()有这么强大的力量呢，让我们看一下API中的说明：exit(int status): Terminates the currently running Java Virtual Machine。原来是这样，JVM都被终止掉了，当然不会再执行finally中的语句了。 
  下面是我们的结论： 
  在不终止VM的情况下，finally中的代码一定会执行。