Question

代码1：

class Tyre 
{
    public void front() throws RuntimeException 
    {
        System.out.println("Tire");
    }
    public void front(int a) 
    {
        System.out.println("Radial Tire with int in tyre");
    }
    public void front(long a) 
    {
        System.out.println("Radial Tire with long");
    }
}

class RadialTyre extends Tyre 
{
    public void front() 
{
        System.out.println("Radial Tire");
    }
    public void front(int a) 
    {
        System.out.println("Radial Tire with int");
    }
}

class Test
{
      public static void main(String... args) 
      {
              Tyre t = new RadialTyre();
              int a = 10;
              t.front(a); 
      }
}

o / p代码1：-Radial Tire with int

代码2： -

class Tyre 
{
    public void front() throws RuntimeException 
    {
        System.out.println("Tire");
    }

    public void front(long a) 
    {
        System.out.println("Radial Tire with long");
    }
}

class RadialTyre extends Tyre 
{
    public void front() 
{
        System.out.println("Radial Tire");
    }
    public void front(int a) 
    {
        System.out.println("Radial Tire with int");
    }
}

class Test
{
      public static void main(String... args) 
      {
              Tyre t = new RadialTyre();
              int a = 10;
              t.front(a); 
      }
}

代码2的

o / p： - 长

的径向轮胎

为什么在code2父类long方法中调用code1子类int方法？如果由于扩大而发生这种情况，那么为什么在案例1中不会扩大？在code1中，为什么在父类中已存在int方法时调用子类int方法？

Answer 1

为什么在code2父类long方法中调用code1子类int方法？

由于您不覆盖，您重载。重载是指方法名称相同但签名不同（即long参数vs int）。

由于您指的是Tyre类型而非RadialTyre类型，并且该方法front没有覆盖，它会选择Tyre唯一知道的方法：带long参数的那个。

class RadialTyre extends Tyre {
    // This is an overLOAD, same method name but different parameter type
    public void front(long a) {
        System.out.println("Radial Tire with int");
    }

    // This is an overRIDE, same method name with same signature
    public void front(int a) {
        System.out.println("Radial Tire with long - override");
    }
}

在code1中，为什么在父类中已存在int方法时调用子类int方法？

这就是最重要的工作方式。如果一个类扩展了另一个类并覆盖了一个或多个超类方法，则会调用它们。

覆盖 - 为什么要调用long而不是int

1 个答案: