相关疑难解决方法(0)

当我运行这段代码时：

'use strict';

class Base {
  constructor() {
    this._public();
  }
}

class Child extends Base {
  constructor() {
    super();
  }

  _public() {
    this.#privateMethod();
  }

  #privateMethod() {
    this.bar = 1234;
  }
}

const c = new Child();
console.log(c.bar);

我收到以下错误：

   this.#privateMethod();
         ^

TypeError: Receiver must be an instance of class Child

据我了解 JavaScript，以下代码中的接收者正是 Child 类的一个实例。它甚至显示在开发工具检查器中：

那么有人可以向我解释一下发生了什么事吗？这是一个错误还是什么？

实际上FF显示了更准确的错误信息：

Uncaught TypeError: can't access private field or method: object is not the right class

我有反思的有线经验.首先是一些示例代码:

public abstract class A {

    public A () {
        init();
    }

    public abstract void init ();
}


public class B extends A {

    private int i = 0;

    public B () {
        super();
        System.out.println(i);
    }

    public void init () {
        i = 1;
    }
}

在我的代码中的某处,我使用反射api来实例化一个对象B.

Class<AbstractSection> bc = (Class<AbstractSection>) Class.forName(B);
Constructor<?> bcon = bc.getConstructor();
B b = (B) bcon.newInstance();

我期望的是B的实例,变量i设置为值'1'.我得到的是一个B的实例,我仍然设置为'0'.通过调试器仔细观察,我发现这不完全正确:我仍然没有设置为'0'.它在init()方法中更改为"1",并在super()调用返回的那一刻设置回"0".

谁有线索？提前致谢,

曼努埃尔

PS:我知道我可以通过调用init()而不是在超类中但在继承构造函数中来解决这个问题.

对Java来说还是比较新的,我想知道哪个是更好的方法来处理这个问题.我有一个类构造函数,它接受一些参数,在这个类中也是公共getter和setter:

private String name;
private Float value;

public MySampleClass(String theName, Float theValue) {
    setName(theName);
    setValue(theValue);
}

public void setName(String n) {
    this.name = n;
}

public value setValue(Float v) {
    this.value = v;
}

我想对这个Float做一些检查.它似乎是最好的地方,它将在setter中:

public value setValue(Float v) {
    if (v < 0.0f) {
        this.value = 0.0f;
    } else if (v > 1.0f) {
        this.value = 1.0f;
    }
}

这段代码最初在构造函数中检查了边界,并在setter中再次检查,这似乎是多余的.我更改了构造函数以调用setter并将检查放在那里.那更有意义吗？或者我违反了一些我完全不知道的惯例？

我已经专业编程java十多年了.这是我试图追踪的最奇怪的错误之一.我有一个私有成员,我初始化它然后它自己变为null.

public class MyObject extends MyParent
{
    private SomeOtherClass member = null;

    public MyObject()
    {
        super();
    }

    public void callbackFromParentInit()
    {
        member = new SomeOtherClass();
        System.out.println("proof member initialized: " + member);
    }

    public SomeOtherClass getMember()
    {
        System.out.println("in getMember: " + member);
        return member;
    }
}

输出:

proof member initialized: SomeOtherClass@2a05ad6d
in getMember: null

如果您运行此代码,显然它将正常工作.在我的实际代码中,在这个确切的模式中只有这三种情况(如果计算打印输入,则为五次).

我在JVM中遇到过一些错误吗？除非我错了,否则父类不会干扰私有成员,无论我在我向你展示的代码行之间放置什么,我都不能在不使用标识符"成员"的情况下更改成员的值".

我有一个这样的课:

public class BaseClass
{
  public BaseClass(URL url, String something, String whatever)
  {
    // Do some stuff with URL, something and whatever
  }

  public List ImportantFunction()
  {
    // Some important stuff here
  }
}

我想使用这个类,但是我想在构造函数中做不同的东西.构造函数所做的事情我需要以不同的方式完成它们.但我想使用其他类方法的所有功能.

我认为最简单的方法是扩展课程.但是,当我这样做时,构造函数要求我调用父构造函数:

super(url, something, whatever);

是否可以扩展基类但具有完全不同的构造函数？我不希望BaseClass完全调用构造函数...

我有一个Android活动,其中有一些调用

