牛角尖一：
Final类可以有protected属性或方法吗？
这是一个典型的牛角尖，一个类被声明为final，说明该类不可被继承，如果类不能被继承，那么它可以有protected的属性和方法吗？

  答案是可以的，那么，这时的protected到底是什么访问权限叫呢？

  一个protected的属性或方法，它可以被同一包中的类访问，或是可以被子类所访问，但是现在它不能有子类，所以，这时protected其实就和默认的访问权限完全相同，变成了同一包中的类可以访问。

代码如下：

1. package net.moon.insignificant.finalclass;
   
2. 
   
3. final class FinalClassSuper{
   
4.         protected void sayHello(){
   
5.                 System.out.println("Hello, world");
   
6.         }
   
7. }
   
8. 
   
9. public class FinalClassDemo{
   
10.         public static void main(String[] args) {
    
11.                 // TODO Auto-generated method stub
    
12.                 FinalClassSuper s = new FinalClassSuper();
    
13.                 s.sayHello();
    
14.         }
    
15. 
    
16. }

复制代码

牛角尖二：类初始化时的执行顺序
在初始化一个类时，到底是先执行哪一部分，总体的执行顺序是什么样的呢，同样，当类被释放时，又是怎样一个顺序呢？先来看下面的代码好了。

1. package net.moon.insignificant.commonclass;
   
2. 
   
3. class CommonSubClass extends CommonSupperClass {
   
4.         static {
   
5.                 System.out.println("Common sub static initial");
   
6.         }
   
7. 
   
8.         public CommonSubClass() {
   
9.                 System.out.println("Common sub construct");
   
10.         }
    
11. 
    
12.         @Override
    
13.         protected void finalize() throws Throwable {
    
14.                 // TODO Auto-generated method stub
    
15.                 System.out.println("Common sub finalize");
    
16.                 super.finalize();
    
17. 
    
18.         }
    
19. }
    
20. 
    
21. abstract class CommonSupperClass {
    
22.         public CommonSupperClass() {
    
23.                 System.out.println("Common super construct");
    
24.         }
    
25. 
    
26.         static {
    
27.                 System.out.println("Common supper static initial");
    
28.         }
    
29. 
    
30.         @Override
    
31.         protected void finalize() throws Throwable {
    
32.                 // TODO Auto-generated method stub
    
33.                 System.out.println("Common supper finalize");
    
34.                 super.finalize();
    
35. 
    
36.         }
    
37. }
    
38. 
    
39. public class Demo {
    
40.         public static void main(String[] args) {
    
41.                 // TODO Auto-generated method stub
    
42.                 CommonSubClass css = new CommonSubClass();
    
43.                 css = null;
    
44.                 System.gc();
    
45. 
    
46.         }
    
47. 
    
48. }

复制代码

只要运行上面的代码，结果如下：

1. Common supper static initial
   
2. Common sub static initial
   
3. Common super construct
   
4. Common sub construct
   
5. Common sub finalize
   
6. Common supper finalize

复制代码

其实大家已经清楚，在初始化时，执行的顺序是：

1.  父类的静态代码块

2. 子类的静态代码块

3. 父类的构造方法

4. 子类的构造方法



  释放资料时，执行的顺序是：

1. 子类的finalize方法

2. 父类的finalize方法

只是这里一个意外是：竟然父类为抽象类时也同样会调用父类的构造方法，看来抽象类在虚拟机内部还是被实例化了。


牛角尖三：Java中只支持单继承吗？
又是一个牛角尖，只是语言不够严谨而已，Java中只支持类的单继承，接口之间的继承同样也是使用extends关键字，但是接口之间是支持多继承的，如下面的例子：

1. interface IP1 {
   
2. }
   
3. 
   
4. interface IP2 {
   
5. }
   
6. 
   
7. public interface ISub extends IP1, IP2 {
   
8. 
   
9. }

复制代码

很明显，上面的代码是没有问题的。所以标题中的应该是不严谨的，严格的说应该是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. }

复制代码

其实这个问题不用担心，因为接口只是对方法的一个声明，并没有具体的实现，所以子接口中的方法属于哪个父接口并不重要，重要的是当实现这个接口的时候只需有一个该方法的实现就可以了，这个方法的实现应该同时属于两个父接口。

  很明显，这不是真正的问题，真正的问题是如果在两个父接口中分别定义了名称和参数都相同，而返回结果却不同的方法：

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. }

复制代码

这同已经有问题了，这时会有编译时错误，原因很简单，方法的重载只能是相同的方法名，不同的输入参数;而对于这两个方法，它们具有相同的方法名，相同的输入参数，只是不同的返回参数，是不能作为重载方法的，所以对于编译器来说，这里是一个方法的重复定义，明显是不能通过编译的。

  同样，这样的问题也存在于一个类同时实现多个接口的情况，所以，在这些情况下，我们必须注意一点，就是具有相同方法名，相同输入参数的方法，是不能出现在同一个类或接口中的。

楼上的太强了。。。。小弟佩服佩服

不错！顶一个