I have learned to create my class abstract:

public abstract class Plane_Abstract

And to create a method known as move virtual

 public virtual void Move()

        there's a legitimate position object

            double radians = PlanePosition.Direction * (Math.PI / 180.)

            // alter the x location through the x vector from the speed

            PlanePosition.X_Coordinate += (int)(PlanePosition.Speed * Math.Cos(radians))

            // alter the y location through the y vector from the speed

            PlanePosition.Y_Coordinate += (int)(PlanePosition.Speed * Math.Sin(radians))


Which 4 other techniques ought to be "pure virtual techniques." What's that exactly?

All of them seem like this at this time:

public virtual void TurnRight()


    if (PlanePosition.Direction >=  &lifier&lifier PlanePosition.Direction < Position.MAX_COMPASS_DIRECTION)

        PlanePosition.Direction += 1


        PlanePosition.Direction = Position.MIN_COMPASS_DIRECTION  //due north

My prediction is the fact that whomever said to create a "pure virtual" method would be a C++ programmer as opposed to a C# programmer... however the equivalent is definitely an abstract method:

public abstract void TurnRight()

That forces concrete subclasses to override TurnRight having a real implementation.

They most likely imply that the techniques ought to be marked abstract.

 public abstract void TurnRight()

You'll then have to implement them within the subclasses, instead of a clear virtual method, in which the subclass will not have to override it.

"Pure virtual" is C++ terminology. The C# equivalent is definitely an abstract method.


"In object-oriented programming, an online function or virtual technique is a function or method whose behavior could be overridden inside an getting class with a function with similar signature."

Bing is always your friend.

After this you do not have an implementation within the Plane_Abstract Class but they are forcing customers "inheritors" from the Class to implement them.

The Plane_Abstract Class is useless before you inherit and implement the abstract functions.