1. package cn.itcast.problem;
   
2. 
   
3. class Parsent{
   
4.         Parsent(){
   
5.                 System.out.println("-----Parsent------");
   
6.                 //为什么结果当中这没有输出，不是说隐示的super()调用父类的空参数构造//这个没问题,失误 不好意思
   
7.         }
   
8.         public Parsent get(){
   
9.                 return new Parsent();
   
10.         }
    
11. }
    
12. 
    
13. class Sub extends Parsent{//
    
14.         Sub(){
    
15.                 //super();
    
16.                 System.out.println("------sub------");
    
17.         }
    
18.         public Sub get(){//不是说不能改变覆盖(重写)方法的返回值类型了吗？
    
19.                 return new Sub();
    
20.         }
    
21. }
    
22. public class ForOverLoad {
    
23. 
    
24.         
    
25.         public static void main(String[] args) {
    
26.                
    
27.                 Sub sb=new Sub();
    
28. /*        结果：
    
29. *-----Parsent------//
    
30. ------sub------
    
31. 
    
32. *         
    
33.         */        
    
34.         }
    
35. 
    
36. }

复制代码

李铁 发表于 2012-10-5 11:48
我觉得你是把重载与重写理解没有弄清楚
首先要了解什么是重载与重写（覆盖）
重载（Overoad）:如果在一个类 ...

楼上  写的武断了点吧  ，重写可以改变，也不全是吧  你将上面get()方法返回值类型为String的写给我看看

{:soso_e127:}不好意思，这是写的失误，难怪觉得怎么
-----Parsent------
没有输出，
但是下面的问题依旧  见谅

Parsent类与Sub类没有继承与被继承的关系。
当
class Parsent{
        Parsent(){
                System.out.println("-----Parsent------");
                //为什么结果当中这没有输出，不是说隐示的super()调用父类的空参数构造
        }
        public Parsent get(){
                return new Parsent();
        }
}

class Sub extends Parsent{
        Sub(){
                //super();
                System.out.println("------sub------");
        }
        public Sub get(){//不是说不能改变重载方法的返回值类型了吗？
                return new Sub();
        }
}
这个样子的时候就可以了。

结果为：

-----Parsent------
------sub------

我觉得你是把重载与重写理解没有弄清楚
首先要了解什么是重载与重写（覆盖）
重载（Overoad）:如果在一个类中定义了多个同名的方法，但是有不同参数个数或者参数类型,顺序必须不同，重载与返回值没有关系；称为重重载
重写（覆盖Override）是子类与父类之间多态的一种表现，如果在子类中定义与其父类有相同的名称和参数，称为重写或者说是覆盖。
下面个简单的例子：
父类：
public class Father {
        //父类的构造方法
        Father(){
                System.out.println("QQQQ");
        }
         public Father get(){
                   return new Father();
           }
   public void fun1(){
           fun2();
   }
   public void fun2(){
           System.out.println("AAAA");
   }
   //重载fun2()方法，注意：重载与返回值类型没有关系。
   public int fun2(int i){
           return i;
   }
}
子类：
public class Child extends Father {
        //子类的构造方法
   Child(){
           //supuer();隐式的调用了父类的构造方法
           System.out.println("FFF");
   }       
   //get()是重写（覆盖）了父亲的方法，重写（覆盖）是可以改变返回值的类型的
   public Child get(){
           return new Child();
   }
  public void fun2(){
           System.out.println("CCC");
  }
   public static void main(String args[]){
           //成员方法在多态调用时，编译看左边，运行看右边
           Father child=new Child();
           child.fun1();
          
   }
}


输出结果：
QQQQ
FFF
CCC

明显的不对，在这里你根本就没有继承parent类，你总不能写个parent就说它是父类，写个sub就说它是子类吧，它们还需要继承关系，关系才能说明一切，表面看到的并不能说明什么

class Parsent{
        Parsent(){
                System.out.println("-----Parsent------");
                //为什么结果当中这没有输出，不是说隐示的super()调用父类的空参数构造
        }
        public Parsent get(){
                return new Parsent();
        }
}

class Sub extends Parsent{//如果你不写extends那他就继承的是Object，那你还调用什么？
        Sub(){
                //super();
                System.out.println("------sub------");
        }
        public Sub get(){//不是说不能改变重载方法的返回值类型了吗？
                return new Sub();
        }
}
public class ForOverLoad{

        
        public static void main(String[] args) {
               
                Sub sb=new Sub();
/*        结果：
* ------sub------

*         
        */        
        }

}

override与overload的前提是继承，而你的sub是继承字Object类，并非继承自Parsent