class A { double f (double x, double y) { return x + y; } static int g(int n) { return n * n; } } class B extends A { double f(double x, double y) { double m = super.f(x, y); return m + x * y; } static int g(int n) { int m = A.g(n); return m + n; } } public class E { public static void main(String[] args) { B b = new B(); System.out.println(b.f(6.0,12.0)); System.out.println(b.g(8)); A a = new B(); System.out.println(a.f(6.0,12.0)); System.out.println(a.g(8)); } }运行
时间: 2024-02-14 13:08:19 浏览: 34
这段代码的输出结果是:
```
78.0
64
78.0
64
```
首先,定义了一个类 `A`,其中有一个非静态的方法 `f` 和一个静态的方法 `g`。然后,定义了一个类 `B`,继承自 `A`,并且重写了方法 `f` 和方法 `g`。
在 `B` 中的方法 `f` 中,先调用了 `super.f(x, y)`,即调用父类的 `f` 方法,然后将结果保存在变量 `m` 中,最后返回 `m + x * y` 的值。
在 `B` 中的方法 `g` 中,先调用了 `A.g(n)`,即调用父类的静态方法 `g`,然后将结果保存在变量 `m` 中,最后返回 `m + n` 的值。
在 `main` 方法中,首先创建了一个 `B` 类对象 `b`,然后分别调用了 `b.f(6.0,12.0)` 和 `b.g(8)` 方法,并将结果输出。
接着,创建了一个 `A` 类对象 `a`,但是通过 `new B()` 的方式创建,然后同样分别调用了 `a.f(6.0,12.0)` 和 `a.g(8)` 方法,并将结果输出。需要注意的是,虽然 `a` 的实际类型是 `B`,但是调用的是 `A` 类的方法,因此调用的是 `B` 类重写之前的 `f` 方法和 `A` 类的静态方法 `g`。但是,由于 `B` 类并没有重写 `f` 方法,因此调用的其实还是 `B` 类中的 `f` 方法。最终输出的结果与调用 `b.f` 和 `b.g` 方法时的结果相同。
相关问题
class A i double f(double x,double y)f return x+y; } static int g(int n) i return n* n; } } class B extends A i double f(double x,double y) i double m = super.f(x,y);return m+x* y; } static int g(int n){ int m = A.g(n);return m +n; } }public class E i public static void main(String[ ] args){ Bb = new B(); system.out.print1n(b.f(10.0,8.0));System.out.print1n(b.g( 3)); Aa = new B(); System.out.print1n(a.f(10.0,8.0));System.out.print1n(a.g(3)); } }运行结果
这段代码中有一些错误,我先进行修正:
```
class A {
public double f(double x, double y) {
return x + y;
}
public static int g(int n) {
return n * n;
}
}
class B extends A {
public double f(double x, double y) {
double m = super.f(x, y);
return m + x * y;
}
public static int g(int n) {
int m = A.g(n);
return m + n;
}
}
public class E {
public static void main(String[] args) {
B b = new B();
System.out.println(b.f(10.0, 8.0));
System.out.println(b.g(3));
A a = new B();
System.out.println(a.f(10.0, 8.0));
System.out.println(a.g(3));
}
}
```
修正后,运行结果为:
```
108.0
12
108.0
9
```
解释一下运行结果:
1. `b.f(10.0, 8.0)` 调用的是类 B 中的 `f` 方法,先调用了 A 类中的 `f` 方法求出 `m` 的值,然后返回 `m+x*y`,即 `18+80=108.0`。
2. `b.g(3)` 调用的是类 B 中的 `g` 方法,先调用了 A 类中的 `g` 方法求出 `m` 的值,然后返回 `m+n`,即 `9+3=12`。
3. `a.f(10.0, 8.0)` 调用的是类 B 中的 `f` 方法,因为 `a` 是一个 `A` 类型的变量,但是 `a` 实际上是一个 `B` 类型的对象,所以调用的是 `B` 类中的 `f` 方法。和上面的情况一样,先调用了 A 类中的 `f` 方法求出 `m` 的值,然后返回 `m+x*y`,即 `18+80=108.0`。
4. `a.g(3)` 调用的是类 A 中的 `g` 方法,因为 `g` 是一个静态方法,所以不会根据对象类型来调用方法。直接返回 `n*n`,即 `3*3=9`。
class A { double f (double x, double y) { return x + y; } static int g(int n) { return n * n; } } class B extends A { double f(double x, double y) { double m = super.f(x, y); return m + x * y; } static int g(int n) { int m = A.g(n); return m + n; } } public class E { public static void main(String[] args) { B b = new B(); System.out.println(b.f(6.0,12.0)); System.out.println(b.g(8)); A a = new B(); System.out.println(a.f(6.0,12.0)); System.out.println(a.g(8)); } }运行并解释
这段代码定义了三个类 A、B 和 E,其中 E 是主类,包含了 main 方法。
类 A 中有一个方法 f,它接受两个 double 类型的参数 x 和 y,返回它们的和。还有一个静态方法 g,它接受一个 int 类型的参数 n,返回 n 的平方。
类 B 继承自 A,并且覆盖了方法 f 和 g。方法 f 调用了父类 A 的方法 f,并在其基础上再加上 x 和 y 的乘积。方法 g 调用了父类 A 的静态方法 g,并在其基础上再加上参数 n。
类 E 中创建了一个 B 类的对象 b,并依次调用了它的方法 f 和 g,输出了结果。然后创建了一个 A 类的引用 a,并将其指向一个 B 类的对象,分别调用了它的方法 f 和 g,输出了结果。
程序的输出结果为:
```
78.0
72
78.0
64
```
第一次调用 b.f(6.0,12.0) 时,首先调用了 A 类的方法 f,返回 18.0,然后在此基础上加上 6.0 * 12.0,得到 78.0。
第二次调用 b.g(8) 时,调用了 B 类的静态方法 g,返回 64,然后在此基础上加上参数 8,得到 72。
第三次调用 a.f(6.0,12.0) 时,由于 a 是 A 类型的引用,因此调用了 A 类的方法 f,返回 18.0。
第四次调用 a.g(8) 时,由于 a 是 A 类型的引用,但是它指向的是 B 类的对象,因此调用了 B 类的静态方法 g,返回 64,而不是 A 类的静态方法 g,然后在此基础上加上参数 8,得到 72。