在大多数列具有多个值的情况下，重新变换为宽到宽(Reshape long to wide where most columns have multiple values)

 方法重写必须具有与其重写的父方法相同的方法签名 ，否则它不会被重写。 
 
 Java ： 
 
public abstract class AbstractTest {

    public abstract void test() throws Exception;
}

public class ConcreteTest extends AbstractTest {

    @Override
    public void test() throws Exception {

    }
}
 
 正如你所看到的， ConcreteTest （它扩展了AbstractTest ）必须覆盖test() 。 它们具有相同的方法名称，返回类型和方法参数。 子类可以省略从基类抛出的异常并抛出它自己的异常。 该子类还可以添加额外的（未）检查异常。 
 
 正如Peter Lawrey所提到的，java接口方法是隐式抽象方法（参见我在Java抽象接口上的问题 ）。 
 
 这里至关重要的是，在这种情况下，方法可见性无法改变（因为它是一种层次可见性，即private-> protected-> public）。 虽然这是有效的： 
 
public abstract class AbstractTest {

    protected abstract void test() throws Exception;
}

public class ConcreteTest extends AbstractTest {

    @Override
    public void test() throws Exception {

    }
}
 
 （父级拥有受保护的方法，子类可以覆盖相同的方法，并且只有2种可见性选择：受保护或公共权限）。 
 
 另外，假设你有 
 
public class B {

}

public class D extends B {

}

public abstract class Base {

    public abstract B foo();
}

public class Derived extends Base {

    @Override
    public D foo() {
        // TODO Auto-generated method stub
        return new D();
    }

}
 
 你会看到Derived返回一个D而不是B 这是为什么？ 这是因为派生类遵循与父类相同的签名 ，派生类的返回类型是父类的返回类型的子类型。 
 
 所以，我可以这样做： 
 
Base pureBase = new Derived();
B b = pureBase.foo(); //which returns class D

if (b instanceof D) {
   //sure, it is, do some other logic
}
 
 在C ++中，使用Covariant Return类型可以获得类似的效果 
 
 C ++ 
 
class AbstractTest {
public:
    virtual void test() = 0;
};


class ConcreteTest : AbstractTest {
public:
    void test() {
        //Implementation here...
    }
};
 
 在C ++中，具有纯虚函数的类（以a =0结尾的虚函数）被称为Abstract类。 子类（在C ++中，类扩展由:分隔）覆盖纯虚方法（除了不包含=0 ）。 它的父类具有相同的签名。 
 
 回到我们的Java示例，假设您有： 
 
class B {

};

class D : B {

};

class Base {
public:
    virtual B* foo() = 0;
}

class Derived : Base {
public:
    D* foo() {
        return new D();
    }
}
 
 在这里完成相同的推理（如java中所解释的）。 协变返回类型也适用于受保护和私有继承。 有关Covariant返回类型的更多信息。 

Method overriding must have the same method signature of the parent method it's overriding, otherwise it's not called overriding.
 
Java:
 
public abstract class AbstractTest {

    public abstract void test() throws Exception;
}

public class ConcreteTest extends AbstractTest {

    @Override
    public void test() throws Exception {

    }
}
 
As you can see, ConcreteTest (which extends AbstractTest) must override test(). They have the same method name, return types and no method parameters. The subclass can omit the exceptions thrown from the base class and throw its own Exception. The subclass can also add additional (un)checked exception.
 
As Peter Lawrey mentioned, a java interface methods are implicitly abstract method (See my SO question on Java Abstract Interface).
 
What is crucial here is that the method visibility cannot change in this case (as it's a hierarchical visibility, i.e. private->protected->public). This is valid though:
 
public abstract class AbstractTest {

    protected abstract void test() throws Exception;
}

public class ConcreteTest extends AbstractTest {

    @Override
    public void test() throws Exception {

    }
}
 
(The parent has a protected method and the subclass can override the same method and only has 2 choice for visibility: protected or public).
 
Also, Suppose you have
 
public class B {

}

public class D extends B {

}

public abstract class Base {

    public abstract B foo();
}

public class Derived extends Base {

    @Override
    public D foo() {
        // TODO Auto-generated method stub
        return new D();
    }

}
 
You will see that Derived returns a D and not a B. Why is that? That's because the derived class follows the same signature as the parent class and the return type of the derived class is a subtype of the return type of the parent class.
 
So, I can have this:
 
Base pureBase = new Derived();
B b = pureBase.foo(); //which returns class D

if (b instanceof D) {
   //sure, it is, do some other logic
}
 
In C++, you can get similar effect, using Covariant Return types
 
C++
 
class AbstractTest {
public:
    virtual void test() = 0;
};


class ConcreteTest : AbstractTest {
public:
    void test() {
        //Implementation here...
    }
};
 
In C++, a class with a pure virtual function (a virtual function that ends with a =0) is known as an Abstract class. The subclass (in C++, class extension is delimited by :) override the pure virtual method (except it doesn't contain the =0). It has the same signature has its parent class.
 
Going back to our Java example, suppose you have:
 
class B {

};

class D : B {

};

class Base {
public:
    virtual B* foo() = 0;
}

class Derived : Base {
public:
    D* foo() {
        return new D();
    }
}
 
The same reasoning (as explained in java) is done here. Covariant return types also works with protected and private inheritance. More on Covariant return types.