1 /*
  2  * Created by SharpDevelop.
  3  * User: YuanWei
  4  * Date: 2015/1/10
  5  * Time: 21:03
  6  * Learning interface
  7  * 接口也是多态性的一种表现,他的重要目的是多态
  8  * 接口既不包含实现，也不包含数据，不包含字段
  9  * 接口的一个重要的特征就是永远不能实例化，不能用new创建接口，所以接口没有构造器和终结器；
 10  * 接口不能包含静态成员
 11  * 不能显式的写abstract
 12  * 接口也可以继承，但是那样就没有什么具体额意义了，至少那样写是可以合理的
 13  * 接口作为一种类型当然可以进行类型转换，如果一个类实现了一个接口就可以将这个类强转换为借口，然后再调用这个接口的方法（通过.可以点出来）
 14  * 显示实现的接口不被看做是类的公共成员的，不能有public virtual override 来修饰它们
 15  * 任何接口都可以转换为System.Object类型
 16  * 接口是引用类型
 17  * 接口如果一旦提交好了就不要更改，会破坏版本的兼容性，可以用一个新的接口继承这个接口，这是跟abstract区别之一
 18  * To change this template use Tools | Options | Coding | Edit Standard Headers.
 19  */
 20 using System;
 21 using System.Text;
 22 using Learning;
 23 using InterfaceLearn;
 24 
 25 namespace InterfaceLearning
 26 {
 27     class Program
 28     {
 29         public static void Main(string[] args)
 30         {
 31             
 32             // TODO: Implement Functionality Here
 33             
 34 //            Animal a=new Animal();
 35 //            a.Name="Monkey";
 36 //            Person p=new Person();
 37 //            p.Open();
 38 //            China c=new China();
 39 //            c.Open();
 40 //            c.Speak();
 41 //            c.Say();
 42 //            StringBuilder sb=new StringBuilder();
 43 //            XiaoJapan xiao=new XiaoJapan();
 44 //            xiao.Say();
 45 //            xiao.Open();
 46 //            Contact c=new Contact("YuanWei");
 47 //            Console.WriteLine(a.Name);
 48 //            InterfaceEnforce
 49 //            Study s=new Study();
 50 //            IPlay i=new IPlay();//会报错，无法创建抽象类或接口的instance
 51             Son s=new Son();
 52             
 53 //            //((IFatherable)s).Teach();//接口也是一种类型，当然可以进行类型转换        
 54 //            IFatherable ife=(s as IFatherable);
 55 ////            ife.Equals();
 56 //            ife.GetHashCode();
 57 //            ife.Teach();
 58 //            ife.ToString();//接口类型可以点出来的东西正好是object的成员，说明每个接口类型都可以转换为System.Object
 59 //            ife.Teach();//这样写都是正确的
 60             GrandSon gs=new GrandSon();
 61             
 62             Console.ReadKey(true);
 63         }
 64     }
 65 //    public class NewString
 66 //    {
 67 //
 68 //    }
 69     public interface IFatherable
 70     {
 71         void Teach();
 72 //        static void Learn();//会报错，说明接口中不能包含静态成员
 73     }
 74     public class Son:IFatherable
 75     {
 76         public void Teach()
 77         {
 78             Console.WriteLine("I can Teach");
 79         }
 80     }
 81     public class GrandSon:IFatherable
 82     {
 83        void IFatherable.Teach() //如果是显示的实现某一个接口，就不能有任何修饰符，所以这样来的成员外面也就访问不了了，就没有什么意义了
 84         {
 85            Console.WriteLine("implement of obvious");
 86             //显示的实现接口的成员，不能有修饰符,不被看为是类的公共成员
 87         }
 88     }
 89     public interface IListable:IPlay //表明了接口也可以继承，不过要在实现这个接口的类中有两个的具体实现
 90     {
 91         string[] ColumValues
 92         {
 93             get;
 94         }
 95         string Items{get;set;}
 96 //        static string Talk();//会报错，接口不鞥你包含静态成员
 97 //        abstract string Talk();//会报错，虽然每个接口成员都要实现他的类型有具体实现，跟abstract一样没得商量，但是不能显式的写abstract
 98     }
 99     /*
100      * 抽象类可以实现接口，
101      * 也允许提供接口成员的抽象实现
102      */
103     public abstract class BaseClass:IListable 
104     {
105         public abstract string[] ColumValues
106         {
107             get; //这样编译是不会报错的，所以可以留给后代去实现具体的细节
108 //            {
109 //                return new string[]
110 //                {
111 //                    "袁伟",
112 //                    "张三"
113 //                };
114 //            }
115         }
116         public abstract string Items
117         {
118             get;set;
119         }
120         public void Say()
121         {
122             //实现IPlay
123         }
124         public void Open()
125         {
126             //实现IPlay
127         }
128     }
129     public interface IFunction
130     {
131         //接口里面的成员是不能有修饰符的，默认都是public，如果加了修饰符是错误的
132         void Speak();
133         //public int ShengMing;//不能包含字段
134 //        int ShngMing;//错误
135         int Height{get;set;}//可以包含不引用支持字段的属性，因为属性不能有任何实现
136     }
137     public interface IPlay
138     {
139         void Open();
140         void Say();
141 //        public string Name{set;get;};//这种写法是错误的
142     }
143     //通过调用构造器可以知道要是实例化一个对象的时候先去调用祖宗辈一级一级往下调用
144     //如果父类实现了某一个接口的具体功能，那么作为儿子的自己，同时也将这些实现了的功能继承了下来  而且是一定继承下来的，
145     //因为父亲实现的时候修饰符必须是public的
146     public class BiZu
147     {
148         public BiZu()
149         {
150             Console.WriteLine("Consructor of BiZu");
151         }
152     }
153     //当然，父类实现了一个接口，作为子类也可以实现那个接口，但是具体的实现由它从父类中继承下来了，所以就不用再在子类中
154     //有这些个功能的具体实现了，换句话来讲，再在子类中实现此接口也就没有什么意义了
155     public class China:Person,IPlay   //Iply没有什么意义
156     {
157         public China()
158         {
159             Console.WriteLine("Consructor of China");
160         }
161         public string Color{get;set;}
162         //使用new 修饰符可以覆盖掉从父亲哪里继承下来的东西
163         public new void Say()
164         {
165             Console.WriteLine(" Cover the Say() of Father");
166         }
167     }
168     public class Japan:IPlay
169     {
170         public Japan()
171         {
172             Console.WriteLine("Constructor of Japan");
173         }
174         public void Open() //Must 这样实现，没有其他的实现形式，这是一种规定一种契约
175         {
176             Console.WriteLine("Japan of Open()");
177         }
178         public void Say()
179         {
180             Console.WriteLine("Japan of Say()");
181         }
182     }
183     public class XiaoJapan:Japan
184     {
185         public XiaoJapan()
186         {
187             Console.WriteLine("Constructor of XiaoJapan");
188         }
189     }
190     public class Person:BiZu,IFunction,IPlay
191     {
192         //如果一个类实现了一个接口，那么这个类就必须实现这个接口里面的成员，而且这个实现还必须是公共的public
193         //而且跟重写是不一样的，这里面叫实现，所以不能用override，要不然会报错
194         //接口表示的是某一个  (类型)  “能做”接口规定的事情，
195         //接口分为显示实现和隐式实现
196         //如果一个类型 实现了两个接口的话，这两个接口里面有相同的功能，那么这两个功能都要实现,如果是隐式实现的话，那就是只用写一个就行了
197         //显示实现的话，就要有两个如下的实现方法，但是不能加public
198         //接口能将实现的细节和提供的功能完全分隔开；
199         public Person()
200         {
201             Console.WriteLine("Consructor of Person");
202         }
203         public void Open()
204         {
205             Console.WriteLine("I can open");
206         }
207         public void Say()
208         {
209             Console.WriteLine("I Can Say");
210         }
211         public void Speak()
212         {
213             Console.WriteLine("I can speak");
214         }
215         private int _Height;
216         public int Height
217         {
218             get{return _Height;}
219             set{_Height=value;}
220         }
221     }
222     public class Animal
223     {
224         public Animal()
225         {
226             Console.WriteLine("Consructor of Animal");
227         }
228         private string _Name;
229         public string Name
230         {
231             set
232             {
233                 if(value=="Monkey")
234                 {
235                     _Name="Houzi";
236                 }
237                 else
238                 {
239                     _Name=value;
240                 }
241             }
242             get{return _Name;}
243         }
244         public int Age{get;set;}
245     }
246     public abstract class PdaItem
247     {
248 //        public PdaItem()
249 //        {
250 //
251 //        }
252         public PdaItem(string name)
253         {
254             Name=name;
255         }
256         private string _Name;
257         public virtual string Name
258         {
259             get{return _Name;}
260             set{_Name=value;}
261         }
262     }
263     public class Contact:PdaItem
264     {
265         //对于继承来说，如果父类没有无参的构造函数那么子类必须要显示的有构造函数而且必须要是有参的构造函数
266         //因为早调用子类的构造函数之前必须先调用父类的构造函数，父类中的构造函数没有无参的那么在子类的构造函数中就要给父类传实参进去，通过base传进去
267         public Contact(string name):base(name)
268         {
269             Name=name;
270         }
271         //public new string Name{get;set;}
272         private string _Name;
273         public override string Name {
274             get{return this._Name;}
275             set{_Name=value;}
276             
277         }
278     }
279 }