我正在经历一个看似奇怪的问题,虽然我知道这个设计背后可能有一些原因,我想知道为什么会这样。
考虑两个类,Foo和Bar。Bar扩展Foo并重写Foo实现的方法。Foo非常简单:
public class Foo {
public Foo() {
System.out.println("Foo constructor");
someMethod();
}
public void someMethod() {
System.out.println("Foo.someMethod");
public class Superclass{
void method1(){
method0();
}
void method0(){
System.out.println("superclass");
}
}
public class Subclass extends Superclass{
void method0(){
System.out.println("subclass");
}
}
public class Runclass{
我在这里问这个问题是因为我真的不知道我该怎么搜索这个。我需要确认一下我今天可能想出来的一些事情。几天前,我曾想过,如果一个对象继承了其父方法,这意味着它的代码中基本上“有”该方法。但后来我问如果我们这样做
class B extends A {
public B() {
}
public int getValue() {
return 2 * super.getValue();
}
}
class C extends B {
public C() {
}
public int getValue(int b) {
return 5 *
我有一个抽象类,有一个抽象成员。我想要将这个成员继承到不同的类,并使成员的重写成为静态。
就像这样:
[<AbstractClass>]
type Parent() = class
abstract member Att : int
end;;
type Son() = class
inherit Parent()
static override Att = 10
end;;
type Daughter() = class
inherit Parent()
static override Att = 20
end;;
另一个选择
[<AbstractCla
我试图在bytebuddy中创建一个抽象类的子类,并希望用我自己的函数覆盖构造函数。我不能让它与defineConstructor一起工作。
超级阶级:
public abstract class AbstractDMTable {
protected HashMap<String, DMEntry<?>> parameterMap;
public DMEntry<?> getParameter(String paramName) {
if (parameterMap.containsKey(paramName))
return p
class A
{
private int m;
public void display()
{
System.out.println(m);
}
}
class B extends A
{
int n;
B(int b)
{
this.n = b;
}
public void display()
{
super.display();
System.out.println(n);
}
}
class trial
{
public
我不知道java在php中没有像self这样的关键字来获得与这个php代码相同的结果。
<?php
class Person {
private $name;
public function __construct($name) {
$this->name = $name;
}
public function getName() {
return $this->name;
}
public function getTitle() {
return $this-&
我在两个不同的包里有亲子班。我正在重写一种受保护类型的方法。我想访问子类中的超类保护方法。
考虑以下代码:
package package1;
public class Super
{
protected void demoMethod()
{
System.out.println("In super method");
}
}
package package2;
import package1.Super;
public class Sub extends Super
{
@Override
protected
我被这个代码示例搞糊涂了:
我搞不懂为什么要先调用draw的子方法。我很困惑,因为当RoundGlyph在main中实例化时,超级构造函数不是在实例化父对象之前实例化父对象吗?
class Glyph {
void draw() {
System.out.println("test"); // method will be called once you create a Glyph object, because when we create a round glyph before creating a glyph the super constru
我有以下尝试使用this和super的代码片段。
class SuperClass
{
public final int x=10;
public final String s="super";
public String notOverridden()
{
return "Inside super";
}
public String overrriden()
{
return "Inside super";
}
}
final class Su
public class PrivateOverride {
private void f() {
System.out.println("PrivateOverride f()");
}
public static void main(String[] args) {
PrivateOverride po = new DerivedWithOutD();
po.d();// PrivateOverride f()
PrivateOverride poD = new DerivedWith
正如我从一本教科书中了解到的,如果我将类型超类的变量名(即newObject )分配给类型子类的对象,而该子类有一些重写的方法,即toString()方法,那么当我调用newObject.toString()时,被重写的方法被调用,而不是原始的方法。
但在另一种情况下,我没有再次发生这种情况。例如,我的超类名为Ship,它的子类CruiseShip。
class Ship{}
class CruiseShip extends Ship implements Serializable {
int getSize() {
return 42;// value is not
给定三个父/子类,如下所示:
class A {
public virtual void doSomething() {
//do things
}
}
class B : A {
public override /*virtual?*/ void doSomething() {
//do things
base.doSomething();
}
}
class C : B {
public override void doSomething() {
//do things
所以我尝试创建一个名为Dean的类,这个类必须能够调用超类,比如,打印出一个文本。有人告诉我使用Professor.say(self,stuff)来调用say的超类,但我真的不明白。
我的代码如下:
Class Dean(Professor):
Professor.say(self, stuff)
self.say(stuff + "- We need money now, send")
如果之前还不清楚,那么重点就是让Dean在超类的任何实例中都这样说,这意味着即使在子类中有其他的say实例(比如我的另一个Python问题中的讲师或教授),它仍然会说
我有一个扩展超类的子类。我希望超类永远不会调用子类上的方法。这个是可能的吗?
在超类上显式调用的方法会再次调用子类,这似乎是不直观的。
简单的例子:
public class Demo {
public static void main(String[] args) {
A a = new A();
B b = new B();
System.out.println("A.a() = " + a.a()); // -1
System.out.println("A.b() = " + a.b(
在objective-c中,如果一个特定的方法被它的(调用)子方法(Ren)覆盖了,那么如何在超类中确定它?
例如,在下面的示例中,子类Z不覆盖方法b,因此基类X将执行一些额外的默认处理。但是,ZY在子类Y中实现了b,因此不需要缺省处理。
// base class X
-(void)a
{
// do something
}
-(void)b
{
if("no_child_has_implemented_b") {
// add some default behavior
}
}
// child class Y : X
-(void)a
如果override方法没有显式调用它的超级方法,我想抛出一个自定义异常。如果任何类扩展了类A并重写了say()方法,应该强制调用super.say()来执行用基类方法编写的代码,如果失败,我想抛出自定义异常,如super not exception
class A {
public void say() {
System.out.println("From super");
}
}
class Demo extends A {
@Override
public void say() {
我有一个代码,我不能得到为什么输出将是“子午线轮胎与长”.Can谁能帮我理解这个代码?
class Tyre {
public void front() throws RuntimeException {
System.out.println("Tire");
}
public void front(long a) {
System.out.println("Radial Tire with long");
}
}
class TestSolution extends Tyre {
pu
我对重写构造函数感到非常困惑。构造函数不能被覆盖是我在google上搜索它时得到的结果,我的问题是
public class constructorOverridden {
public static void main(String args[]) {
Sub sub = new Sub();
sub.test();
}
}
class Super {
Super() {
System.out.println("In Super constructor");
test();
}
如果我在package1中有基类,在package2中有受保护方法子类,则覆盖基类的包中的受保护方法测试类具有将在基类的引用中创建子对象的代码。如果尝试调用受保护方法,会发生什么?它将调用子类方法。你能告诉我背后的原因吗?为什么会这样呢?
package base;
public class Base {
protected void method()
{
System.out.println("Base");
}
}
package base;
import child.Derived;
public class Test {
在类中,与超类中的字段同名的字段会隐藏超类的字段。
public class Test {
public static void main(String[] args) {
Father father = new Son();
System.out.println(father.i); //why 1?
System.out.println(father.getI()); //2
System.out.println(father.j); //why 10?
System.out.println(f