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

【问题标题】：c# making object in different ways (abstraction used)c#以不同的方式制作对象（使用抽象）
【发布时间】：2017-10-18 05:10:16
【问题描述】：

我做了两个对象，我也不知道它们之间有什么区别。有人算得上是好习惯吗？例子表示赞赏！另外，标记两者的优点。是因为我编写了一个非常简单的代码，所以我没有看到差异吗？

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;
    }
}

输出：

【问题讨论】：

对象在结构上是相同的。参考文献不一样。这取决于您使用哪个抽象级别（基类/派生类）。鉴于您的简短示例，除非您将其放在更大的范围内，否则 MyWay 毫无用处。
你应该看看抽象在现代编程语言中的重要性，你会得到答案。这不是关于差异，而是关于要求。
qxg 我知道代码没有多大意义，但是如果您将其视为初学者的 ruff 练习，它看起来还不错：D 另一件事我明白了，谢谢
Ipsit Gaur 所说的“现代编程语言”是什么意思？ c#还不够现代吗？
您的代码看起来像是一个非常糟糕的示例，用于解释 C# 中的继承。您应该查找有关此主题的一些教程。

标签： c# abstract-class abstraction

【解决方案1】：

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

另一件事是类应该封装状态和行为，并且在您的示例中您没有状态（您传递给构造函数的数字不会存储在任何地方）。这意味着只有使用计算的静态方法就可以了

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 存储在私有（无法从外部访问）字段中。而Calculate方法使用它们来产生结果。

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

【讨论】：

我没有得到我创建的对象的区别，我知道这是一个愚蠢的例子（我的代码），我试图探索抽象，所以我首先想到了它没有什么我想制造我的错误我没有在问题中指定
试试 Console.WriteLine(addison == addison2);
所以即使这是一个复杂的代码，输出也总是相同的或者它可以改变（在任何情况下）
如果您使用相同的输入参数来创建对象，输出将是相同的。这就像购买 2 辆汽车.. car1 = 红色宝马和 car2 = 红色宝马......汽车看起来相同，但它们是两个不同的东西。如果你崩溃了，你还有第二个
在抽象方法中使用 object 可能会导致一些 if(a is typeof(...) do this else to other thing 有大量的强制转换紧密耦合您的代码 - 并且会在 Addison addison = new Addison("hello", null); 上中断 -> 面向 Hassan Raza，而不是 Piotr

【解决方案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 是狗。

【讨论】：