相关疑难解决方法(0)

问题是这样的:我有一个抽象类在它的构造函数中做了一些工作,还有一组实现抽象类的子类:

class AbstractClass {
     AbstractClass(){ /* useful implementation */ }
}

class ConcreteClass1 extends AbstractClass {
     ConcreteClass1(){ super(); /* useful implementation */ }
}

然后,需要定制具体类,一个解决方案是扩展具体类:

class CustomizedClass1 extends ConcreteClass1 {
    CustomizedCLass1(){ super(); /* useful implementation */ }
}

但问题是定制类只需要调用抽象类的构造函数而不是具体类的构造函数.

你是如何实现这一目标的？改变班级关系的建议是有效的.

编辑:具体的例子是ConcreteClass1和CustomizedClass1有不同的数据集(ConcreteData1和CustomizedData1),并从类的构造函数中的数据库中检索它.问题是创建CustomizedClass1的实例将检索两个数据实体.

我知道使用简单的继承可能不是最好的事情,这就是为什么我指出改变类关系的建议是有效的.

在下面的示例中,如何从类C的方法method()中访问A？

class A {
    public void method() { }
}

class B extends A{
    public void method() { }
}

class C extends B{
    public void method() { }

    void test() {
        method();          // C.method()
        super.method();    // B.method()
        C.super.method();  // B.method()
        B.super.method();  // ERROR <- What I want to know
    }
}

我得到的错误是

在范围内不能访问类型B的封闭实例

答:不,这是不可能的.Java不允许它.类似的问题.

如果我在Scala中有类星座,就像这样:

class A {
def foo() = "bar"
}

class B extends A {
override def foo() = "BAR"
}

class C extends B {
}

是否有可能在C类中显式调用A中定义的方法foo？

public class GrandParent
{
    public void walk()
    {
        ...
    }
}

public class Parent
{
    public void walk()
    {
        ...
    }
}

public class Child
{
    public void walk()
    {
        // Here in some cases I want to use walk method of GrandParent class
    }
}

现在在Child.walk()中,我只想在某些情况下使用GrandParent.walk().我怎样才能做到这一点？因为super.walk()将始终使用Parent.walk().

注意:(请注意,这是复杂场景的简化示例)

注2:请仅告知是否有标准程序.我在父类中使用了一个标志,如果孩子想要使用GrandParent的方法,则会设置该标志.但是这个序列变得非常复杂.

基本上这就是我想要实现的目标.

classname @ address(？)[original toString()],对象的名称,对象的年龄

@Override public String toString()
{
return String.format("%s , %s , %d", this.toString(), this.getName(),this.getAge());
}

问题,toString()递归调用.

我不能打电话,super.toString()因为那不是我想要的.我想' this'打电话给原件toString().

这个

this.super.toString() 

由于显而易见的原因不起作用.

我已经没精了,一旦方法被覆盖,这可以做到吗？即称之为原始实现？

(我的编辑)基本上我需要的是:覆盖toString以显示'this'对象的两个属性,我也想让'this'调用原始的toString.

这不是项目或工作.只是用Java语言玩(学习).谢谢

我有三个简单的课程:

class A {
  public A(int a){ }
}

class B extends A {
  public B(int b){ super(b); }
}

class C extends B {
  public C(int c){ super(c); }
}

因此,类实例化期间的执行顺序是C-> B-> A-> B-> C,并且所有对象都被正确实例化.那么,问题是:

我可以用某种方式为C类编写一个构造函数,如下所示:

  public C(int c){
    super.super(c);
  }

这个想法是从A类调用构造函数,而不是从直接父B调用构造函数.这可能吗？

我要打印 hi GrandFather

但它似乎打印喜父亲。我不明白如何区分findSpecial和findVirtual

我想要有人可以帮助我。谢谢

class GrandFather{
    void thinking(){
        System.out.println("hi GrandFather");

    }
}
class Father extends GrandFather{
    void thinking(){
        System.out.println("hi Father");
    }
}
class Son extends Father{
    void thinking(){
            MethodType mt=MethodType.methodType(void.class);

            //MethodHandle mh=MethodHandles.lookup().findVirtual(GrandFather.class,"thinking",mt).bindTo(this);
            MethodHandle mh;
                mh = MethodHandles.lookup().findSpecial(GrandFather.class,"thinking",mt,getClass());
                mh.invoke(this);
    }
}
public static void main(String[] args){
    (new MethodHandleTest().new Son()).thinking();
}

可能重复:
为什么是super.super.method(); Java不允许？

如果你有一个类派生自一个派生自另一个的类,那么我是否可以调用super.super方法而不是被覆盖的方法？

class A{
    public void some(){}
} 

class B extends A{
    public void some(){}
} 

class C extends B{
    public void some(){I want to call A.some();}
} 

我的一部分认为这不应该是可能的(即使它是),但无论如何我会问.

给定以下类层次结构(Grandparent并且Parent来自第三方,因此,不在我的控制之下),我将如何覆盖myMethod()以Child绕过重写的实现Parent并调用其中的Grandparent？

class Grandparent {
   public void myMethod() {
      // do stuff
   }
}

class Parent extends Grandparent {
   @Override public void myMethod() {
      super.myMethod();
      // do something else
   }
}

class Child extends Parent {
   @Override public void myMethod() {
      // ??? I want to *only* do what Grandparent did here
   }
}

假设Parent该类提供了许多其他有用的行为,并且是Child层次结构的关键元素(换句话说,我不是在寻找"创建Child子类Grandparent".

我有3节课.这似乎是基本问题.但我无法通过谷歌搜索找到答案.

public abstract class Test {

    void t1()
    {
        System.out.println("super");

    }

}
 public class concret extends Test{

    void t1()
    {
        System.out.println("child");

    }
    void t2()
    {
        System.out.println("child2");

    }

}

public class run {
    public static void main(String[] args) {
        Test t=new concret();

        t.t1();
    }

}

如何调用抽象类t1方法？由于我无法从抽象类创建对象,如何在抽象类中调用t1？谢谢.