virtuales variable sobreescribir sharp metodos metodo herencia entre diferencia and abstracto c# abstract-class pure-virtual

variable - sobreescribir metodo c#



¿Métodos virtuales puros en C#? (7)

Me han dicho que haga el resumen de mi clase:

public abstract class Airplane_Abstract

Y para hacer un método llamado movimiento virtual

public virtual void Move() { //use the property to ensure that there is a valid position object double radians = PlanePosition.Direction * (Math.PI / 180.0); // change the x location by the x vector of the speed PlanePosition.X_Coordinate += (int)(PlanePosition.Speed * Math.Cos(radians)); // change the y location by the y vector of the speed PlanePosition.Y_Coordinate += (int)(PlanePosition.Speed * Math.Sin(radians)); }

Y que otros 4 métodos deberían ser "métodos virtuales puros". ¿Qué es eso exactamente?

Todos se ven así en este momento:

public virtual void TurnRight() { // turn right relative to the airplane if (PlanePosition.Direction >= 0 && PlanePosition.Direction < Position.MAX_COMPASS_DIRECTION) PlanePosition.Direction += 1; else PlanePosition.Direction = Position.MIN_COMPASS_DIRECTION; //due north }


"Pure virtual" es la terminología de C ++. El equivalente de C # es un método abstracto.


Entonces no tiene una implementación en la clase Airplane_Abstract, pero obliga a los consumidores "herederos" de la Clase a implementarlos.

La clase Airplane_Abstract no se puede usar hasta que heredes e implementes las funciones abstractas.


O incluso puede ir a la interfaz, pensó que se requiere alguna pequeña limitación:

public interface IControllable { void Move(int step); void Backward(int step); } public interface ITurnable { void TurnLeft(float angle); void TurnRight(float angle); } public class Airplane : IControllable, ITurnable { void Move(int step) { // TODO: Implement code here... } void Backward(int step) { // TODO: Implement code here... } void TurnLeft(float angle) { // TODO: Implement code here... } void TurnRight(float angle) { // TODO: Implement code here... } }

Sin embargo, tendrá que implementar todas las declaraciones de funciones de IControllable e ITurnable asignadas; de lo contrario, se producirá un error de compilación. Si desea una implementación virutal opcional, debería ir a abstract class para el método virtual con la interface para el método virtual puro.

De hecho, existe una diferencia entre la función de interface y abstract función abstract , esa interface solo declara la función , todas las funciones de la interface deben ser públicas, por lo que no hay ninguna propiedad de clase private como private o protected por lo que es muy rápida, mientras que abstract función abstract es clase real método sin implementación y obliga a la implementación en la clase derivada , por lo que puede poner variables miembro private , protected y de acceso con funciones abstract , y la mayoría de las veces es más lento porque las relaciones de herencia de clase se analizan en tiempo de ejecución . (aka vtable)


Probablemente quieran decir que los métodos deben ser marcados como abstract .

public abstract void TurnRight();

Luego tendrá que implementarlos en las subclases, a diferencia de un método virtual vacío, donde la subclase no tendría que anularlo.


Supongo que quien te dijo que escribieras un método "puro virtual" fue un programador de C ++ en lugar de un programador de C # ... pero el equivalente es un método abstracto:

public abstract void TurnRight();

Eso obliga a las subclases concretas a anular TurnRight con una implementación real.


Una función virtual pura es la terminología de C ++, pero en C # si una función que se implementa en la clase derivada y esa clase derivada no es una clase abstracta.

abstract class PureVirtual { public abstract void PureVirtualMethod(); } class Derivered : PureVirtual { public override void PureVirtualMethod() { Console.WriteLine("I''m pure virtual function"); } }


http://en.wikipedia.org/wiki/Virtual_function

"En la programación orientada a objetos, una función virtual o método virtual es una función o método cuyo comportamiento puede ser anulado en una clase heredada por una función con la misma firma".

Google es siempre tu amigo