1 Ａ．类:
2 ● 类与类的使用:
3 class A{
4 public int wheels; //公有成员
5 protected float weight; //保护成员
6 }
7 class B{
8 void F{
9 A v1=new A(); //创选类Ａ的实例
10 v1.wheels=10; //调用类Ａ的公有成员成功
11 v1.weight=1.0; //错，因为此变量为保护成员
12 }
13 }
14 ● 类的继承:
15 类B从类A中继承
16 class A{}
17 class B:A{}
18
19
20 Ｂ．静态成员和非静态成员:
21 一般说来，静态成员属于类所有的，非静态成员则属于类的实例--对象
22 （非静态成员在类的每个实例中都占有一个存储（或者说具有一个副本）,
23 而静态方法是类所共享的，无法判断当前的非静态属于哪个类的实例.
24 引用静态与非静态成员：
25 int a; //非静态成员
26 static int b; //静态成员
27 void F(){ //非静态方法Ｆ
28 a=1; //正确，等价于this.x=1
29 b=1; //正确，等价于Test.y=1
30 }
31 static void G(){
32 a=1; //错误，不能访问this.x
33 b=1; //正确，等价于Test.y=1
34 }
35 static void Main(){
36 Test t=new Test();
37 t.a=1; //正确
38 t.b=1; //错误，不能在类的实例中访问静态成员
39 Test.a=1; //错误，不能在类问非静态成员
40 Test.y=1; //正确
41 }
42 ● 在同一类的引用
43 非 访 非=直接（可用this.X） 静 访 静=直
44 非 访 静= Test.a 静访非=创造实例=t.a
45 Test t= newTest();创造实例后用qf.F()访问< /FONT>< /FONT>
46
47 Ｃ．this 保留字在各种结构中的含义: 实例＝类的结构
48 １．(类的构造函数)值类型，对构造的对象本身的引用
49 ２．(类的方法)值类型，对调用该方法的对象的引用
50 ３．(结构的构造函数)变量类型，对构造的结构的引用
51 ４．(结构的方法)变量类型，对方法的结构的引用
52
53 Ｄ．构造函数析构函数 (作用用于执行类的实例的初始化)
54 ● 通常与类名相同
55 ● 不声明反回类型
56 ● 一般是public类型，如是private表明类不能被实例化，这通常用于只含有静态成员的类
57 ● 不要做对类的实例进行初始化以外的事情，也不要尝试显式地调用构造函数
58 intx=0,y=0,count; //不带参数的
59 public A(){
60 count=0;
61 }
62 public A(int vx.int vy){ //带参数的
63 x=vx;
64 y=vy;
65 }
66
67 Ｅ．方法
68 ● 不能与类中的成员名相同
69 ● 用abstract和extern修饰方法的执行有一个简单的分号
70 ● 执行部份通过return语句得到返回值,return后不跟任何值，反回的是void型
71 ● （非静态成员在类的每个实例中都占有一个存储（或者说具有一个副本）,
72 而静态方法是类所共享的，无法判断当前的非静态属于哪个类的实例.
73 ● 值参数，给值做一份拷贝
74 ● 引用型参数ref
75 ● 输出参数out
76 ● 数组型参数params（否则提示重载）
77
78
79
80 static int max(intx,int y){
81 if(x>y)
82 return x;
83 else
84 return y;
85 }
86 static void Main(){
87 Console.WriteLine("１０与８那个大:{0}",max(10,8));
88 }
89
90
91 Ｆ．属性
92 ● 在Ｃ＃中不直接操作类的数据内容，而是通过访问器进行访问．借助于get和set对属性的值进行读写
93 ● 只有set，只能设置不能读出
94 ● 只有get，只读不能改写
95 ● 同时具有set和get，读写都是允许的．
96 ● 除使用abstract修饰抽象属性，每个访问器的执行体中只有分号";",其它所有属性的get访问器都昌通
97 过return来读取属性的值，set访问器都通过value来设置属性的值．
98
99 public class File
100 {
101 private string s_filename;
102 public string Filename{
103 get{ //读
104 return s_filename;
105 }
106 set{ //写
107 if(s_filename!=value){
108 s_filename=value; //过通value设置属性
109 }
110 }
111 }
112 }
113 public class Test
114 {
115 public static void Main(){
116 File f=new File();
117 f.Filename="myfile.txt";
118 string s=f.Filename;
119 }
120 }
121
122
123 Ｇ．接口(interface)默认为public修饰
124 下面的例子定义了一个名为IControl的接口，接口中包含一个成员方法Paint
125 接口ITextBox和IListBox都从接口IControl中继承，承者也就继承了接口IControl的Paint方法:
126 using System;
127 interface IControl { void Paint(); }
128 interface ITextBox:IControl { void SetText(string text); }
129 interface IListBox:IControl { void SetItems(string[]items); }
130 interface IComboBox:ITextBox,IListBox{}
131
132
133 ★ 第十七章 文件操作
134 Ａ．入输出操作的类型
135 １．支持字节的读写操作 System.IO.Stream 包括
136 ● 读操作Reading
137 ● 写操作Writing
138 ● 搜索操作Seeking，有些流不支持以上的所有操作，如网络流就不支持搜索操作
139 ２．BinaryReader和BinaryWriter支持从字符串或原始数据到各种流之间的读写操作
140 ３．File和Directory类的基类都是抽象类FileSystemEntry
141 ● File对文件的基本操作，包括创建＼拷贝＼移动＼删除和打开一个文件
142 ● Directory类执行常见的各种目录操作，如创建＼移动＼游戏目录及其子目录
143 ●
144 ●
145
146
147
148
149
150 类的方法默认为受保护修饰
151
152
153
154
155
156 Main()函数的参数只有两种参数形式：无参数和string 数组表示的命令行参数，即static void Main()或static void Main(string[]args) ，后者接受命令行参数。一个C#程序中只能有一个Main()函数入口点。其他形式的参数不具有入口点语义，C#不推荐通过其他参数形式重载Main()函数，这会引起编译警告.
157 Main()函数返回值只能为void(无类型)或int(整数类型)。其他形式的返回值不具有入口点语义。
158
159
160
161 a=new 代理1(类1.方法1) //把类的一个方法赋给a
162 a(); //输出 类1 中一个方法的值
163 ------------类修饰符-------------
164 public //公有成员，不限制对该类的访问
165 protected //保护成员，只能从所在类和所在类派生的子类进行访问
166 internal //内部成员，只有其所在类才能访问
167 private //私有成员，只有对包.Net中的应用程序或库才能访问
168 abstract //抽象类，不允许建立类的实例
169 sealed //密封类，不允许被继承
170 -------------方法修饰符----------
171 new
172 public
173 protected
174 internal
175 private
176 static
177 virtual //虚方法
178 sealed
179 override //派生类中声明虚方法
180 abstract
181 extern
182 ---------------------------------
183
184
185 一、数据类型
186
187 1.整数类型
188 短字节型（sbyte）、字节型（byte）、短整型（short）、无符号短整型（ushort）、
189 整型（int）、无符号整型（uint）、长整型（long）、
190
191 2.布尔类型
192 '真'或'假' 用true和false表示
193
194 3.实数类型
195 浮点类型: 单精度（float）和双精度（double）
196 十进制类型（decimal） //定义十进制变量并赋值时,用m下标表明它是十进制类型.如省略了m下标,
197 //在被赋值前,它将被编译器当作双精度处理。如：decimal d_value=1.0m;
198 4.字符类型
199 char c='A'; //字符类型采用了国际gb2312字符集标准.一个gb2312的标准字符长度为16位.
200
201 5.结构类型
202 struct //程序设计中经常要把一组相关的信息放在一起.一系列相关的变量组织成为单一实体的过程，
203 //称为生成结构的过程.这个单一实体的类型我们就叫做结构类型,每一个变量称为结构的成员。
204 //结构类型采用struct来声明.下面代码定义一个通讯录记录结构(包括姓名、电话和地址)的定义。
205 Struct PhoneBook{
206 public string name;
207 public string phone;
208 public string address;
209 }
210 PhoneBook p1;
211 //p1就是一个通讯录（PhoneBook）结构类型的变量.声明中的public表示对结构类型成员的访问权限
212 //访问结构成员可通过结构变量名加上访问符"."号，后跟成员的名称 赋值给成员如：p1.name= "tom";</FONT>< /FONT>
213
214 6.枚举类型
215 枚举（enum）实际上是为一组在逻辑上密不可分的整数值提供便于记忆的符号。下面的程序代码声明了一个代表星期的枚举类型的变量。
216 Enum WeekDay{
217 Sunday，Monday，Tuesday，Wednesday，Friday，Saturday
218 };
219 WeekDay day;
220 注意：枚举类型的变量在某一时刻只能取枚举中某一个元素的值。如，day这个表示“星期”的枚举的变量，它的值要么是Sunday，要么是Monday或其他的星期元素，但它在一个时刻只能代表具体的某一天，不能既是星期二，又是星期三。
221 Day=Tuseday;
222 按照系统默认，枚举中的每个元素都是整型（int），且第一个元素删去的值为0，它后面的每一个连续的元素的值按加1递增。在枚举中，也可以给元素直接赋值。下面的程序代码把星期一的值设为1，其后的元素的值分别为2，3……
223 enum WeekDay{
224 Sunday=1，Monday，Tuesday，Wednesday，Friday，Saturday
225 };
226 为枚举类型的元素所赋值的值的类型限于long、int、short和byte等整数类型。
227
228
229 二、引用类型
230 引用的含义是该类型的变量不直接存储所包含的值，而是指向它所要存储的值。
231 即引用类型存储实际数据的引用值的地址。 C#中的引用类型有四种： 类 代表 数组 接口
232
233 1. 类是面向对象编程的基本单位，是一种包含数据成员、函数成员和嵌套类型的数据结构.类和结构最主要的区别在于：类是引用类型,而结构是值类型.类支持继承机制，通过继承，派生类可以扩展基类的数据成员和函数成员，进而达到代码重用和设计重用的目的。下面介绍两个经常用到的类：
234 object类：它是所有其他类型的基类，C#中的所有类型都直接或是间接地从object类中继承。因此，对一个object的变量可以赋予任何类型的值。
235 Int x=25;
236 object obj1;
237 obj1=x;
238 object obj2='A';
239 对object类型的变量声明采用object关键字，这个关键字是在.NET平台中为我们提供的预定义的名字空间System中定义的，是类System.Object的别名。
240
241
242 String类：专门用于对字符串的操作。同样，这个类也是在.NET平台中为我们提供的预定义的名字空间System中定义的，是类System.String的别名。
243 字符串在实际中应用非常的广泛，在类的定义中封装了许多内部的操作，我们只要简单地加以利用就可以了。可以用加号“+”合并两个字符串，采用下标从字符串中获取字符等。
244 String String1="Welcome";
245 string String2="Welcome"+"everyone"; /// 连接字符
246 char c=String1[0]; /// 把变量String1的第一个字符赋给c
247 boolb=(String1==String2); /// 执行布而运算,两值相等赋值True ,不等赋值False
248
249
250 2.代表
251 在C#中取消了C和C++中的指针的这个概念。而代表实际上相当于是C#中的函数指针原型，与指针不同的是，代表在C#中是类型安全的.在声明代表时，只需要指定代表指向的原型的类型，它不能有返回值，也不能带有输出类型的参数。如我们可以声明一个指向int类型函数原型的代表：
252 delegate int MyDelegate();
253 如果我们声明了自己的一个代表，那么它就是对系统定义的类System.deldgate的一个扩展。
254
255
256 3.数组
257 在进行批量处理数据的时候，我们要用到数组。数组是一组类型相同的有序数据。数组按照数组名、数据元素的类型和维数来进行描述。C#中提供Ststem.Array类是所有数组类型的基类。
258 数组的声明格式为：
259 non-array-type［dim-separators］ array-instance name;
260 比如我们声明一个整数数组：
261 int［］arr;
262 在定义数组时，可以预先指定数组元素的个数，这时在“［］”中定义数组的元素个数，它的个数可以通过数组名加圆点加“Length”获得。而在使用数组时，可以在“［］”中加入下标来取得对应的数组元素。C#中的数组元素的下标是从0开始的，以后递增。
263 在C#中数组可以是一维的也可以是多维的，同样也支持矩阵和参差不齐的数组。其中一维数组最为普遍，用得也最多。
264 Class Tese
265 {
266 static void Main（）{ //可动态生成数组的长度
267 string［］ a1; //一维数组string
268 string［］ a2; //二维数组string
269 string［］ a3; //三维数组string
270 }
271 }
272
273 4.接口
274 接口定义了一个协议（conrtact）。一个类或结构要实现接口就必须坚持这种协议。接口可以包括方法、属性、索引和事件作为成员。下面的程序代码说明了一个接口，它包含一个索引、一个事件E、一个方法F和一个属性P。
275 Interface Iexampie
276 {
277 string this［int index］{get; set;}＼
278 event EventHandler E;
279 void F（int value）;
280 string P{get; set;}
281 }
282
283
284 三、变量与常量
285 Variable //使用变量的一条重要的原则是：变量必须先定义后使用
286 变量的类型
287 在C#中，我们把变量分为七种：静态变量、非静态变量、局部变量、数组元素、值参数、引用参数和输出参数等。
288 静态变量：带有“static”修饰符声明的变量称为静态变量。一旦静态变量所属的类被装载，该类程序结束后变量的值被采放。静态变量就是该变量类型的默认值。静态变量最好是在定义时便赋值。如static a =10;
289 非静态变量：不带有“static”修饰符声明的变量称其为实例变量。如int a;类中的非静态变量，一旦一个类的新的实例被创建，直到该实例不再被应用从而所在空间被释放为止，该非静态变量将一直存在。同样鉴于定义赋值检查，一个类的非静态变量也应该是在初始化的时候赋值。
290 数组元素：数组元素也是变量的一种，该变量随该数组实例的存在而存在。每一个数组元素的初始值是该数组元素类型的默认值。同样地，鉴于定义赋值检查，数组元素最好是在初始化的时候被赋值。
291 局部变量：局部变量是指在一个独立的程序块中，一个for语句、switch语句或者using语句中声明的变量，它只在该范围内有效。当程序运行到这个范围内时，该变量即开始生效，程序离开时变量失效。与其他几种变量类型不同的是，局部变量不会自动被初始化，所以也就是没有默认值。在进行赋值检查时，局部变量被认为没有被赋值。
292 在局部变量的有效范围内，在变量的定义以前就使用是不合法的。如下面的代码：
293 for（int I=0;I<10;I++）{
294 int num=a; //这是非法的，因为局部变量a还没有被定义
295 int a;
296 int b=a;
297 }
298 有关值参数、引用参数和输出参数在这里我们不作讨论，有兴趣的读者可以参看相关的书藉。
299
300 常量声明的格式如下：
301 attributes constant-modifiers const type constant-declarators;
302 其中：常量修饰符constant-modifiers可以是：new、public、protected、internal、private。
303 常量的类型type必须是下面中的一种：
304 sbyle、byte、short、ushort、int、uint、ulong、char、float、double、decimal、bool、string或是引用类型（reference-type）。
305 常量表达式constant-declarators表示常量的名字。
306 如：public const double X=1.0，Y=2.0，Z=3.0;
307
308 四、表达式
309 1.操作符的分类
310 表达式由操作数和操作符组成。表达式的操作符指出了对操作数的操作。比如操作符有+、—、/；操作数可以是文字、域、当前变量或表达式。
311 依照操作符作用的操作数的个数来分，C#中有一元操作符：作用于一个操作数，包括前缀操作符和后缀操作符；二元操作符：作用于两个操作数，使用时在操作数中插入操作符；三元操作符：只有一个操作符“?:”。作用于三个操作数，使用时在操作数中间插入操作符。
312 下面分别给出使用操作符的例子：
313 intx=5，y=10，z;
314 x++; //后缀一元操作符
315 --x； //前缀一元操作符
316 z=x+y; //二元操作符
317 y=（X>10?0:1）; //三元操作符
318 2.操作符的优先级
319 当一个表达式包含多样操作符时，操作符的优先级控制着单个操作符求值的顺序。例如，表达式x+y*z按照x+（y*z）求值，因为“*”操作符比“+”操作符有更高的优先级。下表给出了所以操作符从高到底的优先级顺序。
320 （^60090201h^）< br> 当一个操作数出现在两个有相同优先级的操作符之间时，操作符按照出现的顺序由左至右执行。除了赋值的操作符，所有的二进制操作符都是按照从左向右的顺序执行。如x+y+z按（x+y）+z进行。<br> 赋值操作符和条件操作符（?:）按照从右向左的顺序执行。如x=y=z按照x=（y=z）进行。
321 建议：在写表达式时，如果无法确定操作符的有效顺序，则尽量采用括号来保证运算的顺序，这样也使得程序一目了然，而且自己在编程时能够思路清晰。
322
323
324 五、流程控制
325 1.条件语句
326 当程序中需要进行两个或两个以上的选择时，可以根据条件判断来选择将要执行的一组语句。C#提供的选择语句有if语句和switch语句。
327 （1）if语句
328 if语句是最常用的选择语句，它根据布尔表达式的值来判断是否执行后面的内嵌语句。其格式为：
329 if（boolean-expression）embedded-statement或
330 if（boolean-expression）embedded-statement
331 else embedded-statement
332 当布表达式的值为真时，则执行if后面的内嵌语句embedded-statement。为假时则程序继续执行。如果有else语句时，则执行else后面的内嵌语句，否则继续执行下一条语句。
333 If （x-int（x）>0.5
334 {
335 I=int（x）+1；
336 }
337 else
338 {
339 I=int（x）
340 }
341 如果if或者else之后的嵌套语句只包含一条执行语句，则嵌套部分的大括号可以省略。如果包含了两条以上的执行语句，对嵌套部分一定要加上大括号。
342 如果程序的逻辑判断关系比较复杂，通常会采用条件判断嵌套语句。If语句可以嵌套使用，即是在判断之中又有判断。具体的形式如下：
343 if（boolean-expression）
344 {
345 if（boolean-expression）
346 {……}；
347 else
348 {……};
349 ……
350 }
351 else
352 {
353 if（boolean-expression）
354 {……};
355 else
356 {……}
357 ……
358 }
359 此时应注意，每一条else与离它最近且没有其他else与之对应的if相搭配。
360 （2）Switch语句
361 if语句每次判断只能实现两条分支，如果要实现多种选择的功能，那么可以采用Switch语句。Switch语句根据一个控制表达式的值选择一个内嵌语句分支来执行。它的一般格式为：
362 switch（controlling-expression）
363 {
364 case constant-expression;
365 embedded-statements
366 default;
367 embedded-statements
368 }
369 Switch语句的控制类型，即其中控制表达式（controlling-expression）的数据类型可以是sbyle、byte、short、short、uint、long、ulong、char、string或是枚举类型（rnum-type）。每个case标签中的常量表达式（constant-expression）必须属于或能隐式转换成控制类型。如果有两个或两个以上case标签中的常量表达式值相同，编译时将报错。Switch语句中最多只能有一个default标签。
370 下面的程序代码说明Swtich语句按所提供参数的数字执行不同的语句。
371 using system;
372 class Test
373 {
374 static void Main （string［］ args） {
375 switch （args.Length） {
376 case 0;
377 Console.WriteLine （"No arguments were provided"）;
378 break;
379 case 1;
380 Console.WriteLine （"One arguments was provided"）;
381 break;
382 default;
383 Console.WriteLine （"{0} arguments were provided"）;
384 break;
385 }
386 }
387 }
388 2.循环语句
389 循环语句可以实现一个程序模块的重复执行，它对于我们简化程序，更好地组织算法有着重要的意义。C#提供了四种循环语句：While语句、do-while语句、for语句、foreach语句。
390 （1）While语句
391 While语句有条件地将内嵌语句执行0遍或若干遍。其格式为：
392 while （boolean-expression） embedded-statement
393 其执行的顺序是：
394 首先计算表达式boolean-expression的值；当布尔表达式的值为真时，执行语句embedded-statement一遍，程序转至第1步；当布尔表达式的值为假时，while循环结束。
395 （2）do-while语句
396 do-while语句与while语句不同的是，它将内嵌语句执行一次（至少一次）或若干次。其格式为：
397 do embedded-statement while（boolean-expression）
398 其执行的顺序是：
399 首先执行内嵌语句embedded-statement一遍；当布尔表达式的值为真时则回到第1步，为假时则终止do循环。
400 在do-while循环语句中同样允许用break语句和continue语句实现与while语句中相同的功能。
401 （3）for语句
402 for语句是C#中使用频率最高的循环语句。在事先知道循环次数的情况下，使用for语句是比较方便的。其格式为：
403 for（inttializer，condinton;iterator）embedded-statement
404 其中inttializer、condinton、iterator三项是可选项。Inttializer为循环控制变量做初始化，循环控制变量可以有一个或多个（用逗号隔开）；condinton为循环控制条件，也可以有一个或多个语句；iterator按规律改变控制变量的值。
405 其执行的顺序是：
406 首先按照书写顺序将inttializer部分（如果有）执行一遍，为循环控制变量赋初值；然后测试condinton（如果有）中的条件是否满足；若没有condinton项或条件满足，则执行内嵌语句一遍，按iterator改变循环控制变量的值，回到第2步执行；若条件不满足，则for循环终止。
407 下面的程序代码说明用一个for语句写出整数1～10。
408 Using System;
409 class Test
410 {
411 static void Main（）{
412 for （int I=0; I<10; I++）
413 Console.WriteLine（I）;
414 }
415 }
416 （4）foreach语句
417 foreach语句是在C#中新引入的。它表示收集一个集合中的各元素，并针对各个元素执行内嵌语句。其格式为：
418 foreach（type identifier in expression）embedded-statement
419 其中类型（type）和标识符（identifier）用来声明循环变量，表达式（expression）对应集合。每执行一次内嵌语句，循环变量就依次取集合中的一个元素代入其中。在这里，循环变量只是一个只读型局部变量，如果试图改变它的值或将它作为一个ref或out类型的参数传递时，都将引发编译出错。
420 Foreach语句中的expression必须是集合类型，如果该集合的元素类型与循环变量类型不一样，则必须有一个显示定义的从集合中的元素类型到循环变量元素类型的显示转换。
421 下面的程序代码说明用一个foreach语句来循环显示列表中的元素。
422 Using System;
423 using System.Collections;
424 class Tese
425 {
426 static void WriteList（Arraylist list）{
427 foreach（object o in list）
428 Console.WriteLine（o）;
429 }
430 static void Main（）{
431 ArrayList list=new ArrayList（）;
432 for（int I=0; I<10; I++）
433 list.Add（I）;
434 WriteList（list）;
435 }
436 }
437 3.转子语句
438 （1）break语句和continue语句
439 break语句用来退出最近的switch、while、do、for、foreach语句的循环，而continue语句用来开始一个新的while、do、for和foreach语句的循环。
440 （2）标签声明和goto声明
441 标签声明可以交替声明，goto声明可以把控制传送到标签声明。
442 （3）return语句
443 返回对语句中的成员控制。无表达式的return语句只能在无返回值的成员中应用。带表达式的return语句只能在返回表达式的函数成员中运用。
444 （4）throw语句与try语句
445 throw语句用来抛出异常。Try语句提供一个在程序块执行过程中捕获异常的机制。此外，try语句还提供当try语句脱离控制时总是要执行的代码块。
446 （五）异常处理
447 程序中对异常的处理能使你的程序更加强壮。现在的许多程序设计语言都增加了异常处理的能力，C#也不例外。
448 1.异常处理语句
449 C#中的异常处理语句有三种形式：try-catch 捕捉异常、try-finally 清除异常、try-catch-finally 处理所有异常。
450 下面的一段代码处理溢出异常：
451 try{
452 for（;n<=max;n++）
453 sum*=n;
454 }
455 catch（OverfolwException oe）
456 {
457 Console.WriteLine（“溢出“）;
458 return;
459 }
460 2.清除异常
461 try-finally 结构将清除异常。看下面的代码：
462 try{
463 for（;n<=max;n++）
464 sum*=n;
465 }
466 finally
467 {
468 Console.WriteLine（“溢出“）;
469 return;
470 }
471 上面的代码中finally 子句中的代码在任何情况下总会被执行，即使没有异常发生。
472 3.处理所有异常
473 try-catch-finally 处理所有的异常。如下面的代码：
474 try{
475 for（;n<=max;n++）
476 sum*=n;
477 }
478 catch（OverfolwException oe）
479 {
480 Console.WriteLine（“溢出“）;
481 return;
482 }
483 catch（Exception e）
484 {
485 //捕捉所有异常
486 }
487 finally
488 {
489 }
490 4.抛出异常
491 程序中我们可以先抛出异常，然后进行捕捉。
492 抛出异常的语法如下：
493 throw new Exception（）
需求分析还是没怎么看懂。一共分为七个模块，每个模块都有具体要实现的功能，其中第一个，第二个，还有第五个需要实现的界面较多，需要仔细研究一下