相关疑难解决方法(0)

所以我刚看到这个代码在工作,作者告诉我这是内联优化.

Class Test{
...
void init(){
   //sets variables, call functions, etc
} 
...
}

然后他像这样称呼它

Test t=new Test();
t.init();

而不是使用带有init()代码的默认构造函数.他告诉我这是内联优化.它是否正确？怎么更快？我在哪里读到这个？

我想到这个问题的具体用法如下,但它更加普遍.

我有一个自定义JFrame类,也可以作为ActionListener其组件.所以我的构造函数看起来像下面这样:

private JButton myButton;

public MyCustomFrame() {
    super();
    myButton.addActionListener(this);
    // ... more stuff
}

我的问题是,这在幕后实际上是如何运作的？如果构造函数是"创建"引用的对象this,那么this在构造函数返回之前我该如何使用？代码编译和工作完全正常(据我所知),所以对象必须已经"存在"在某种意义上,但我担心这可能会导致无法预料的问题.传递一个"部分构造"的引用是否存在任何危险addActionListener()(或者只是对它执行任何逻辑)？或者是否有一些让我安全的幕后魔术？

例如,那些没有默认值但必须由构造函数提供的东西呢？如果我已private final String SOME_VALUE;声明,我理解这应该默认为null,但是在构造函数中为常量提供值之前,该对象不应该完全形成.那么参考,尽管是最终的,可能会有变化的价值？

我想generateId()在抽象超类的构造函数中调用抽象方法,其中此抽象方法依赖于相应子类的某些字段.为清楚起见,请考虑以下代码:

抽象类: SuperClass

public abstract class SuperClass {
   protected String id;

   public SuperClass() {
        generateId();
   }

   protected abstract void generateId();
}

子类: Sub1

public class Sub1 extends SuperClass {
   private SomeType fieldSub1;

   public Sub1(SomeType fieldSub1) {
      this.fieldSub1 = fieldSub1;
      super();
   }

   protected void generateId() {
      // Some operations that use fieldSub1
   }
}

子类: Sub2

public class Sub2 extends SuperClass {
   private SomeOtherType fieldSub2;

   public Sub2(SomeOtherType fieldSub2) {
      this.fieldSub2 = fieldSub2;
      super();
   }

