class ADemo {
public ADemo show(){
  return new ADemo();
}
}
class BDemo extends ADemo{
public BDemo show(){
  return new BDemo();
}
}
为什么我这样写是不报错的呢？

public BDemo show(){
   return new BDemo();
} //这是对父类方法的重写。返回一个子类对象，是属于父类的。
我这样理解：
这里相当于 ADemo a = new BDemo();//现实举例：一个动物的对象创建一个狗。

在多态的情况下，复写，子父类的返回值类型是可以不一样的
但两者必须要有关系，而且子类的返回值类型应比父类的返回值类型小或者相等


class Fu
{
        public Object show()
        {
                System.out.println("Fu");
                return new Object();
        }
}

class Zi extends Fu
{
        public String show()
        {
                System.out.println("Zi");
                return "";
        }
}

class Demo1
{
        public static void main(String args[])
        {
                Fu z = new Zi();
                z.show();//输出Zi，证明了Zi里复写了Fu中的show方法
        }
}

1. class ADemo
   
2. {
   
3.         public ADemo show()
   
4.         {
   
5.                 System.out.println("ADemo show()");
   
6.                 return new ADemo();
   
7.         }
   
8. }
   
9. 
   
10. class BDemo extends ADemo
    
11. {
    
12.         public BDemo show()
    
13.         {
    
14.                 System.out.println("BDemo show()");
    
15.                 return new BDemo();
    
16.         }
    
17. }
    
18. 
    
19. public class Test3
    
20. {
    
21.         public static void main(String []args)
    
22.         {
    
23.                 ADemo a=new ADemo();
    
24.                 a.show();               //输出ADemo show()
    
25.                 BDemo b=new BDemo();
    
26.                 b.show();               //输出BDemo show()
    
27.                 ADemo c=new BDemo();
    
28.                 c.show();               //输出BDemo show()
    
29.         }
    
30. }

复制代码

我的理解：
编译通过，并且c.show()输出的是子类的show方法，说明子类重写了父类中的show方法。
虽然子类中的show方法返回值与父类show方法返回值不同，但子类show方法的返回值类型是父类show方法返回值类型的子类，子类对象会自动向上转型，所以BDemo中的
show方法相当于
public ADemo show()
{
    return new BDemo();
}
所以子类重写了父类的show方法。

好像不是方法的重写吧，方法的重写要求方法的方法头必须一致，不能更改，即：返回值类型、方法名、形参都不能更改，访问控制符权限不能高于父类的方法。
楼主的类Bdemo中的show方法的返回值类型已经变了，显然是又重新定义了一个方法，不应该是重写。

如果问题未解决，请继续追问，如果问题解决了，请将问题分类改为“已解决”，谢谢

1. 多态体现在两方面
   
2.         方法的重载和覆写（方法的多态）
   
3.         对象的多态（接口来实现）
   
4. 两种情况
   
5.         向上转型：父类 父类对象=子类实例（利用接口实现，常用）
   
6.         向下转型：子类 子类对象=（子类）父类示例，（利用继承实现，基本不用）
   
7. 扩展时，上层代码不用改，下层随便改，这种现象就叫多态，可以分工同时工作，提高效率
   
8. public interface IPlane {
   
9.         public void canFly();
   
10. }
    
11. public interface IShip {
    
12.         public void canFloat();
    
13. }
    
14. public class ShipPlane implements IShip,IPlane{
    
15. 
    
16.         @Override
    
17.         public void canFloat() {
    
18.                 System.out.println("水上飞机会漂");
    
19.         }
    
20. 
    
21.         @Override
    
22.         public void canFly() {
    
23.                 System.out.println("水上飞机会飞");
    
24.         }
    
25.        
    
26. }
    
27. public class Test {
    
28.         public void byShip(IShip iship){
    
29.                 iship.canFloat();
    
30.         }
    
31.         public void byPalne(IPlane iplane){
    
32.                 iplane.canFly();
    
33.         }
    
34.         public static void main(String[] args) {
    
35.                 Test t=new Test();
    
36.                 IPlane ip=new ShipPlane();
    
37.                 t.byPalne(ip);
    
38.         }
    
39. }
    
40. public class XiaoYingHao implements IShip{
    
41.         @Override
    
42.         public void canFloat() {
    
43.                 System.out.println("小鹰号航母在漂浮");
    
44.         }
    
45. }
    
46. public class ZhiShengFeiJi implements IPlane{
    
47. 
    
48.         @Override
    
49.         public void canFly() {
    
50.                 System.out.println("直升飞机在飞");
    
51.         }
    
52.        
    
53. }
    

复制代码

因为在new BDemo()时， BDemo()构造方法已经new Aemo(),

重载与方法的访问权限，参数列表，方法名有关，与返回类型无关。