Reference article: http: //www.cftea.com/c/2012/03/5522.asp; http: //blog.sina.com.cn/s/blog_4aaeba510100c4y6.html
an abstract method: Benefits: Flexible implementation code reuse, a subclass overrides (override); abstract purpose that I can not achieve it by inheriting my class to achieve
1, a, abstract class method must be abstract methods, or error;
b, the properties do not have to abstract property.
2, a, a class can inherit an abstract class;
B, abstract and private, virtual, static can not be used simultaneously;
C, can not be instantiated abstract class.
3, an abstract method of the abstract class, an abstract property to be rewritten generally subclasses (to be consistent accessibility override), and abstract properties of the read and write cases to be consistent.
4, an abstract method of the abstract class does not have to override the abstract properties abstract subclasses, but must be rewritten to implement, is not implemented in the rewriting must be overridden in a subclass.
5, sub-class inherits the abstract class can override inherited abstract class inherits the method properties again.
6, not abstract field (because the field can only be assigned by an equal sign, no other code (different from the property), nothing abstract sense).
example:
public abstract class PhoneAbsstract // abstract class method must be abstract methods, or error; property does not have to abstract properties. { Public abstract void call (); public abstract void camera (); public abstract void Internet (); private int _size = 0; public int size { get { return _size; } set { _size = size; } } public abstract int weight { get;} } public class Phone1: PhoneAbsstract // abstract method abstract class must override the abstract properties (rewrite accessibility to be consistent) in its general subclasses, and read the abstract properties, write to the same situation. { Public the override void call () { Console.Write ( " I can call. " ); } public the override void camera () { Console.Write ( " I can play photo. " ); } public the override void Internet () { Console.Write ( " I can access. " ); } private int _weight = 0; public override int weight { get { return _weight; } } } public abstract class IPhoneAbstract: PhoneAbsstract // abstract method of the abstract class, an abstract property is not always to be rewritten in the abstract subclasses, but must be rewritten to implement { public the override void call () { Console.Write ( " the IPhone mobile phone can call. " ); } public the override void Internet () // subclass inherits the abstract class can override inherited abstract class inherits the method properties again. { Console.Write ( " the IPhone mobile phone access to the Internet. " ); } private int _weight = 0; public override int weight { get { return _weight; } } } public class iphone1: IPhoneAbstract // not implemented in a rewritable must be overridden in a subclass { public the override void Internet () { Console.Write ( " the IPhone mobile phone access to the Internet. " ); } public the override void camera () { Console.Write ( " the IPhone camera phone can. " ); } }
Second, the interface: multi-state; the purpose is to provide a standard interface for people to comply with, we do not know how to achieve; Simple factory pattern applications (using multi-state);
1, the interface can only be public, that implements the interface must also be public;
2, can implement multiple interfaces, but all methods inherited interfaces must be achieved;
example: a simple factory pattern
class Program { static void Main(string[] args) { phone2 p2=new phone2(); camera c = new camera(); . SimplenessFactory camera (P2); . SimplenessFactory camera (C); Console.Read(); } } public class SimplenessFactory // simple engineering model application interface { public static void camera (photographing device interface Photo) { . Photo camera (); } } public interface call interface // interfaces only public { void call (); } public interface photographic device interface { void photographic (); int size { GET ;} } public interface Internet Device Interface { void Internet (); } public class phone1: call interface // interface implementation class must be public { public void call () // must be public { Console.WriteLine ( " phone 1 phone calls. " ); } } public class phone2: call device interface, camera interface, Internet interface // can implement multiple interfaces, but all methods inherited interfaces must be realized { public void call () { Console.WriteLine ( " Phone 2 phone calls. " ); } public void camera () { Console.WriteLine ( " Phone 2 photo shoot. " ); } public void Internet () { Console.WriteLine ( " phone access to the Internet 2. " ); } public int size { get { return 100; } } // attribute must also realize, it must be public } public class Camera: camera Device Interface { public void camera () { Console.WriteLine ( " camera photo shoot. " ); } public int size { get { return 200; } } // attribute must also realize, it must be public }
Third, the difference between abstract classes and interfaces:
1, a class may be a plurality of interfaces, but only implement an abstract class.
2, the specific methods of the abstract class implements virtual default, but the interface of the interface class method implementation has a default non-virtual, of course, you can declare virtual
3, (Interface) with similar non-abstract class, an abstract class must also provide its own implementation for all members of the interfaces listed in the base class list of this class. However, the abstract class interface method allowing
mapped to the abstract methods.
4, good interface definition should be a specific functional, rather than a multi-functional, interfaces or cause pollution.
Fourth, the use of abstract classes and interfaces:
1. If you expect to create multiple versions of a component, create an abstract class. Abstract class provides a simple way to control the component version.
2. If the function was created to be used in a wide range between disparate objects, use the interface. If you want to design small and concise function block, use the interface.
3. If the functional unit to be designed large, an abstract class is used. To provide common among all components to achieve functionality has been achieved, using an abstract class.
4. main abstract class for objects close; and the interface is adapted to provide generic functions unrelated to the class.
Here is what I see on the Internet a few metaphor, really good, huh:
1. The aircraft can fly, birds fly, they have inherited the same interface "fly"; but F22 aircraft belonging to an abstract class, abstract class pigeons belong to the birds.
2. Like iron gate doors are doors (abstract class), you want a door I can not give (can not be instantiated), but I can give you a specific gates or doors (multi-state); and can only be door, you can not say that it is a window (single inheritance); a door can be locked (interfaces) can also doorbell (more than realized). Door (abstract class) defines what you are, an interface (lock) sets out what you can do (the best one interface can only do one thing, you can not ask locks can sound bar (Interface pollution).