C# Abstraction
Abstract Classes and Methods
Data abstraction is the process of hiding certain details and showing only essential information to the user.
Abstraction can be achieved with either abstract classes or interfaces (which you will learn more about in the next chapter). 【“抽象”可以通过”抽象类”和”接口”实现】
The abstract keyword is used for classes and methods:
- Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).
- Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the derived class (inherited from).
An abstract class can have both abstract and regular methods:
|
1 2 3 4 5 6 7 8 |
abstract class Animal { public abstract void animalSound(); public void sleep() { Console.WriteLine("Zzz"); } } |
From the example above, it is not possible to create an object of the Animal class:
|
1 |
Animal myObj = new Animal(); // Will generate an error (Cannot create an instance of the abstract class or interface 'Animal') |
To access the abstract class, it must be inherited from another class. Let’s convert the Animal class we used in the Polymorphism chapter to an abstract class.
Remember from the Inheritance chapter that we use the : symbol to inherit from a class, and that we use the override keyword to override the base class method.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
// Abstract class abstract class Animal { // Abstract method (does not have a body) public abstract void animalSound(); // Regular method public void sleep() { Console.WriteLine("Zzz"); } } // Derived class (inherit from Animal) class Pig : Animal { public override void animalSound() <strong><mark style="background-color:rgba(0, 0, 0, 0)" class="has-inline-color has-vivid-purple-color">//██要实现抽象类中的方法，对子类中的方法还是要用 override 修饰！！！</mark></strong> { // The body of animalSound() is provided here Console.WriteLine("The pig says: wee wee"); } } class Program { static void Main(string[] args) { Pig myPig = new Pig(); // Create a Pig object myPig.animalSound(); // Call the abstract method myPig.sleep(); // Call the regular method } } |
Why And When To Use Abstract Classes and Methods?
To achieve security – hide certain details and only show the important details of an object.
Note: Abstraction can also be achieved with Interfaces, which you will learn more about in the next chapter.
C# Interface
An interface is a completely “abstract class“, which can only contain abstract methods and properties (with empty bodies): 【接口是一个完全的“抽象类”，它只能包含抽象方法和属性（具有空体）！？？】
|
1 2 3 4 5 6 |
// interface interface Animal { void animalSound(); // interface method (does not have a body) void run(); // interface method (does not have a body) } |
It is considered good practice to start with the letter “I” at the beginning of an interface, as it makes it easier for yourself and others to remember that it is an interface and not a class.
By default, members of an interface are abstract and public.
Note: Interfaces can contain properties and methods, but not fields.████
To access the interface methods, the interface must be “implemented” (kinda like inherited) by another class. To implement an interface, use the : symbol (just like with inheritance). The body of the interface method is provided by the “implement” class. Note that you do not have to use the override keyword when implementing an interface:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// Interface interface IAnimal { void animalSound(); <strong><mark style="background-color:rgba(0, 0, 0, 0)" class="has-inline-color has-vivid-purple-color">//██ interface method (does not have a body)</mark></strong> } // Pig "implements" the IAnimal interface class Pig : IAnimal { public void animalSound() { // The body of animalSound() is provided here Console.WriteLine("The pig says: wee wee"); } } class Program { static void Main(string[] args) { Pig myPig = new Pig(); // Create a Pig object myPig.animalSound(); } } |
Notes on Interfaces:
- Like abstract classes, interfaces cannot be used to create objects (in the example above, it is not possible to create an “IAnimal” object in the Program class)
- Interface methods do not have a body – the body is provided by the “implement” class
- On implementation of an interface, you must override all of its methods
- Interfaces can contain properties and methods, but not fields/variables
- Interface members are by default
abstractandpublic - An interface cannot contain a constructor (as it cannot be used to create objects)
Why And When To Use Interfaces?
1) To achieve security – hide certain details and only show the important details of an object (interface).
2) C# does not support “multiple inheritance” (a class can only inherit from one base class). However, it can be achieved with interfaces, because the class can implement multiple interfaces. Note: To implement multiple interfaces, separate them with a comma (see example in the next chapter).
Multiple Interfaces
To implement multiple interfaces, separate them with a comma:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
interface IFirstInterface { void myMethod(); // interface method } interface ISecondInterface { void myOtherMethod(); // interface method } // Implement multiple interfaces class DemoClass : IFirstInterface, ISecondInterface { public void myMethod() { Console.WriteLine("Some text.."); } public void myOtherMethod() { Console.WriteLine("Some other text..."); } } class Program { static void Main(string[] args) { DemoClass myObj = new DemoClass(); myObj.myMethod(); myObj.myOtherMethod(); } } |
