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

输出：

10

Answer 1

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

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

才能正常

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之间有什么区别： - 这是同一个类的两个不同的实例 - 他们在记忆中占据两个不同的位置（他们的参考不相等）

Answer 2

我尝试解释这个给出另一个例子：

If Not fDialog.InitialFileName = filePath Then
    fDialog.InitialFileName = filePath
End If

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

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

所以让我们假设你在Dog中有一个名为Bark

的方法

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

这将有效

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

这不会

y.Bark();

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

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

2 个答案: