标签: abstract-class

我想写一个抽象类，所以无论谁继承它，他都将被迫在其中实现一个特定的功能。

例如我写道：

class Car {
    virtual double getFuelConsumption(int speed) = 0;
};

但是，如果我编写以下内容，它会在没有编译错误的情况下进行编译（即使它没有实现 getFuelConsumption()）

class meme : public Car {};

更新：为什么我收到错误：（我知道如果它确实是一辆车，那么它没有getFuelConsumption实现如果它是一个继承 class 的类会怎样Car，我希望它起作用）

double getPetrol(std::vector<Road> roads, const Car &car) {
car.getFuelConsumption(1);
}

> 'this' argument to member function 'getFuelConsumption' has type
> 'const Car', but function is not marked const

由于我们无法从抽象类创建对象，这是如何工作的？在这个类中，我声明了一个Alien数组，而Alienclass 是一个抽象类。在构造函数中创建是如何工作的？

public class AlienPack {

    private  Alien[] aliens;  //composition 

    //cons with para of array size 
    public AlienPack(int numAliens) {
        aliens = new Alien [numAliens]; //how can we create objects from AC????????????
    }

    public void addAlien(Alien newAlien, int index) {
        aliens[index] = newAlien;
    }

    public Alien[] getAliens() {
        return aliens;
    }

    public int calculateDamage() {
        int damage = 0;
        for (int i=0; i<aliens.length; i++)            // Call getDamage() from each alien to
            damage += aliens[i].getDamage();             // calculate …

我想了解如何实现依赖注入，但我有一些问题：

1. 我可以使用抽象类吗？我读了一些关于 DI 的文章，如果我理解得很好，他们说你必须使用接口而不是抽象类 - 如何避免在不同的类中使用重复的代码？

2. 如果我在一个类中有很多依赖项，我是否必须将它们全部注入到构造函数中？如果我不在所有方法中使用所有这些怎么办？

3. 我可以实例化对象吗？如果我不实例化对象，我如何调用类的构造函数？

我已经在头文件（Environment.h）中声明了以下类，并且我想使超类 FieldAccessor 抽象：

#include <jni.h>

class FieldAccessor {

    public:
        FieldAccessor(
            JNIEnv* env
        ) {
            this->jNIEnv = env;
        }

        virtual jobject getValue(jobject, jobject) = 0;

    protected:
        JNIEnv* jNIEnv;
};

template<typename Type>
class PrimitiveFieldAccessor : public FieldAccessor {
    public :
        PrimitiveFieldAccessor (
            JNIEnv* env, const char name[], const char ctorSig[],
            Type (JNIEnv::*getFieldValueFunction) (jobject, jfieldID)
        );

        jobject getValue(jobject, jobject);

    private:
        jclass type;
        jmethodID constructorId;
        Type (JNIEnv::*getFieldValueFunction) (jobject, jfieldID);
};

但我得到以下编译错误：

#include <jni.h>

class FieldAccessor {

    public:
        FieldAccessor(
            JNIEnv* env
        ) {
            this->jNIEnv = …

抽象类可以由另一个类继承,并要求人们覆盖抽象函数,抽象属性等.

一个接口也可以由另一个类实现,也需要人们实现函数,属性,索引器等.

我找到的唯一不同是Visual Studio足够聪明,可以自动生成此接口的必要成员.

那么,有什么不同？

谢谢〜

我想问一下,没有实现虚函数有问题吗？例如:

class Function { 
public: 
    virtual ~Function() {} 
    virtual double value(double x) const = 0; 
    virtual Function* clone() const = 0; 
protected: 
    virtual void print(ostream& os) const = 0; 
    friend ostream& operator<<(ostream& os, const Function& f); 
}; 

在Function的派生类中,如果没有实现clone,它会给出编译错误吗？或者,如果我尝试调用derived.clone(),它会是运行时错误吗？

不field应该在第 50 行 undefined 吗？我的理解是内部嵌套类对外部类没有可见性，正如我在第 65 行遇到的那样......似乎有点不一致，我希望更好地了解外部嵌套类的可见性以避免任何混淆在将来。

"""######################################### Imports ############################################"""
import turtle
import time
import functools
"""######################################### Key press ##########################################"""

def key_space():  # Resets Level
    field.setLevel()

def key_p():      # Skips Level
    field.nextLevel()

def key_k():      # For making levels
    print([(b.x,b.y) for b in field.getBoxes()])
    
"""######################################## Interface(s) ########################################"""

def stamp(self):  # Interface for drawing polygons.
    turtle.goto(self.canvasX+field.offset[0],self.canvasY+field.offset[1])
    turtle.shape(self.shape)
    turtle.color(self.color)
    turtle.stamp()

def frameBoiler(func): #
    @functools.wraps(func)
    def wrapper_frame_boiler(*args,**kwargs):
        turtle.clear()
        #turtle.getscreen().bgpic('Untitled.png')
        r = func(*args, **kwargs)
        turtle.update()
        time.sleep(0.05)
        return r
    return wrapper_frame_boiler

"""######################################### Game Logic …

抽象方法具有它没有体的属性.因此,当具体类扩展抽象类时,它必须实现该抽象方法.

所以我的问题是如何覆盖抽象方法？

我们今天进行了Java测试,对正确的答案进行了激烈的讨论.你能用一个简单的解释帮我找到正确的答案吗？

问题:这个Java代码有什么问题？

abstract class Fluffy {
}

interface Animal {
}

class Cat extends Fluffy implements Animal {
}

class Dog extends Fluffy implements Animal {
}

选项

1. Animal必须是一个抽象类,Fluffy必须是一个接口
2. 蓬松必须实施动物
3. 动物必须是抽象类
4. 蓬松必须是一个界面

您只能选择一个答案