Abstract and virtual in C #

In C # Learning, it is easy to confuse the use of virtual and abstract methods, now to discuss the difference between the two. Both involve the use of a mate with override in a derived class.

First, virtual method (virtual method)

The virtual keyword is used to decorate a method in a base class. There are two things you can do with virtual:

Scenario 1: The virtual method is defined in the base class, but the virtual method is not overridden in the derived class. In a call to a derived class instance, the virtual method uses the method defined by the base class.

Scenario 2: The virtual method is defined in the base class and then overridden in a derived class by using override. In a call to a derived class instance, the virtual method uses the derived overridden method.

Ii. Abstract Method (Abstraction method)

The abstract keyword can only be used to decorate a method in an abstraction class, and there is no specific implementation. An implementation of an abstract method must be implemented in a derived class by using the override keyword.

Interfaces and abstract classes:

The most essential difference: An abstract class is an incomplete class, an abstraction of an object, and an interface is a code of conduct.

C # is an object-oriented programming language, and each function belongs to a class.
Static: When a method is declared as static, the method is a static method, and the compiler retains the implementation of the method at compile time. That is, the method belongs to a class, but does not belong to any member, regardless of whether the instance of the class exists or not. Just like the entry function static void Main, because it is a static function, it can be called directly.

Virtua: When a method is declared as virtual, it is a dummy method until you use ClassName variable = new ClassName (); Before declaring an instance of a class, it does not exist in the real memory space. This keyword is very common in class inheritance and is used to provide polymorphism support for class methods.
Overrride: Indicates that overriding this class is inherited from the shape class
public override double Area This property is definitely present in shape, but we don't want to use shape, so rewrite it.
Virtual,abstract is telling other classes that want to inherit from him that you can rewrite my method or property, otherwise it is not allowed.
A vivid example: Dad represents a base class (inherited Class) son represents a subclass (inheriting class)
Dad used virtual to tell his son: "Children, you have to inherit my career, on this piece can continue to develop your own"
The son uses the override to tell the world: "This I am not directly to take my father's, he just refers to a way to me, is I struggle out of"

Abstract: The abstraction method declaration is used as a method that must be overridden by a derived class, which is used to inherit, and can be seen as a virtual method without implementing a body, and if the class contains an abstract method, the class must be defined as an abstract class, whether or not it contains other general methods, and the abstract class cannot have entities.
Example answers:
Interface: Used to declare an interface
1. Only some method specifications are provided, and no method body is provided. Such as:
public interface IPerson
{
void GetName ();//Does not contain method body
}
2. Methods cannot be modified with public abstract, no field variables, no constructors.
3. The method can contain parameters. Such as
public interface IPerson
{
void Getage (string s);
}
An example (Example 1):
public interface IPerson
{
IPerson (); Error
String name; Error
public void Getidcard ();//Error
void GetName (); Right
void Getage (string s); Right
}
Classes that Implement Interface
1. Consistent with the format of the inheriting class, such as public class chinese:iperson{}
2. Each method in the interface must be implemented
Example 2, inheritance Example 1
public class Chinese:iperson
{
Public Chinese () {}//Add construct
public void GetName () {}//implement GetName ()
public void Getage (string s) {}//implement Getage ()
}
Abstraction: Declaring abstract classes, abstract methods
1. The class in which the abstract method resides must be an abstract class
2. Abstract classes cannot be instantiated directly, and must be implemented by their derived classes.
3. The abstract method does not contain a method body and must be implemented by the derived class in an override manner, similar to the method in interface
Such as
Public abstract class book
{
Public book ()
{
}
public abstract void GetPrice (); Abstract method with no body
public virtual void GetName ()//virtual method, can overwrite
{
Console.WriteLine ("This is a test:virtual getName ()");
}
public virtual void getcontent ()//virtual method, can overwrite
{
Console.WriteLine ("This is a test:virtual getcontent ()");
}
public void GetDate ()//general method, if overridden in a derived class, must use the New keyword
{
Console.WriteLine ("This is a test:void getDate ()");
}
}
public class Javabook:book
{
public override void GetPrice ()//Implement abstract method, must implement
{
Console.WriteLine ("This is a Test:javabook override abstract GetPrice ()");
}
public override void GetName ()//Overwrite the original method, not required
{
Console.WriteLine ("This is a Test:javabook override virtual GetName ()");
}
}
The test is as follows:
public class Test
{
Public test ()
{
Javabook jbook=new Javabook ();
Jbook.getprice (); Will call Javabook in GetPrice ()
Jbook.getname (); Will call Javabook in GetName ()
Jbook.getcontent (); Will call book in GetContent ()
Jbook.getdate (); Will call book in GETDATE ()
}
public static void Main ()
{
Test t=new test ();
}
}
Virtual: The token method is a virtual method
1. You can override this method with override in a derived class
2. Do not overwrite or can be called by an object
3. Methods without this tag (and no other tags), overriding the original method with new
Abstract vs. Virtual: Use the Override keyword when overriding methods
The interface definition begins with the capital letter I. Method only defines its name, in C #, the method is the public method by default, the method is not allowed with the publicly modification, or a compilation error occurs, the interface can inherit from another interface, and if it inherits multiple interfaces, the parent interface list is separated by commas.
Interfaces can be implemented by classes, when the base list of a class contains both the base class and the interface, the first occurrence in the list is the base class, and the class must implement its abstract method;
Interface use: See Code (GO)
Interface use
Interface use (instance one)
Using System;
Namespace Dage.interface
{
Printer interface
public interface IPrint
{
String Returnprintname ();
}
}
//--------------------------------------------
Using System;
Using Dage.interface;
Namespace Dage.print
{
HP Brand Printer Class
public class Hp:iprint
{
public string Returnprintname ()
{
Return "This is the HP brand printer";
}
}
}
//--------------------------------------------
Using System;
Namespace Dage.print
{
EPS Brand printer class
public class Eps:iprint
{
public string Returnprintname ()
{
Return "This is the EPS brand printer";
}
}
}
//--------------------------------------------
Using System;
Using Dage.interface;
Namespace Dage
{
Print class
public class Printer
{
Public Printer ()
{}
public string Printname (IPrint IPrint)
{
return Iprint.returnprintname ();
}
}
}
//--------------------------------------------
Calling code in--winfrom:
private void Button1_Click (object sender, System.EventArgs e)
{
Printer p= new Printer ();
Switch (this.comboBox1.Text)
{
Case "HP":
MessageBox.Show (P.printname (New HP ()));
Break
Case "Eps":
MessageBox.Show (P.printname (New Eps ()));
Break
Default
MessageBox.Show ("did not discover this brand!") ");
Break
}
}

Transfer from http://www.cnblogs.com/blsong/archive/2010/08/12/1798064.html

Abstract and virtual (go) in C #