   protected void generateId() {
      // …

我有以下课程:

public class Project {

    private int id;
    private String name;  

    public Project(int id, String name) {
        if(name == null ){
            throw new NullPointerException("Name can't be null");
        }

        if(id == 0 ){
            throw new IllegalArgumentException("id can't be zero");
        }

            this.name = name;
            this.id = id;

    }

    private Project(){}

    public int getId() {
        return id;
    }

    public void setId(int id) { 
        if(id == 0 ){
            throw new IllegalArgumentException("id can't be zero");
        }
        this.id = id;
    }

    public String getName()
        return name; …

细分尽可能简单:

是否存在以下场景的设计模式(名称)？

可能有许多通用的生成器可用于实现IGenerator接口,但也有一些依赖于国家的接口(扩展GeneratorBase).后者可以封装依赖于国家/地区的生成器以及与国家无关的生成器,具体取决于要保存实现的"SomeType"的类型.Mehtod init()旨在覆盖包含可用生成器的注册/映射过程.

抽象类GeneratorBase提供了为特定类型的"SomyType"关联和查找生成器的功能.同时,可以存在IGenerator实现,它们既不知道"SomeType"也不知道国家.

旁注:所有可用(不可用!)生成器都保存在一个单独的注册表类中,该类负责查找正确的IGenerator实现.

客户端/用户获得的唯一接口是IGenerator接口.

public interface IGenerator
{
    public String generate(SomeType s);
}

public abstract class GeneratorBase implements IGenerator
{
    private Map generators;
    protected String country;

    public GeneratorBase(String country){
        generators = new HashMap();
        this.country = country;
        init();
    }

    public abstract void init();

    public String generate(SomeType s)
    {
        Generator gen = (Generator) generators.get(new Integer(s.getObjectType()));
        ...
        return gen.generate(s);
    }
}

编辑:我遇到了适配器模式,桥接模式和装饰模式.它们都不适合这种设置.最接近的可能是适配器或桥接模式,但我既不调整东西,也不桥接(抽象类实现与实现者完全相同的接口)

我正在使用Java 7并获得3个类:

TestSuper.java

public abstract class TestSuper {
    public TestSuper() {
            testMethod();
    }

    protected abstract void testMethod();
}

TestNull.java

public class TestNull extends TestSuper {
    private String test = "Test";

    public TestNull() {
            super();
            System.out.println(test);
    }

    @Override
    protected void testMethod() {
            System.out.println(test);
    }

}

TestMain.java

public class TestMain {
    public static void main(String[] args) {
            new TestNull();
    }
}

输出:

null
Test

为什么会发生这种情况并且有一个很好的解决方法呢？

我想要在 JavaFX- 上方显示文本TextField。设置prompText几乎是我想要的，但对于我的用例来说有一些缺点。下面的代码似乎可以工作，但是将 a 添加Label到 的子级感觉是错误的TextField。以下代码是否违反任何 JavaFX 原则或者使用安全吗？

public class MyTextField extends TextField {    
    public MyTextField() {
        Label label = new Label("test");
        this.getChildren().add(label);
    }  
}

以下代码将输出打印为40而不是30.我无法找出解决方案.请帮助代码.

class Base {

  int value = 0;

    Base() {
      addValue();
    }

    void addValue() {
      value += 10;
    }

    int getValue() {
      return value;
    }
}

class Derived extends Base {

  Derived() {
    addValue();
  }

  void addValue() {
    value +=  20;
  }
}

public class Test{

  public static void main(String[] args) {
    Base b = new Derived();
    System.out.println(b.getValue());
  }
}

Derived构造函数中  的隐式超级引用调用Base构造函数,该构造函数又调用addValue()类中的方法将Base值变量作为10,然后addValue()在Derived类中将20添加到值10.因此最终输出为30.

但代码打印40.

最近，我将我的项目从Java 8升级到Java 10，并发出了很多警告，指出现在不推荐使用Observer和Observable。替换它们的建议是Flow API-问题是我尚未找到有关如何为Flow API编写代码的不错的教程。我发现的所有内容都说不能直接实现发布者/订阅者，而且我发现的许多内容都表明Flow API很大程度上基于多线程。

注意：我已经在StackOverflow以及Quora和其他一些站点上找到了这个答案，有人引用不能对Observable对象进行序列化，这在我为我的每个bean和许多bean实现Serializable时都完全不正确。我的其他类也是如此，甚至已经序列化以归档我的一些对象，并将它们从文件中读回到对象形式。

但是，多线程是一个问题-我不希望在响应模型对象的更改时使用流或多线程。问题1是-是否绝对需要使用Flow API，还是存在另一组不需要多线程和流​​的类/接口？

在查看Flow.publisher的javadocs时，我将用Observable替换-因为这是一个接口，这意味着我想我必须放入（类似于ListModel和TableModel类的实现）订阅者集合（类似于Observers？），并放置自定义代码以将其添加到我的发布商中或从中删除？问题2-我有权利吗？

问题3.）Flow.Publisher和Flow.Subscriber中的通用类型参数是什么？它显示了一个类型，但是我不知道在哪里使用该类型-我将在这里为我的一个模型类放置代码：

package net.draconia.frenchstudy.model;

import java.io.Serializable;

import java.util.concurrent.Flow.Publisher;
import java.util.concurrent.Flow.Subscriber;

public class Category implements Publisher<Category>, Serializable
{
    private static final long serialVersionUID = 5281400324476454101L;

    public static final Category EMPTY_CATEGORY = new Category(); 

    private Integer miId;
    private String msCategory;

    public Category()
    { }

    public Category(final int iId)
    {
        setId(iId);
    }

    public Category(final String sCategory)
    {
        setCategory(sCategory);
    }

    public Category(final int iId, final String sCategory)
    {
        setId(iId);
        setCategory(sCategory);
    }

    public String getCategory()
    { …

我有以下课程：

public abstract class MyAbstractClass {
     protected int x;
     protected int number;
     public MyAbstractClass(int x) {
         this.x = x;
         this.number = this.generateNumber();
     }
     public abstract int generateNumber(); // This class is called in the super constructor and elsewhere
}
public class MySubClass extends MyAbstractClass {
     private int y;
     public MySubClass(int x, int y) {
          super(x);
          this.y = y;
     }
     @Override
     public int generateNumber() {
         return this.x + this.y; // this.y has not been initialized!
     }
}

我的问题是在运行超级构造函数之前必须初始化MySubClass的y …