final ConnectToServerAsyncTask task = new ConnectToServerAsyncTask(...);

和

final Intent intent = new Intent(this, SomeActivity.class);

为了单元测试这个类,我需要能够嘲笑的创建ConnectToServerAsyncTask和Intent(例如使用的Mockito).

有比下面描述的方法更优雅的方法吗？

public class MainActivityOfTheApp extends Activity {
    private IAsyncTaskFactory asyncTaskFactory = new AsyncTaskFactory();
    private IIntentFactory intentFactory = new IntentFactory();

    public void setAsyncTaskFactory(final IAsyncTaskFactory aFactory)
    {
        asyncTaskFactory = aFactory;
    }

    public void setIntentFactory(final IIntentFactory aFactory)
    {
        intentFactory = aFactory;
    }

    @Override
    protected void onResume() {
        ...
        final ConnectToServerAsyncTask task = asyncTaskFactory.create(...);
        ...

        final Intent intent = intentFactory.create(this, OtherActivity.class);
        ...
    }
} …

我有一个Base类方法,我想在Derived类中重写.

只要从"外部"或派生类访问具有相同名称的方法,就应调用派生类方法.当从基类内部访问该方法时,我希望使用基类方法.请考虑以下代码:

public class TestBaseMethod
{
    static class Basic {
        public Basic()
        {
            Basic.this.doSomething(); // <<---- This should call Basic version
        }

        public void doSomething()
        {
            System.out.println("Doing something old");
        }
    }

    static class Derived extends Basic {
        Object ressource = new Object();

        @Override
        public void doSomething()
        {
            System.out.println("Doing something completely new");
            // ressource.toString(); // <<---- explosion
        }
    }

    public static void main(String[] args)
    {
        Basic d = new Derived();
        System.out.println("-------------------------------");
        d.doSomething(); // <<---- This should call Derived version
    }
} …

我正在尝试构建一个包含在子类中初始化的属性的字符串.

我读到了懒惰的初始化,但不知怎的,这不像我预期的那样工作.

abstract class SubProcessFullNameBuilder(technicalDomain: TechnicalDomainEnumeration) {

    protected val moduleName = "td.${technicalDomain.value().toLowerCase()}.shared"

    private val packageName by lazy { packageName() }
    private val processName by lazy { processName() }

    val processFullName: String = "$moduleName/$packageName.$processName"

    protected abstract fun packageName(): String
    protected abstract fun processName(): String
}

class WorkerFullNameBuilder(
        private val jmsDirection: JmsDirectionEnumeration,
        technicalDomain: TechnicalDomainEnumeration,
        private val cdmCode: String) : SubProcessFullNameBuilder(technicalDomain) {

    override fun packageName() = "$moduleName.workers.${jmsDirection.value().toLowerCase()}.${cdmCode.toLowerCase()}"
    override fun processName() = "Worker"
}

既然我已经覆盖了packageName()和processName()性质,我希望上调用packageName,它将使用从子类的实现财产.

但是,当我打电话给processFullName财产时,它会抛出一个 …

我正在将一些Java代码转换为C++,我希望保持类结构类似.但是,我遇到了以下问题,我不知道如何解决; 我在Java中这样做:

public class Mother {   
    protected Father make;  
    public  Mother(){       
        make = maker();         
        make.print(); };    
    public Father maker(){ 
        return new Father();};}

public class Daughter extends Mother {
    public Daughter(){
        super();}
    @Override
    public Father maker(){
        return new Son();};}

public class Father {
    public void print(){
        System.out.println("I am the Father!\n");}}

public class Son extends Father {
    @Override
    public void print(){
        System.out.println("I am the son!\n");};}

public static void main(String[] args) {
    Daughter dot  = new Daughter();
}

会产生:我是儿子! 而:

class father{ …

我写下了这个迷你程序:

A 类:

public class A
{

    public A()
    {
        System.out.println(getS());
    }

    public String getS() { return s;}


}

B 类:

public class B extends A
{
    private String s = "hello2";

    public String getS() { return s;}

}

main:

public static void main(String[] args)
{
    B b = new B();
}

并打印:

null

这是为什么？
我知道打印的字符串是B的字符串,但为什么它之前没有初始化？

根据这个答案 - 在构造函数之前初始化的变量..

编辑 - 我编辑了代码,所以不相关的代码不会混淆