建立子类对象后，想用父类的方法，不想让子类覆盖怎么办？

可以考虑使用静态static方法   

class   GrandPa   
  {   
          static   void   Method()   
          {   
                  System.out.println("Hello,   I   am   GrandPa!");   
          }   
  }   

class   Father   extends   GrandPa   
  {   
          static   void   Method()   
          {   
                  System.out.println("Hello,   I   am   Father!");   
          }   
  }   

class   Son   extends   Father   
  {   
          static   void   Method()   
          {   
                  GrandPa.Method();//   这样可以调用GrandPa的Method   
   
                  Father.Method();   
            
                  System.out.println("And   Son   is   followed!");   
          }   
  }

夏一站 发表于 2013-6-13 20:05
可以考虑使用静态static方法   

class   GrandPa   

1. class   Fu   //父类对象
   
2.   {   
   
3.            void   Method()   
   
4.           {   
   
5.                   System.out.println("Fu    run!");   
   
6.           }   
   
7.   }   
   
8. 
   
9. class   Zi  extends   Fu  //子类继承父类对象
   
10.   {   
    
11.           void   Method()   
    
12.           {              
    
13.                   System.out.println("Zi    run!");   
    
14.           }   
    
15.   }
    
16. class   Demo
    
17. {
    
18.          public static  void main (String[]  args)
    
19.         {
    
20.              Fu   z  =   new  Zi();
    
21.               z.Method();
    
22.        }   
    
23. 
    
24. }
    
25. //运行结果是Zi  run！我的意思是在这之后又想用父类的方法。

复制代码

定义一个父类对象的变量指向子类         Father  f  = new son();

风雨兼程 发表于 2013-6-13 20:42

看题内容，让我相到了私有，但是楼楼这个回答。。。。。
我想说创建父类对象吧

楼主的意思是这样的吧：子类Son的方法中想要调用父类Father的方法，但是Son中不能重写（Override）方法。
如：Son如果能够使用Father的方法m1(),则改方法不能用private修饰；同时Son不能继承方法m1()，加上final修饰符即可。如下代码所示：

1. public class Son extends Father {
   
2.         //编译报错，final方法不能被重写
   
3.         /*@Override
   
4.         public void m1(){
   
5.                 System.out.println("m1");
   
6.         }*/
   
7.         
   
8.         public void m2(){
   
9.                 m1();
   
10.         }
    
11.         
    
12. public static void main(String[] args) {
    
13.                 new Son().m2();
    
14.         }
    
15. }
    

复制代码

1. public class Father {        
   
2.         //该方法不能用private修饰，否则子类中无法直接访问
   
3.         final void m1(){
   
4.                 System.out.println("m1");
   
5.         }
   
6. }

复制代码

那就用反射吧，前提是我知道父类有一个不带参数的构造函数

1. package com.heima.duotai;
   
2. 
   
3. public class Demo {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9. 
   
10.         Fu   z  =   new  Zi();
    
11.       Class<Fu> clazz =  (Class<Fu>) z.getClass().getSuperclass();
    
12.       try {
    
13.                 Fu f =(Fu)clazz.newInstance();
    
14.                 f.Method();
    
15.         } catch (Exception e) {
    
16.                 // TODO Auto-generated catch block
    
17.                 e.printStackTrace();
    
18.         }  
    
19.          z.Method();
    
20.         }
    
21. 
    
22. }
    
23. class   Fu   //父类对象
    
24. {   
    
25.          void   Method()   
    
26.         {   
    
27.                 System.out.println("Fu    run!");   
    
28.         }   
    
29. }   
    
30. 
    
31. class   Zi  extends   Fu  //子类继承父类对象
    
32. {   
    
33.         void   Method()   
    
34.         {              
    
35.                 System.out.println("Zi    run!");   
    
36.         }   
    
37. }

复制代码

如果问题已经解决  请把帖子的类型改为已解决