Java 对于已经扩展了任何其他类的类，是否有任何方法可以扩展或实现SwingWorker

我想为一个类扩展SwingWorker，但我已经为此扩展了另一个类。我想知道是否有类似于线程的解决方法（我们可以扩展它或实现它），这样我就可以在SwingWorker的doInBackground方法中使用它

我有一个需要对其执行操作的对象列表。对象类型为a、B、C。 我创建了一个超类S，a，B，C是该超类的子类。 我有一个对象S，在运行时，在浏览列表时，我在列表中找到项目的类型，并将S类型转换为A、B或C，然后执行操作。 如果我让S成为SwingWorker，我只能执行一次操作，因为SwingWorker只能使用一次。 我不能让A，B，C扩展SwingWorker，因为他们已经在扩展S了。 所以我需要为A，B，C实现SwingWorker

---

我还有一个a、B、C将使用的连接对象，我将其作为一个单例，因为我不想一次又一次地初始化。

下面是一个合成示例

预期产出：

已收到部分更新列表[工作人员：开始]

进展：20%

进展：70%

进展：100%

已收到部分更新列表[工作人员：唤醒，工作人员：发送 结果]

工人完成

发射装置完成了

代码：

package com.stackoverflow；
导入java.beans.PropertyChangeEvent；
导入java.beans.PropertyChangeListener；
导入java.util.List；
导入javax.swing.SwingWorker；
公共类委派WingWorkerDemo{
公共静态void main（字符串[]args）{
新启动器（）.launch（）；
}
}
/**
*使用此命令启动辅助进程。
*/
类DelegatingSwingWorker扩展SwingWorker{
可旋转的代表；
出版商；
公共委托SwingWorker（SwingWorkable委托）{
this.delegate=委托；
publisher=newpublisher（）{
@凌驾
公共无效发布（O…块）{
DelegatingSwingWorker.this.publish（块）；
}
@凌驾
公共void setProgress（int progress）{
DelegatingSwingWorker.this.setProgress（progress）；
}
};
}
@凌驾
受保护的无效进程（列表块）{
过程（块）；
}
@凌驾
受保护的void done（）{
delegate.done（）；
}
@凌驾
受保护的I doInBackground（）引发异常{
返回delegate.doInBackground（publisher）；
}
}
接口发布者{
无效发布（O…块）；
void setProgress（int progress）；
}
/**
*让您的类实现接口。
*/
界面可旋转{
作废流程（列表块）；
我做背景（出版商）；
无效完成（）；
}
/**
*假设这是你的超级课堂：
*/
类MySuperClass{
}
/**
*使用您的超类，但实现SwingWorkerable。然后
*使用DelegatingSwingWorker启动
*/
类SleepingDemoSwingWorkerable
扩展MySuperClass
可旋转的{
@凌驾
公共作废流程（列表块）{
System.out.println（“收到的部分更新列表”+块）；
}
@凌驾
公共字符串doInBackground（Publisher）{
publisher.publish（“Worker:start”）；
试一试{
publisher.setProgress（0）；
睡眠（200）；
出版商：setProgress（20）；
睡眠（500）；
出版商：setProgress（70）；
睡眠（300）；
publisher.setProgress（100）；
publisher.publish（“工人：醒来”）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
publisher.publish（“工作者：发送结果”）；
返回“第二次通过”；
}
@凌驾
公众假期结束（）{
系统输出打印项次（“工作完成”）；
}
}
最后一个类ConsoleProgressListener实现PropertyChangeListener{
@凌驾
公共作废propertyChange（PropertyChangeEvent事件）{
开关（event.getPropertyName（））{
案例“进展”：
System.out.println（“进度：“+event.getNewValue（）+”%…”；
}
}
}
/**
*发射
*/
类启动器{
公开发售（）{
SleepingDemoSwingWorkerable=新SleepingDemoSwingWorkerable（）；
委派工作人员委派工作人员=
新的授权员工（可工作）；
delegatingSwingWorker.addPropertyChangeListener（新控制台ProgressListener（））；
delegatingSwingWorker.execute（）；
试一试{
《睡眠》（2000年）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
System.out.println（“启动器完成”）；
}
}

@Adel:我试着在问题中解释一下。请看编辑是的，你可以很容易地解决这个问题。我如何解决这个问题？你能详细说明一下吗？你可以用合成而不是继承。Thanx Rekin。工作得很有魅力：）

package com.stackoverflow;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.List;

import javax.swing.SwingWorker;

public class DelegatingSwingWorkerDemo {

    public static void main(String[] args) {
        new Launcher().launch();
    }
}

/**
 * Use this, to launch the worker.
 */
class DelegatingSwingWorker<I, O> extends SwingWorker<I, O> {

    SwingWorkerable<I, O> delegate;

    Publisher<O> publisher;

    public DelegatingSwingWorker(SwingWorkerable<I, O> delegate) {
        this.delegate = delegate;

        publisher = new Publisher<O>() {

            @Override
            public void publish(O... chunks) {
                DelegatingSwingWorker.this.publish(chunks);
            }

            @Override
            public void setProgress(int progress) {
                DelegatingSwingWorker.this.setProgress(progress);
            }
        };
    }

    @Override
    protected void process(List<O> chunks) {
        delegate.process(chunks);
    }

    @Override
    protected void done() {
        delegate.done();
    }

    @Override
    protected I doInBackground() throws Exception {
        return delegate.doInBackground(publisher);
    }

}

interface Publisher<O> {

    void publish(O... chunks);

    void setProgress(int progress);
}

/**
 * Make your class implement the interface.
 */
interface SwingWorkerable<I, O> {

    void process(List<O> chunks);

    I doInBackground(Publisher<O> publisher);

    void done();

}

/**
 * Let's say this is your super class:
 */

class MySuperClass {

}

/**
 * Use your super class, but implement the SwingWorkerable. Then
 * launch using a DelegatingSwingWorker
 */
class SleepingDemoSwingWorkerable
    extends MySuperClass
    implements SwingWorkerable<String, String> {

    @Override
    public void process(List<String> chunks) {
        System.out.println("Received partial update list " + chunks);
    }

    @Override
    public String doInBackground(Publisher<String> publisher) {
        publisher.publish("Worker: start");
        try {
            publisher.setProgress(0);
            Thread.sleep(200);
            publisher.setProgress(20);
            Thread.sleep(500);
            publisher.setProgress(70);
            Thread.sleep(300);
            publisher.setProgress(100);
            publisher.publish("Worker: woken up");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        publisher.publish("Worker: sending the result");
        return "Second passed.";
    }

    @Override
    public void done() {
        System.out.println("Worker Done");
    }

}

final class ConsoleProgressListener implements PropertyChangeListener {

    @Override
    public void propertyChange(PropertyChangeEvent event) {
        switch (event.getPropertyName()) {
        case "progress":
            System.out.println("Progress: " + event.getNewValue() + "%...");
        }
    }
}

/**
 * Launch
 */
class Launcher {

    public void launch() {
        SleepingDemoSwingWorkerable workerable = new SleepingDemoSwingWorkerable();
        DelegatingSwingWorker<String, String> delegatingSwingWorker =
                new DelegatingSwingWorker<String, String>(workerable);
        delegatingSwingWorker.addPropertyChangeListener(new ConsoleProgressListener());
        delegatingSwingWorker.execute();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Launcher done.");
    }
}