7

我的课程讲师有效地混淆了我的焦油的新手问题。Is-A 关系是说狗是动物。然后你会让 Animal 成为 Base 类， Dog 作为派生类。

但是对于我们的类项目，我必须创建一个基于接口的类。使用一个单独的类，它只有一种方法来提供随机数。看起来它们并不真正相关，但我必须从主类调用 randomNumber 方法。

他在说明中的问题（很糟糕）说要弄清楚这是一种 IS-A 还是 HAS-A 关系。基于事实，我会说这是一种 HAS-A 关系，但我不知道如何引用该类，而是将一个变量分配给该类以便我可以使用它。

还有另一种方法来引用我不知道的类吗？

Devices randomMeasure = new Devices();  //Random measurement Class
this.mostRecentMeasure = randomMeasure.GetMeasurement();
4

6 回答 6

7

如果您的类继承自另一个类，则它是“IS-A”关系。

如果该类被传递给构造函数中的另一个类，则这是一种“HAS-A”关系。

例如

public class foo : bar
{
    // IS-A
}



public interface IBar
{
}

public class Bar : IBar
{
}

public class Foo : IBar
{
    private Bar _bar;

    public foo(Bar bar)
    {
        _bar = bar;

    }

    // HAS-A
}

但是，您的要求并不明显。在第二种情况下，Foo IS-A IBar和HAS-A Bar。

于 2013-10-29T19:11:43.883 回答
6

接口是一种可以做的关系。
您可以将类的实例分配给任何类型的变量

  1. 班级本身或
  2. 该类的基类之一或
  3. 类或其基类之一实现的接口。

在您的示例中（案例 3），这意味着：

IDevice randomMeasure = new Devices();
randomMeasure.GetMeasurement();

这个概念被称为多态性。

于 2013-10-29T19:14:04.987 回答
3

这是一个 IS-A 关系，

要引用它，您应该创建具体类的实例并将其分配给接口类型的变量：

interface IMeasureable 
{
    public int GetMeasurement();
}
class Device : IMeasureable 
{
    public int GetMeasurement() 
    {
        return .... 
    }
}
class App 
{
    public void Main() 
    {
         IMeasureable thing = new Device();
         int x = thing.GetMeasurement();
    }
}
于 2013-10-29T19:13:58.197 回答
2

回答你的问题（虽然我不确定你为什么问）你可以

  1. 实例化类

  2. 让它成为静态的

  3. 将类对象保存在应用程序变量/缓存/视图状态等中

  4. 使用扩展方法，它会给你随机数（在这种情况下你不必使用另一个类）

于 2013-10-29T19:29:30.913 回答
2

如果我们接受接口是 CAN-DO 关系，那么教授一定是在询问两个具体类之间的关系。我将调用这些类ClassBasedOnInterface和SeperateClass. ClassBasedOnInterface又名“主要课程”在哪里。我们也知道要求是：

我必须从主类调用 randomNumber 方法。

interface IMyInterface
{
    void Call();
}

//Requirement: I have to call the randomNumber Method from the main class.
public class ClassBasedOnInterface : IMyInterface
{
    SeperateClass hasASeperateClass = new SeperateClass();

    public void Call()
    {
        //Could be local variable.  
        //Or, the professor could be implying that ClassBasedOnInterface has a SeperateClass 
        //member that is used to make the call to GetRandomNumber().  
        //Or, GetRandomNumber() could be static.
        //var seperateClass = new SeperateClass();//I do not consider a private local variable a HAS-A relationship
        //seperateClass.GetRandomNumber();

        hasASeperateClass.GetRandomNumber();
    }
}

public class SeperateClass
{
    public void GetRandomNumber()
    {

    }
}

还有许多未解答的问题。但是，没有理由相信它ClassBasedOnInterface也源自SeperateClass. 有证据表明SeperateClass是成员，ClassBasedOnInterface因为要求是ClassBasedOnInterface必须调用SeperateClass.GetRandomNumber()。换句话说，没有理由相信存在 IS-A 关系。

出于这个原因，我相信答案是：

ClassBasedOnInterface具有HAS-A关系SeperateClass

于 2013-10-29T19:43:25.030 回答
1

接口描述了一个类的一些东西，但不一定定义它。正如其他人所说，这更像是一种可以做的关系。你能对这个班级做点什么吗？等等。

Has-A 关系将是一个利用其他类来表示 0..* 关系中的东西的类。 

// This interface doesn't really define what a class is, only
// that it can, in fact, have Cheeseburgers.
public interface ICanHasCheeseburgers
{
     List<Cheeseburger> Cheeseburgers { get; }
}

// This abstract class, defines what a derived class 'is'.
// If you are familiar with biology, imagine: kingdom, phylum, class, order, 
// genius, species.  It's different levels of abstraction for a 'thing'.
public abstract class Animal
{

}

// The cat class derives from the Animal class just as a Dog class might.
// This is a Is-A relationship; the Cat is an Animal.  It also implements 
// the ICanHasCheeseburgers interface which represents a Can-Do relationship.
public class Cat : Animal, ICanHasCheeseburgers
{
     // this property represents a Has-A relationship between our Cat
     // class and a Cheeseburger class.  The cat can have any number of
     // Cheeseburger objects.
     public List<Cheeseburger> Cheeseburgers { get; private set; }

     public Cat(RandomNumberGenerator generator) 
     {
          if (generator != null) 
          {
              var number = generator.GetRandom();
              var burgers = new List<Cheeseburger>();

              while(number > 0) {
                  burgers.add(new Cheeseburger());
                  number--;
              }

              Cheeseburgers = burgers;
          }
     }
}

Can-Do 和 Is-A 关系允许我们抽象逻辑。假设我们有任意数量，我们想知道它们总共有Animals多少。Cheeseburgers如果我们必须为每种动物编写一个方法，然后尝试将它们加在一起，这将不会很有趣。但是通过抽象，我们可以编写一种方法。

public static class Util
{
     public int GetTotalCheeseburgerCount(List<Animal> animals)
     {
          var total = 0;

          foreach(var animal in animals)
          {
               // not every animal can have cheeseburgers, so we 
               // can ignore this animal if it can't.
               var canHasCheeseburger = animal as ICanHasCheeseburger;
               if (canHasCheeseburger != null)
               {
                   if (canHasCheeseburger.Cheeseburgers != null)
                   {
                       total += canHasCheeseburger.Cheeseburgers.Count;
                   }
               }
          }

          return total;
      }
 }
于 2013-10-29T20:10:39.813 回答