Java中 通过子类怎么调用父类已经被重写的方法

class A{
void a(){
System.out.println("parent'a()");
}
}

class AA extends A{
void a(){
System.out.println("child'a()");
}d
}

public static void main(String[] agrs){
AA aa = new AA();
aa.a();
A a = (A)aa;
a.a();
}

这两种打印出来的结果都是一样的，怎么才能调用A中的a方法，在不改变 A 和AA的方法的情况下。

你的需求比较怪异.

但是可以折中解决.具体办法是你得有之类的修改权限..

做一个新的方法

代码如下

[code="java"]
import java.io.BufferedReader;

public class baidu extends Search {

public static void main(String[] args) throws IOException {
    new baidu().superFunction() ;
}

public void function(){
    System.out.println("I am baidu!");
}

public void superFunction(){
    super.function() ;
}

}

class Search{
public void function(){
System.out.println("I am search!");
}
}
[/code]

如果你没有..那再看看反射吧..估计可能性不大..还有对无法解决的问题..最好找折中.不要乱用不熟悉或者复杂的东西...

既然A是个class何不自己创建对象直接调用呢？还是有其他需求？

class AA extends A{
void a(){
super.a();
System.out.println("child'a()");
}
}

如果不是类内部，而是外部调用，比如你例子中的main方法，答案是

[b][color=green]不能。你不能调用已经被覆盖掉的父类的方法。[/color][/b]

这也是覆盖override的最初设计意图之一。

大多数时候，覆盖父类意味着子类想做些特殊的处理。如果能够跳过子类的特殊处理，就会打开一个无法控制的缺口，会导致很多很多问题。

唯一可以调用父类方法的地方，就只有类内部。子类自己控制，什么时候该调用父类，什么时候做自己的处理。

关键字 super 用来调用父类的构造方法和操作被隐藏的成员变量和方法。
[code="java"]
class Sum {
int n;
float f() {
float sum = 0;
for(int i=1; i<=n; i++) {
sum = sum+i;
}
return sum;
}
}
class Average extends Sum {
int n;
float f() {
float c;
super.n = n; //操作被隐藏的成员变量
c = super.f(); //操作被隐藏的方法
return c/n;
}
}
public class Test {
public static void main(String[] args) {
Average aver = new Average();
aver.n = 100;
System.out.println(aver.f()); //Print: 50.5
}
[/code]

两种方式吧.
第一种:
子类 重现的方法中 使用 super关键字 去调用父类中的方法或属性；

第二种：
直接实例化 父类

在AA的覆盖方法里面使用super关键字吧，
调用父类的方法，

[code="java"]
class TestExtends
{
public static void main(String[] args)
{
Son son = new Son();

son.superSample();
}

}

class Father
{
public static void sample(){
System.out.println("Father!");
}
}

class Son extends Father
{
public static void sample(){
System.out.println("Son!");
}

public void sing(){
    System.out.println("Testst");
}

public void superSample(){
    super.sample();
}

}
[/code]

LZ的需求只能通过实例化A实现。

不过LZ的需求貌似有问题，试想这个情况：如果父类是个抽象的或接口，你的需求就有问题了, 你不可能调用抽象方法吧。

还有A a = (A)aa; 正这种写法语法方面没有错，但没必要强制类型转换，与A a = aa等价。面向对象中使用子类初始化父类只正确的，只有向下类型转换时才需要强制……

[size=medium]用子类对象去调用父类被子类重写过的方法，这本来就不符合面向对象的思想，或者像楼上说的，用super吧！[/size]