我正在尝试创建一个基本抽象类和子类来抽象对后端数据库的访问。一个子类是 SQLAlchemy，另一个子类是 MongoDB 或其他 nosql。下面是一个非常简单的例子。在基类中，我需要为每种类型的对象提供一个 deleteObject，因为 noSQL 实现将需要这个，但是，任何使用 SQLAlchemy 的内容都只需要一个删除方法。我想通过为抽象基础中的每种类型的对象提供以下方法来节省自己的打字时间。如果这有效，我就不必为 SQLAlchemy 子类中的每个对象类型定义 deleteObject，因为基本抽象只会将其传递给私有 __delete 函数。不幸的是，当我调用deleteUser时，它确实会转到抽象基函数，但对self.__delete(user)的调用会转到抽象函数，即使子类定义了此函数。当子类定义该函数的实现时，有没有办法确保抽象实现中的函数调用转到子类？

@abc.abstractmethod
def deleteUser(self, user):
    """Delete an user from the backend database"""
    print('abstractmethod')
    self.__delete(user)

@abc.abstractmethod
def __delete(self, object):
    print('dont go here')

我在类库（项目“A”）上有这个对象，我想在多个项目（“B”和“C”）中使用它：

public class Notification : INotification
{
    public string Id { get; set; }

    public int Type { get; set; }

    public IList<Message> Messages { get; set; }
}

public class Message: IMessage
{
    public string Key { get; set; }

    public string Value { get; set; }

    public string Culture { get; set; }
}

public interface INotification
{
    string Id { get; set; }

    int Type { get; set; }

    IList<Message> Messages { get; set; }
}

现在，如果我想在我的项目“B”上创建这个对象，我需要执行以下操作： …

在下面的示例中，我有我的父类和两个子类。任何一个孩子的对象都存储在父母的向量中。循环遍历向量我只能看到来自父类的方法调用。

如何正确获得方法定义和 vtables 以及如何避免切片效应。我一直在做 Python 太长时间了，这样的事情会起作用。

#include <iostream>
#include <vector>


using namespace std;

class A{
    public:

        virtual string print(){return string("A");};
};

class B: public A{
    virtual string print() final {return string("B");};
};

class C: public A{
    virtual string print() final {return string("C");};
};

int main()
{

   vector<A> v;
   v.push_back(B());
   v.push_back(C());

   for(auto x : v){
       cout << x.print() << endl;
   }

}

=>

$g++ -std=c++11 -o main *.cpp
$main
A
A

我有一个抽象类，我想让派生类不仅定义值类型，还要让它们定义它们有多少个值类型。然后我想要求他们为每种类型设置 getter/setter：

public abstract class A<T1, T2, ..., TN>
{
    // Getters
    public abstract T1 GetValue();
    public abstract T2 GetValue();
    ...
    public abstract TN GetValue();
    // Setters
    public abstract void SetValue(T1 newVal);
    public abstract void SetValue(T2 newVal);
    ...
    public abstract void SetValue(TN newVal);
}

然后从 A 派生的类可以拥有任意数量的值，只要它们提供对它们的访问。这在c#中可能吗？或者类似的东西？

编辑：这个问题措辞不好，提供的答案从字面上看是正确的，但没有教我如何达到我所需要的。如果您正在为同样的问题而苦苦挣扎，这最终帮助了我：当这些方法的返回类型取决于子类时，如何强制执行子类行为/方法？

我正在尝试从我编写的样板抽象类中实现一个基本的矩阵类。这个抽象类会有几个实现，每个实现都使用不同的数学库，然后我将测试速度。

每个实现都将其数据保存在该库的本机矩阵数据结构中。我认为这是泛型的一个用例。在这一点上，我想我已经阅读了太多的教程并观看了太多的视频，因为我似乎无法找出所有正确的位置来放置TNotation 以使其正常工作。

所以我的问题是双重的：

1. 我是否误用或错过了泛型的要点？
2. 如果没有，它们使用的正确语法是什么？

我已经阅读了文档以及大约三个不同的教程，但仍然无法理解。

这是我尝试过的：

public abstract class BaseMatrix<T> {

    protected int[] shape;
    protected int nrows;
    protected int ncols;
    protected T data; // <--- Here is the generic data --->

    public BaseMatrix(int rows, int cols){
        this.nrows = rows;
        this.ncols = cols;
        this.shape = new int[]{nrows, ncols};
    }    

