c# 以不同的方式制作对象（使用抽象）

Question

我做了两个对象，我也不知道它们有什么区别。有人算作好习惯吗？示例表示赞赏！另外，标记两者的优点。是不是我编写了一个非常简单的代码，所以我看不出有什么不同？

class Program    
{

    static void Main()
    {
        MYway addison = new Addison(4, 6);    //OBJ 1
        Addison addison2 = new Addison(4, 6); // OBJ 2
        Console.ReadKey();
    }

}

abstract class MYway
{
    abstract protected object Calculate(object value1, object value2);
}

class Addison: MYway
{
    public Addison(double v1,double v2)
    {
        Console.WriteLine(Calculate(v1,v2));
    }

    protected override object Calculate(object value1, object value2)
    {
        return (double)value1 + (double)value2;
    }
}

Output:

10

Answer 1

从class定义开始。根据我的经验，最好从具体实现开始，然后（仅在需要时）提取一些抽象。我不确定这些是谁的话但是："Abstraction should be discovered"。所以你不应该从 abstract 关键字开始你的设计（在你的例子中我会删除 abstract class）

另一件事是 classes 应该封装状态和行为，在你的例子中你没有状态（你传递给构造函数的数字不会存储在任何地方）。这意味着您只能使用计算

的静态方法

public static class Addison
{
    public static object Calculate(object value1, object value2)
    {
        return (double)value1 + (double)value2;
    }
}

你可以使用它：

class Program    
{
    static void Main()
    {
        object addison = Addison.Calculate(4, 6);    //OBJ 1
        object addison2 = Addison.Calculate(4, 6); // OBJ 2
        Console.ReadKey();
    }
}

如果您想实际封装状态和行为，那么

public class Addison
{
    private object _value1;
    private object _value2;
    public Addision(object value1, object value2)
    {
         _value1 = value1;
         _value2 = value2;
    }
    public object Calculate()
    {
        return (double)_value1 + (double)_value2;
    }
}

class Program    
{
    static void Main()
    {
        Addison addison = new Addison(4, 6);    //OBJ 1
        Addison addison2 = new Addison(4, 6); // OBJ 2
        Console.WriteLine(addison.Calculate());
        Console.WriteLine(addison2.Calculate());
        Console.ReadKey();
    }
}

在上面的示例中，您将值 4 和 6 存储在私有（无法从外部访问）字段中。和计算方法使用它们来产生结果。

现在如果你问 addison 和 addison2 之间有什么区别： - 这是相同 class 的两个不同实例 - 它们在内存中占据两个不同的位置（它们的引用不相等）

Answer 2

我试着用另一个例子来解释这个：

public abstract class Animal
{
    public abstract void MakeNoise();
}

public class Dog : Animal
{
    public override void MakeNoise() { Console.WriteLine("Woof"); }
}

public class Cat : Animal
{
    public override void MakeNoise() { Console.WriteLine("Meow"); }
}


static void Main()
{
    Animal a = new Dog();
    Animal b = new Cat();

    a.MakeNoise();
    b.MakeNoise();
}

Dog和Cat都派生自Animal，因此需要实现抽象方法"MakeNoise"。创建 Dog 或 Cat 时，您知道它们是动物，因此您可以将它们放入 Animal 类型的变量中。

由于 MakeNoise 方法是在 Animal 类型中定义的，因此您可以访问它，即使此方法的实现必须在子类中也是如此。

所以让我们假设您在 Dog 中有另一个方法叫做 Bark

    Animal x = new Dog();
    Dog y = new Dog();

这会起作用

y.Bark();

这不会

x.Bark();

x 和 y 都包含狗，但是您只能确定 y 是狗。

c# 以不同的方式制作对象（使用抽象）

c# making object in different ways (abstraction used)

c#

abstract-class

abstraction