Fundamentals of C # Object-oriented programming

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 shape class public override double area This property is definitely present in shape, but we don't want to use shape to rewrite virtual, Abstract is to tell other classes that you want to inherit from him that you can override this method or property of me, otherwise it is not allowed.

A vivid example: Dad represents a base class (inherited Class) The son represents a subclass (inherited class) The father told his son with virtual: "Son, you have to inherit my career, on this piece can continue to develop your own" sons with Override tell the world: "This I do not directly take my father's, He's just pointing a way to me, and it's my own struggle.
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,

Example of inheritance 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

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 and Virtual: method overrides use the Override Keyword interface definition to start with the uppercase letter I. Method only defines its name, in C #, the method is the public method by default, and it is not allowed to modify the method, otherwise a compilation error will occur;

Interfaces can inherit from other interfaces, and if they inherit 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 using interface (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 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

}

}

Fundamentals of C # Object-oriented programming