1. IntroductionIn my previous post titled "who is the abstract class and interface?", I discussed with my colleague Guan Wei and got the attention of many friends, because it is not a systematic theory, therefore, it is inconvenient for everyone to understand. At the same time, I think it is also necessary to summarize the systemic theory of this topic. Therefore, this article has been released. At the same time, I will also explain the problems mentioned above.2. introduction of concepts
An interface is an abstract type that contains a set of virtual methods. Each method has its name, parameter, and return value. Interface methods cannot contain any implementations. clr allows interfaces to include events, attributes, indexers, static methods, static fields, static constructors, and constants. Note: c # cannot contain any static members. A class can implement multiple interfaces. When a class inherits an interface, it must not only implement all methods defined by this interface, but also implement all methods inherited from other interfaces. Definition method:
- Public interface system. icomparable
- {
- Int compareto (object o );
- }
-
- Public class testcls: icomparable
- {
- Public testcls ()
- {
- }
-
- Private int _ value;
- Public int value
- {
- Get {return _ value ;}
- Set {_ value = value ;}
- }
-
- Public int compareto (object o)
- {
-
- // Use the as mode for transformation judgment
- Testcls acls = o as testcls;
- If (acls! = Null)
- {
-
- // Implement the abstract Method
- Return _ value. compareto (acls. _ value );
- }
- }
- }
- What is an abstract class?
Abstract classes provide multiple Derived classes that share the public definitions of the base class. They can provide both abstract methods and non-abstract methods. Abstract classes cannot be instantiated. They must be inherited by the derived classes to implement their abstract methods. Therefore, abstract classes cannot use the new keyword or be sealed. If the derived class does not implement all abstract methods, the derived class must also be declared as an abstract class. In addition, the overriding method is used to implement the abstract method. Definition method:
- /// <Summary>
- /// Define an abstract class
- /// </Summary>
- Abstract public class animal
- {
- // Define static Fields
- Protected int _ id;
-
- // Define attributes
- Public abstract int id
- {
- Get;
- Set;
- }
-
- // Define the Method
- Public abstract void eat ();
-
- // Define the Indexer
- Public string this [int I]
- {
- Get;
- Set;
- }
- }
-
- /// <Summary>
- /// Implement an abstract class
- /// </Summary>
- Public class dog: animal
- {
- Public override int id
- {
- Get {return _ id ;}
- Set {_ id = value ;}
- }
-
- Public override void eat ()
- {
- Console. write ("dog eats .")
- }
- }
3. Similarities and Differences
3.1
Similarities
- They cannot be directly instantiated. They can all be inherited to implement their abstract methods.
- It is the technical basis for abstract programming and implements many design modes.
3.2
Differences
- Interfaces support multi-inheritance; abstract classes cannot implement multi-inheritance.
- An interface can only define abstract rules. abstract classes can either define rules or provide implemented members.
- An interface is a set of behavioral norms. An abstract class is an incomplete class that focuses on the concept of a family.
- Interfaces can be used to support callback. abstract classes cannot implement callback because inheritance is not supported.
- An interface only contains methods, attributes, indexers, and event signatures, but cannot define fields or methods that contain implementations. An abstract class can define fields, attributes, and methods that have implementations.
- The interface can act on the Value Type and reference type; the abstract class can only act on the reference type. For example, struct can inherit interfaces rather than classes.
Through comparison between the same and different types, we can only talk about interfaces and abstract classes, each of which has its own strengths, but has no advantages. In actual programming practices, we need to take appropriate measures based on actual situations. However, the following experiences and accumulation may give you some inspiration, except for some of my accumulation, many of them come from classic networks. I believe they can withstand the test. So in terms of rules and occasions, the most important thing for us to learn these classics is to apply what we have learned. Of course, I will give my family a wide smile.
3.3
Rules and occasions
- Remember, one of the most important principles of Object-oriented thinking is interface-oriented programming.
- With the help of interfaces and abstract classes, many of the 23 design patterns have been cleverly implemented. I think the essence is simply abstract programming.
- Abstract classes are mainly used for closely related objects, and interfaces are most suitable for providing general functions for irrelevant classes.
- The interface focuses on the can-do relationship type, while the abstract class focuses on the is-a relationship;
- Behavior of Multi-definition objects in interfaces; Attributes of Multi-definition objects in abstract classes;
- Interface definitions can use public, protected, internal, and private modifiers, but almost all interfaces are defined as public, so you don't have to say much about the reason.
- "Interface unchanged" is an important factor to consider. Therefore, when an extension is added by an interface, a new interface should be added instead of an existing interface.
- If possible, the interface design can be a single functional block. Taking. net framework as an example, idisposable, idisposable, icomparable, iequatable, and ienumerable all contain only one public method.
- The upper-case letter "I" before the interface name is an agreement, just as it starts with an underscore below the field name. Stick to these principles.
- All methods in the interface are public by default.
- If a version issue is expected, you can create an "abstract class ". For example, if you have created a dog, a chicken, and a duck, you should consider abstracting the animal to deal with future things. Adding a new member to an interface requires you to modify all the derived classes and re-compile them. Therefore, it is best to use an abstract class to solve the version problem.
- A non-abstract class derived from an abstract class must include all the inherited abstract methods and the actual implementation of the abstract accessors.
- Abstract classes cannot use the new keyword or be sealed because they cannot be instantiated.
- Static or virtual modifiers cannot be used in abstract method declarations.
The above rules are tentatively set to t14. If I am so tired of writing, I will be rewarded for the moment. You can also contact each other. I will revise it in time.
4. Classic example
4.1
Absolute classic. Net framework is the best resource for learning. Conscious Research of fcl is a required course for every. net programmer. I have the following suggestions on the use of interfaces and abstract classes in fcl:
- Fcl uses an interface-based design for the Collection class. Therefore, pay attention to the interface design and implementation in system. collections;
- Fcl uses the abstract class-based design for Data stream-related classes. Therefore, pay attention to the abstract class design mechanism of the system. io. stream class.
4.2 special dishesThe following example marks the classic as "relative" because of my understanding. As for when to be promoted to "absolute", I am here. is it possible to be so persistent on the path pursued by net as always, so I will reconstruct the relative structure to the absolute end (haha ). This example does not describe the application of abstract classes and interfaces in the design mode, because it will be another valuable text to be discussed. This article focuses on understanding concepts and principles, but the real application comes from specific requirements and specifications. Design structure: 1. define abstract classes
- Public abstract class animal
- {
- Protected string _ name;
-
- // Declare abstract attributes
- Public abstract string name
- {
- Get;
- }
-
- // Declare the abstract Method
- Public abstract void show ();
-
- // General Implementation Method
- Public void makevoice ()
- {
- Console. writeline ("all animals can make voice! ");
- }
- }
2. Define Interfaces
- Public interface iaction
- {
- // Define public method labels
- Void move ();
- }
3. Implement abstract classes and interfaces
- Public class duck: animal, iaction
- {
- Public duck (string name)
- {
- _ Name = name;
- }
-
- // Overload the abstract Method
- Public override void show ()
- {
- Console. writeline (_ name + "is showing for you .");
- }
-
- // Overload abstract attributes
- Public override string name
- {
- Get {return _ name ;}
- }
-
- // Interface Implementation Method
- Public void move ()
- {
- Console. writeline ("duck also can swim .");
- }
-
- }
-
- Public class dog: animal, iaction
- {
- Public dog (string name)
- {
- _ Name = name;
- }
-
- Public override void show ()
- {
- Console. writeline (_ name + "is showing for you .");
- }
-
- Public override string name
- {
- Get {return _ name ;}
- }
-
- Public void move ()
- {
- Console. writeline (_ name + "also can run .");
- }
-
- }
4. Client implementation
- public class testanmial
- {
- public static void main(string [] args)
- {
- animal duck = new duck("duck");
- duck.makevoice();
- duck.show();
-
- animal dog = new dog("dog");
- dog.makevoice();
- dog.show();
-
- iaction dogaction = new dog("a big dog");
- dogaction.move();
- }
- }
