1. package cn.itcast.problem;
   
2. 
   
3. 
   
4. class Fu{
   
5.         private final void doSomething(){
   
6.                 System.out.println("------fu.doSoething()----");
   
7.         }
   
8.         final void doSomething2(){
   
9.                 System.out.println("-------fu.doSomething2()---");
   
10.         }
    
11.         
    
12.         public void doSomething3(){
    
13.                 System.out.println("--------fu.doSomething3()----");
    
14.         }
    
15. }
    
16. 
    
17. class Zi extends Fu{
    
18.         public final void doSomething(){
    
19.                 System.out.println("------zi.doSomething()----");
    
20.         }
    
21.         
    
22.         public void doSomething3(){
    
23.                 System.out.println("------zi.doSomething3()----");
    
24.         }
    
25. }
    
26. 
    
27. public class ForFinalTest {
    
28. 
    
29.         public static void main(String[] args) {
    
30.                 Zi z=new Zi();
    
31.                 z.doSomething();
    
32.                 z.doSomething2();
    
33.                 z.doSomething3();
    
34.                
    
35. /*        运行结果：
    
36. * ------zi.doSomething()----
    
37. -------fu.doSomething2()---
    
38. ------zi.doSomething3()----
    
39. 
    
40.         这子类的doSomething()方法是对父类的复写么，不是说final修饰不可以，
    
41.         求解释？
    
42.                
    
43.                
    
44.         */
    
45.         }        
    
46. }
    

复制代码

不是重写，因为父类的方法是private的，子类不能继承父类的私有方法

final定义的是最终类，不可以被继承，final修饰的方法不能被覆盖。final定义变量时，就表示这个变量一旦被赋值便不可以被改变，而且对于对象变量来说其引用不可再变。

没有被复写，父类中的那个方法是私有的，子类根本就不知道父类有那个方法， 就算子类现在有这个方法那也是子类自己的方法

class Fu{
        public final void doSomething(){
                System.out.println("------fu.doSoething()----");
        }
        final void doSomething2(){
                System.out.println("-------fu.doSomething2()---");
        }
        
        public void doSomething3(){
                System.out.println("--------fu.doSomething3()----");
        }
}
class Zi extends Fu{
//此处报编译时异常：Cannot override the final method from Fu，即不能覆盖父类的final方法
        public final void doSomething(){
                System.out.println("------zi.doSomething()----");
        }
        
        public void doSomething3(){
                System.out.println("------zi.doSomething3()----");
        }
}
public class ForFinalTest {
        public static void main(String[] args) {
                Zi z=new Zi();
                z.doSomething();
                z.doSomething2();
                z.doSomething3();
               
/*        运行结果：
* ------zi.doSomething()----
-------fu.doSomething2()---
------zi.doSomething3()----
        这子类的doSomething()方法是对父类的复写么，不是说final修饰不可以，
        求解释？
        */
        }        
}

父类的private方法不能被子类继承，当子类内部再写一个doSomething()方法时，会被认为是新增加的方法，而不是覆盖父类的。
我把楼主的代码修改了一下，就会报编译时异常。如上
final类不能被继承，final方法不能被覆盖

首先，没有被重写。其次，final修饰的确不可以被重写。
由于你代码父类用的是私有的，所以没有被重写。子类是看不到父类有这个方法的。
如果都改成
class Fu{
    public void doSomething(){           
               System.out.println("------fu.doSoething()----");
    }
    final void doSomething2(){
            System.out.println("-------fu.doSomething2()---");
    }
   
    public void doSomething3(){
            System.out.println("--------fu.doSomething3()----");
    }
}

class Zi extends Fu{
    public void doSomething(){            
                       System.out.println("------zi.doSomething()----");
    }
   
    public void doSomething3(){
            System.out.println("------zi.doSomething3()----");
    }
}
这个样子肯定是可以的。

但如果使用final就会报错了。

你的Fu类 又没有被final修饰   

再者 你    private final void doSomething()
      和
                public final void doSomething()
根本就不是同一个方法，  不是复写的，下面那个 public的是 子类自己的方法

上面的都说的很清楚了 呵呵  {:soso_e179:}

ok  了  :)