要想了解这个问题怎么回答，我认为首先我们应该了解下Java中的一个重要的语法：

静态绑定和动态绑定

首先，一个Java程序的执行要经过编译和执行（解释）这两个步骤，同时Java又是面向对象的编程语言。当子类和父类存在同一个方法，子类重写了父类的方法，程序在运行时调用方法是调用父类的方法还是子类的重写方法呢，这应该是我们在初学Java时遇到的问题。这里首先我们将确定这种调用何种方法实现或者变量的操作叫做绑定。

在Java中存在两种绑定方式，一种为静态绑定，又称作早期绑定。另一种就是动态绑定，亦称为后期绑定。

区别对比

1.静态绑定发生在编译时期，动态绑定发生在运行时
2.使用private或static或final修饰的变量或者方法，使用静态绑定。而虚方法（可以被子类重写的方法）则会根据运行时的对象进行动态绑定。
3.静态绑定使用类信息来完成，而动态绑定则需要使用对象信息来完成。
4.重载(Overload)的方法使用静态绑定完成，而重写(Override)的方法则使用动态绑定完成。

重载方法的示例

这里展示一个重载方法的示例。

执行的结果为

在上面的代码中，call方法存在两个重载的实现，一个是接收Object类型的对象作为参数，另一个则是接收String类型的对象作为参数。str是一个String对象，所有接收String类型参数的call方法会被调用。而这里的绑定就是在编译时期根据参数类型进行的静态绑定。

验证

光看表象无法证明是进行了静态绑定，使用javap -C 编译一下即可验证。

看到了这一行18: invokevirtual #6 // Method TestMain$Caller.call:(Ljava/lang/String;)V确实是发生了静态绑定，确定了调用了接收String对象作为参数的caller方法。

重写方法的示例

执行的结果为

上面的代码，Caller中有一个call方法的实现，SubCaller继承Caller，并且重写了call方法的实现。我们声明了一个Caller类型的变量callerSub，但是这个变量指向的时一个SubCaller的对象。根据结果可以看出，其调用了SubCaller的call方法实现，而非Caller的call方法。这一结果的产生的原因是因为在运行时发生了动态绑定，在绑定过程中需要确定调用哪个版本的call方法实现。

验证

使用javap不能直接验证动态绑定，然后如果证明没有进行静态绑定，那么就说明进行了动态绑定。

正如上面的结果，18: invokevirtual #6 // Method TestMain$Caller.call:(Ljava/lang/String;)V这里是TestMain$Caller.call而非TestMain$SubCaller.call，因为编译期无法确定调用子类还是父类的实现，所以只能丢给运行时的动态绑定来处理。

当重载遇上重写

下面的例子有点{{BANNED}}哈，Caller类中存在call方法的两种重载，更复杂的是SubCaller集成Caller并且重写了这两个方法。其实这种情况是上面两种情况的复合情况。

下面的代码首先会发生静态绑定，确定调用参数为String对象的call方法，然后在运行时进行动态绑定确定执行子类还是父类的call实现。

执行结果为：

验证

由于上面已经介绍，这里只贴一下反编译结果啦

好奇问题

非动态绑定不可么？

其实理论上，某些方法的绑定也可以由静态绑定实现。比如：

比如这里callerSub持有subCaller的对象并且callerSub变量为final，立即执行了call方法，编译器理论上通过足够的分析代码，是可以知道应该调用SubCaller的call方法。

但是为什么没有进行静态绑定呢？
假设我们的Caller继承自某一个框架的BaseCaller类，其实现了call方法，而BaseCaller继承自SuperCaller。SuperCaller中对call方法也进行了实现。

假设某框架1.0中的BaseCaller和SuperCaller

而我们使用框架1.0进行了这样的实现。Caller继承自BaseCaller，并且调用了super.call方法。

然后我们基于这个框架的1.0版编译出来了class文件，假设静态绑定可以确定上面Caller的super.call为BaseCaller.call实现。

然后我们再次假设这个框架1.1版本中BaseCaller不重写SuperCaller的call方法，那么上面的假设可以静态绑定的call实现在1.1版本就会出现问题，因为在1.1版本上super.call应该是使用SuperCall的call方法实现，而非假设使用静态绑定确定的BaseCaller的call方法实现。

所以，有些实际可以静态绑定的，考虑到安全和一致性，就索性都进行了动态绑定。

得到的优化启示？

由于动态绑定需要在运行时确定执行哪个版本的方法实现或者变量，比起静态绑定起来要耗时。

所以在不影响整体设计，我们可以考虑将方法或者变量使用private，static或者final进行修饰。

综上所述：  理解了动态绑定和静态绑定后，回头我们在来看我们的问题

Java中子类重写了父类的某个方法后，父类中还可以调用自己被重写的那个方法吗？

答案是： 如果父类声明指向自己子类的实例对象，那么可以通过父类声明调用子类重写的那个方法， 如果父类声明指向的是父类本身那么可以调用父类实例中的方法。

ok！ 我们说了太长了，我们就到这里，希望能够对你有所帮助！

是可以的，下面是一个例子，请参考。

public class SomeClass1 {
    public void method1(){
        method2();
    }
    public void method2(){
        System.out.println("Someclass1 method2 invoked");
    }
}
class SomeClass2 extends SomeClass1{
    @Override
    public void method2() {
        System.out.println("SOmeclass2 method2 invoked");
    }

    public static void main(String[] args) {
        SomeClass1 sc = new SomeClass2();
        sc.method1();
    }
}

输出：

SOmeclass2 method2 invoked

是可以的，下面是一个例子，请参考。

public class SomeClass1 {
    public void method1(){
        method2();
    }
    public void method2(){
        System.out.println("Someclass1 method2 invoked");
    }
}
class SomeClass2 extends SomeClass1{
    @Override
    public void method2() {
        System.out.println("SOmeclass2 method2 invoked");
    }

    public static void main(String[] args) {
        SomeClass1 sc = new SomeClass2();
        sc.method1();
    }
}

输出：

SOmeclass2 method2 invoked

多态的体现。

代码如下;

package TestMENG;public class Base { 
    int i = 99; 

    public void amethod() {  
        System.out.println(" Base.amethod() "); 
    } 
    Base() {  
        amethod(); 
    }
}

package TestMENG;
public class Derived extends Base { 
    int i = -1; 
    
    public static void main(String argv[]) {  
        Base b = new Derived();  
        System.out.print(b.i);  
        b.amethod(); 
    }
    
    public void amethod() {  
        System.out.print(" Derived.amethod() "); 
    }
}

控制台打印输出：     Derived.amethod() 99    Derived.amethod() 

上面代码经过debug调试  效果如下

当执行到Base()方法中的 amethod()方法时  将会跳转到子类Derived.amethod()方法中。

 

 

 

 涉及到的知识点：

1.父类的属性 不能被子类覆盖。

2.在实例化子类对象时，如果父类的实例引用了子类的对象（多态），例如：父类　实例 = new 子类（）

   那么该引用在调用父类的方法时遵循以下原则

      2.1  该实例 可以调用父类中特有的方法。（该方法未被子类重写）

      2.2  该实例如果调用父类中的方法，若该方法被子类重写，则一定调用的是在子类中重写后的该方法。

      2.3   该实例不可以调用父类中没有的方法。（该方法子类特有）