我遇到一些代码块正常运行的问题.我不完全确定这个代码做了什么(我试图让一个过时的插件与我们的服务器一起正常工作),我只知道每运行20分钟并抛出一个错误.以下是问题发生的代码部分:

public class DynamicThread extends Thread {
private LocalShops plugin = null;


public DynamicThread(ThreadGroup tgroup, String tname, LocalShops plugin) {
    super(tgroup, tname);
    this.plugin = plugin;
}

public void run() {
    Map<ItemInfo, List<Integer>> itemStockMap = Collections.synchronizedMap(new HashMap<ItemInfo, List<Integer>>());

    //Dump all the shop stock data into the map.
    for ( Shop shop : plugin.getShopManager().getAllShops() ) {
        for ( InventoryItem item : shop.getItems() ) {
            if (itemStockMap.containsKey(item.getInfo()))
                itemStockMap.get(item.getInfo()).add(item.getStock()); //Where error happens
            else
                itemStockMap.put(item.getInfo(), Arrays.asList(item.getStock()));     
        }
    }
    for(ItemInfo item : itemStockMap.keySet()) {
        List<Integer> stockList …

假设我有一个纯抽象类(即没有任何实现的抽象类):

abstract class A {
    abstract m(): void;
}

就像在C#和Java中一样,我可以扩展抽象类:

class B extends A {
    m(): void { }
}

但与 C#和Java不同,我也可以实现抽象类:

class C implements A {
    m(): void { }
}

课程B和C行为有何不同？为什么我会选择一个与另一个？

(目前,TypeScript 手册和语言规范不包括抽象类.)

在Python中使用抽象属性实现以下Scala代码的最短/最优雅的方法是什么？

abstract class Controller {

    val path: String

}

Controller强制使用子类来定义Scala编译器的"路径".子类看起来像这样:

class MyController extends Controller {

    override val path = "/home"

}

我已经搜索了SO以及网络的其他部分以获得一个很好的答案,但我找不到一个我真正理解的内容.我将以不同的方式呈现这一点,希望答案也能帮助其他人.

据我所知,这两个概念具有相同的规则,但由于方法实现能力,抽象类更灵活.此外,我知道你可以实现多个接口,只扩展一个类,但我确信有比我提到的两个更多的差异.

请查看代码的两个片段,并举例说明我可以对我的每个示例做些什么,这些示例会让我想要或不想使用另一个.

抽象类

abstract class Foo {
    abstract public function getValue();
    abstract public function setValue($value); 
}


class myObj extends Foo {
    function getValue() {

    }
    function setValue($value) {

    }
}

接口

interface Foo {
    public function getValue();
    public function setValue($value);
}

class myObj implements Foo {
    function getValue() {

    }
    function setValue($value) {

    }
}

Spring无法自动装载我的对象？是否可以在抽象类中自动装配对象.假设所有模式都在application-context.xml中提供

问题:基础和扩展类(如果有)@Service @Component应该是什么注释？

例

abstract class SuperMan {

    @Autowire
    private DatabaseService databaseService;

    abstract void Fly();

    protected void doSuperPowerAction(Thing thing) {

        //busy code

        databaseService.save(thing);

    }
}

扩展课程

public class SuperGirl extends SuperMan {

    @Override
    public void Fly() {
        //busy code
    }

    public doSomethingSuperGirlDoes() {

        //busy code

        doSuperPowerAction(thing)

    }

应用程序的context.xml

<context:component-scan base-package="com.baseLocation" />
<context:annotation-config/>

为什么abstractJava 中的类有一个constructor？

它构建的是什么,因为我们无法实例化一个abstract类？

有什么想法吗？

有没有办法强制子类覆盖超类的非抽象方法？

我需要能够创建父类的实例,但是如果一个类扩展了这个类,它必须给出它自己的一些方法的定义.

我正在开发一个项目,目前正在使用log4j实现一些日志记录,我很好奇我应该如何实现日志.我正在讨论的两个实现如下:

第一选择

对于该类和所有子类,使用来自超类的单个日志:

public abstract class AbstractFoo {
    protected static Log LOG = LogFactory.getLog(AbstractFoo.class);

    ...
}

public class Foo extends AbstractFoo {
    public void someMethod() {
        LOG.info("Using abstract log");
    }
}

第二选择

为每个类,super和subs使用单独的日志:

public abstract class AbstractFoo {
    private static Log LOG = LogFactory.getLog(AbstractFoo.class);

    ...
}

public class Foo extends AbstractFoo {
    private static Log LOG = LogFactory.getLog(Foo.class);        

    public void someMethod() {
        LOG.info("Using own log");
    }
}

什么更有意义,为什么？

假设我有一个如下定义的接口:

public interface IFunctionality
{
    void Method();       
}

我为抽象类实现了这个接口,如下所示:

public abstract class AbstractFunctionality: IFunctionality
{
    public void Method()
    {
        Console.WriteLine("Abstract stuff" + "\n");
    }       
}

我还有一个具体的类,它继承自抽象类,如下所示:

public class ConcreteFunctionality: AbstractFunctionality
{
    public void Method()
    {
        Console.WriteLine("Concrete stuff" + "\n");
    }
}

现在我有以下代码,

ConcreteFunctionality mostDerived = new ConcreteFunctionality();
AbstractFunctionality baseInst = mostDerived;
IFunctionality interfaceInst = mostDerived;
mostDerived.Method();
baseInst.Method();
interfaceInst.Method();

执行这些东西后我得到的输出如下.

Concrete stuff
Abstract stuff
Abstract stuff

但是我一直期望输出在所有三种情况下都是"混凝土东西",因为我在这里做的是分配ConcreteFunctionality类型AbstractFunctionality和变量的引用IFunctionality.

内部发生了什么.请澄清一下.

我有一些关于抽象类/方法的基本问题.我知道抽象类的基本用法是为将来的类创建模板.但他们有没有更多的用途？什么时候你应该更喜欢它们而不是接口？抽象方法何时有用？