今天来说一下类的成员。

     类的成员有访问修饰符，字段，构造函数，析构函数，属性，索引器。

     类有五种访问修饰符：public、private、protected、internal最后一个是protected与internal的组合。这几种修饰符使用范围各有不同，public可以修饰所有的类成员，同一个解决方案中的其他的类可以访问所有的用public修饰的另一个类的成员。但是枚举与接口除外，它两个不可以用任何的修饰符来修饰，系统默认是public的。用private修饰符修饰的成员是私有的，只有本类中的成员可以访问。protected修饰的成员可以被本类和继承类所访问。internal是在同一命名空间的可以访问。protected internal 是一个组合修饰符，用该修饰符修饰的类的成员可以被同一命名空间或继承类访问。

     字段被定义在类或方法中，一般为私有的，目的是保护数据不被恶意改变。只读字段只能在构造函数中初始化。

      构造函数名与类名相同，构造函数可以重载，在实例化对象的时候除非自己调用了有参的构造函数，否则系统将自动调用无参的构造函数。如果在类中定义字段的时候没有给它初始化，则构造函数会给它初始化成默认值。

       析构函数与构造函数相反，是用来释放内存的。它不用任何的修饰符，只有一个函数名，函数名与类名相同。

        属性是用来封转数据的，对数据起到保护的作用，属性的定义与方法类似，只有签名没有参数，属性的内部包含两个访问器：get访问器和set访问器。get用来接收参数，set用来设置返回值。一个属性中可以只包含一个访问器，但是不可以一个访问器都不设，只有get的是只读属性，只有set的是只写属性。

         索引器也可以称作是有参属性，它的定义与属性非常相似，同样有get和set访问器，索引器是把对象本身当成序列，用this关键字。索引器可以被重载，可以有多个参数，在调用索引器的时候可以直接采用对象加下标的方式去调用，这个很类似与系统提供的ArrayList这个类所实现的功能了。鉴于此，我们可以尝试自己用索引器去创建一个类，来实现ArrayList所实现的所有的方法。

         下面是这个设想的具体实现：

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Collections;  
6.  
7. namespace MakeMyArrayList  
8. {  
9.     class Program  
10.     {  
11.         static void Main(string[] args)  
12.         {  
13.             MyArrayList mal = new MyArrayList();  
14.             mal.Add(1);  
15.             mal.Add(2);  
16.             mal.Add(3);  
17.             mal.Add(4);  
18.             mal.Add(5);  
19.             mal.Add(6);  
20.             mal.Add(7);  
21.             mal.Add(8);  
22.             mal.Add(9);  
23.             mal.Add(10);  
24.             mal.Add(11);  
25.             //mal.Insert(2, 99);  
26.             //Console.WriteLine(mal.Contains(188));  
27.             //mal.RemoveAt(6);  
28.             //mal.Reverse(3, 4);  
29.             //mal.Remove(9);  
30.             //mal.Clear();  
31.             foreach (object o in mal)  
32.             {  
33.                 Console.WriteLine(o);  
34.             }  
35.             Console.WriteLine("数量" + mal.Count);  
36.             Console.WriteLine("容量" + mal.Capacity);  
37.         }  
38.     }  
39.     class MyArrayList : IEnumerable  
40.     {  
41.         int count = 0;  
42.  
43.         //计算元素个数的属性  
44.         public int Count  
45.         {  
46.             get 
47.             {  
48.                 return count;  
49.             }  
50.         }  
51.  
52.         //计算容量的属性  
53.         public int Capacity  
54.         {  
55.             get 
56.             {  
57.                 return objarr.Length;  
58.             }  
59.             set 
60.             {  
61.                 if (value < count)  
62.                 {  
63.                     throw new Exception("容量小于元素个数");  
64.                 }  
65.                 else 
66.                 {  
67.                     object[] newobjectarr = new object[value];  
68.                     for (int i = 0; i < count; i++)  
69.                     {  
70.                         newobjectarr[i] = objarr[i];  
71.                     }  
72.                     objarr = newobjectarr;  
73.  
74.  
75.                 }  
76.  
77.             }  
78.         }  
79.  
80.         //创建一个新数组  
81.         object[] objarr = new object[0];  
82.  
83.         //索引器  
84.         public object this[int index]  
85.         {  
86.             get 
87.             {  
88.                 if (index < count)  
89.                 {  
90.                     return objarr[index];  
91.                 }  
92.                 else 
93.                 {  
94.                     throw new Exception("超出索引界限");  
95.                 }  
96.  
97.             }  
98.             set 
99.             {  
100.                 if (index < count)  
101.                 {  
102.                     objarr[index] = value;  
103.                 }  
104.                 else 
105.                 {  
106.                     throw new Exception("索引超出界限");  
107.                 }  
108.  
109.             }  
110.         }  
111.  
112.         //无参的构造函数  
113.         public MyArrayList()  
114.         {  
115.  
116.         }  
117.  
118.         //有参的构造函数  
119.         public MyArrayList(int i)  
120.         {  
121.             objarr = new object[i];  
122.         }  
123.  
124.         //清除所有元素的方法  
125.         public void Clear()  
126.         {  
127.             for (int i = 0; i < objarr.Length; i++)  
128.             {  
129.                 objarr[i] = null;  
130.                 count--;  
131.  
132.             }  
133.             count =0;  
134.         }  
135.  
136.         //反转所有元素的方法  
137.         public void Reverse()  
138.         {  
139.             object[] newobjectarr = new object[count];  
140.             for (int i = 0; i < count; i++)  
141.             {  
142.                 newobjectarr[i] = objarr[count - i - 1];  
143.             }  
144.             objarr = newobjectarr;  
145.  
146.         }  
147.  
148.         //指定位置的反转方法  
149.         public void Reverse(int index, int count)  
150.         {  
151.             object[] ob = new object[1];  
152.             for (int i = 0; i < (count) / 2; i++)  
153.             {  
154.                 ob[0] = objarr[index + i];  
155.                 objarr[index + i] = objarr[count - 1 + index - i];  
156.                 objarr[count - 1 + index - i] = ob[0];  
157.  
158.             }  
159.         }  
160.  
161.         //添加元素的方法  
162.         public int Add(object value)  
163.         {  
164.             if (objarr.Length == 0)  
165.             {  
166.                 objarr = new object[4];  
167.                 objarr[0] = value;  
168.                 count++;  
169.                 return count;  
170.  
171.             }  
172.             else 
173.             {  
174.                 if (count < objarr.Length)  
175.                 {  
176.                     objarr[count] = value;  
177.                     count++;  
178.                     return count - 1;  
179.                 }  
180.                 else 
181.                 {  
182.                     object[] newobjectarr = new object[objarr.Length * 2];  
183.                     for (int i = 0; i < objarr.Length; i++)  
184.                     {  
185.                         newobjectarr[i] = objarr[i];  
186.                     }  
187.                     newobjectarr[count] = value;  
188.                     count++;  
189.                     objarr = newobjectarr;  
190.                     return count - 1;  
191.                 }  
192.             }  
193.  
194.         }  
195.  
196.         //删除元素的方法  
197.         public void Remove(object value)  
198.         {  
199.             int index = -1;  
200.             for (int i = 0; i < count; i++)  
201.             {  
202.                 if (value.Equals(objarr[i]))  
203.                 {  
204.                     index = i;  
205.                     break;  
206.                 }  
207.             }  
208.             if (index != -1)  
209.             {  
210.                 for (int i = index; i < count; i++)  
211.                 {  
212.                     objarr[i] = objarr[i + 1];  
213.                 }  
214.                 objarr[count - 1] = null;  
215.                 count--;  
216.             }  
217.  
218.         }  
219.  
220.         //指定位置的删除元素的方法  
221.         public void RemoveAt(int index)  
222.         {  
223.             object[] ob = new object[1];  
224.             ob[0] = objarr[count - 1];  
225.             for (int i = 0; i < count; i++)  
226.             {  
227.                 if (i == index)  
228.                 {  
229.                     for (int j = i; j < count - index; j++)  
230.                     {  
231.                         objarr[j] = objarr[j + 1];  
232.                     }  
233.                 }  
234.             }  
235.             count -= 1;  
236.             objarr[count - 1] = ob[0];  
237.  
238.         }  
239.  
240.         //判断是否包含某个元素的方法  
241.         public bool Contains(object value)  
242.         {  
243.             for (int i = 0; i < count; i++)  
244.             {  
245.                 if (value.Equals(objarr[i]))  
246.                 {  
247.                     return true;  
248.                 }  
249.             }  
250.             return false;  
251.         }  
252.  
253.         //插入元素的方法  
254.         public void Insert(int index, object value)  
255.         {  
256.             object[] ob = new object[count -index+1 ];  
257.             for (int i = 0; i < count+1 ; i++)  
258.             {   
259.                 if (i == index)  
260.                 {   
261.                     ob[0] = objarr[i];  
262.                     objarr[i] = value;  
263.                     count += 1;  
264.                     for (int j = 1; j < count-index ; j++)  
265.                     {  
266.                         ob[j] = objarr[i + j ];  
267.                         objarr[i+j  ] = ob [j -1];     
268.                     }   
269.                 }       
270.             }  
271.         }  
272.  
273.         //遍历整个数组  
274.         public IEnumerator GetEnumerator()  
275.         {  
276.             for (int i = 0; i < count; i++)  
277.             {  
278.                 yield return objarr[i];  
279.             }  
280.         }  
281.  
282.     }  
283. }  

        这就是今天的内容了。大家午安 ~ ~ ~