    public abstract BaseMatrix mmul(BaseMatrix other);

这是我的实现：

public class ND4JDenseMatrix extends BaseMatrix{
    

    // private INDArray data;

    public ND4JDenseMatrix(int rows, int cols) {
        super(rows, cols); …

我有 2 个类（B和C），我正在尝试创建一个父类型，以便我可以操作type 的A变量。下面的例子工作正常：aA

class A {}

class B extends A {}

class C extends A {}

var b = true;

final A a = b ? C() : B();

但由于某种原因，当A有泛型类型时A<T>，它不起作用

class A<T> {}

class B extends A<int> {}

class C extends A<String> {}

var b = true;

final A a = b ? C() : B(); // <- Error

我收到 linting 错误：

A value of type 'Object' …

我有一个密封类，几个抽象类继承自该类。由于密封类中有很多字段需要在抽象类中初始化，因此我尝试将其移动到辅助构造函数，但是辅助构造函数不允许我们声明override val字段以使代码更简洁。我能想到的唯一其他方法是创建字段lateinit var，但这样我就失去了不变性。

sealed class Animal {
  abstract val object1 : SomeObject
  abstract val object2 : SomeObject2
  abstract val object3 : SomeObject3
  abstract val object4 : SomeObject4
}

abstract class GrassEaterAnimal : Animal {

   //trying to do this
   constructor(override val object1 : SomeObject, override val object2 : SomeObject2, override val object3 : SomeObject3, override val object4 : SomeObject4, func : (field1, field2) -> Foo)
}

有没有办法使此代码更清晰或有任何其他建议可以在这种情况下提供帮助？

例如：

// Example program
#include <iostream>
#include <string>

class abstract_class
{
public:
    abstract_class() = default;
    ~abstract_class() = default;
    virtual void read() = 0;
};

int main()
{
    std::unique_ptr<abstract_class> x;
    std::cout << "Hello, " << "!\n";
}

我认为抽象类有这些限制
抽象类不能用于：
变量或成员数据
参数类型<------------
函数返回类型
显式转换类型

在上面的代码中，我们使用抽象类作为模板参数，那么为什么这不是一个错误呢？

概括

我有一个继承自抽象类的基类，但它本身必须声明为partial，因为我正在使用源生成器来生成部分实现。

如何防止partial class在 C# 中实例化它？有没有办法在编译时做到这一点？

编辑：我将 C# 8.0 (.NET Standard 2.1) 与 Xamarin.Forms 项目一起使用。

我试过了partial abstract，但是这是不允许的。

长话短说

在我的一个项目中，我一直使用一个abstract class作为ViewModel 的基类来实现MVVM 模式。以前，所述基类实现了该INotifyPropertyChanged接口，但现在我切换到CommunityToolkit.Mvvm，以便能够使用MVVM 源生成器 （我已经在其他项目中广泛使用了它，我什至写了一个关于它们的博客系列） 。

显然，在 C# 中，一个类只能是其中之一partial，abstract但不能同时是两者，这是有道理的。由于源生成器仅与类一起使用partial，因此我的基类不能abstract再这样了。但是，这会产生一个问题，即我无法阻止基类在编译时实例化。虽然它仍然是一个abstract class，但无法实例化，但现在可以这样做。

抽象基类

这就是基类过去的样子（简化/修改的示例）：

public abstract class ViewModelBase : INotifyPropertyChanged
{
    private bool _myBool;
    public …

在javaFX中Application是一个抽象类。在这个抽象类中，有一些抽象方法在扩展抽象应用程序类的主类中被重写，并且在抽象类应用程序中也有静态 launch() 方法。launch() 方法从主类中的 main 方法调用。现在 launch() 方法如何调用这些抽象方法，并且对于这些调用，执行主类中的重写方法？请帮助我了解这个程序实际上是有效的。我知道非静态方法不能从静态方法调用，并且不可能创建抽象类的实例。抽象方法不能是静态方法。

我不想创建主类的对象。因为launch()方法不知道主类的名称是什么。

给我写一段java代码，这个过程很好地说明了这一点。像这样

public class main extends Application{
    public static void main(String[] args)
        launch();                       // launch() was a static method in Application class
    }
    @override
    public void init(){                 // init() was an abstract method in Application class
        System.out.println("hello");
    }
}

public abstract class Application {
    public static void launch(){
        init();
    }
    public abstract void init();
}

我想得到输出：你好