如何在C＃中通过接口实现此抽象类/属性逻辑？

Question

我有一个包含Abstract properties的抽象类图形，并且在派生类Rectangle和Square中覆盖了它们。 现在，我想用Interface来实现这一点。 但是我不能使用构造函数，也不能在Interface内部声明变量。 那么，如何使用Interface实现这些功能，其中Figures应该是Interface，而Square和Rectangle应该是class ？

abstract class Figures
{
    int Width;
    int _cs;
    public Figures(int Width)
    {
        CS = Width;
    }

    public abstract int getarea
    {
        get;
    }
    public abstract int getperm
    {
        get;
    }
    public abstract int CS
    {
        set;
    }

    public abstract void display();
}

class Square : Figures
{
    int _CsS;
    public Square(int c) : base(c)
    {
    }

    public override int getarea
    {
        get
        {
            return (_CsS * _CsS);
        }
    }
    public override int getperm
    {
        get
        {
            return (2 * _CsS * _CsS);
        }
    }
    public override int CS
    {
        set
        {
            _CsS = value;
        }
    }

    public override void display()
    {
        Console.WriteLine("area={0} and perimeter={1}", getarea, getperm);
    }
}

class Rectangle : Figures
{
    int H;
    int _csr;
    public Rectangle(int H, int W) : base(W)
    {
        this.H = H;
    }

    public override int getarea
    {
        get
        {
            return H * _csr;
        }

    }
    public override int getperm
    {
        get
        {
            return 2 * H * _csr;
        }

    }
    public override int CS
    {
        set
        {
            _csr = value;
        }
    }

    public override void display()
    {
        Console.WriteLine("area={0} and perimeter={1}", getarea, getperm);
    }
}

Answer 1

您可以执行以下操作：

interface IFigures
{

    int getarea
    {
        get;
    }
    int getperm
    {
        get;
    }
    int CS
    {
        set;
    }

    void display();
}

然后您可以从您的类中实现此接口，并在类本身中进行逻辑处理。 因此，不必将属性逻辑放在抽象类中，而必须在子类中编写它们。

class Square : IFigures
{
    int _CsS;
    public Square(int c) 
    {
         CS = c;
    }

    public int getarea
    {
        get
        {
            return (_CsS * _CsS);
        }
    }
    public int getperm
    {
        get
        {
            return (2 * _CsS * _CsS);
        }
    }
    public int CS
    {
        set
        {
            _CsS = value;
        }
    }

    public void display()
    {
        Console.WriteLine("area={0} and perimeter={1}", getarea, getperm);
    }

    //here you have implemented properties
}

Answer 2

那么如何使用接口来实现

根据定义，接口不会让您实现任何东西。 您只能指定事物。

因此，您将不得不从IFigures接口中删除ctor和字段，并在每个类中重新实现它们。 您可以使用abstract class FiguresBase: IFigures重用实现，但这并不总是最好的设计。

这完全取决于您为什么要使用该界面以及如何使用它。

Answer 3

您的抽象类是一件好事。 它使您可以重用代码。

如果要实现松散耦合的系统，则接口（即合同）也很好。

您可以将抽象类和接口一起使用，以实现代码的可重用性和松散耦合的部分。

public interface IFigures
{
  int getarea();
}
public abstract class Figures : IFigures
{
  public abstract int getarea();

  //opportunity for code reuse
  protected int getarea_internal()
  {
    throw new NotimplementedExcpetion();
  }
}

public class Square : Figures
public class Rectangle: Figures

Answer 4

这是类图的答案

程序的类图

 interface IFigures
    {
        int Getarea
        {
            get;

        }
        int GetPerm
        {
            get;
        }
        int CS
        {
            //get;
            set;
        }
    }
  abstract class Figures:IFigures
    {
        int _Cs;
        public Figures( int _Cs)
        {
            CS = _Cs;
        }

        public abstract int Getarea
        {
            get;

        }
        public abstract int GetPerm
        {
            get;

        }
        public abstract int CS
        {
            //get;
            set;
        }
        public abstract void display();

    }
class Circle:Figures
    {
        int _r, _csc;
        public Circle(int _r):base(_r)
        {
            CS = _r;
        }

        public override int Getarea
        {
            get
            {
                return (_r * _r);
            }


        }
        public override int GetPerm
        {
            get
            {
                return (2* _csc * _csc);
            }


        }
        public override void display()
        {
            Console.WriteLine("area of Circle={0}", (_r * _r));
            Console.WriteLine("perimeter of rectangle={0}", (2 * _r * _r));
        }
        public override int CS
        {
            //get
            //{
            //    return _csc;
            //}

            set
            {
                _csc = value;
            }
        }

    }

class Rectangle:Figures
    {
        int _L, _csr;
        public Rectangle(int _L,int _W):base(_W)
        {
         this._L = _L;
            CS = _W;
        }
        public override int Getarea
        {
            get
            {
                return _csr * _L;
            }


        }
        public override int GetPerm
        {
            get
            {
                return (2* _csr * _L);

            }



        }
        public override void display()
        {
            Console.WriteLine("area of rectangle={0}", (_csr * _L));
            Console.WriteLine("perimeter of rectangle={0}", (2* _csr * _L));
        }
        public override int CS
        {
            //get
            //{
            //    return _csr;
            //}

            set
            {
                _csr = value;
            }
        }
}
class Program
    {
        static void Main(string[] args)
        {
            Figures f = new Rectangle(3, 4);
            f.display();
            //f.CS = 5;
            f.display();

            Console.ReadKey();
        }
    }