初探c#--8,9,10

韩冰

1。8 类（Classes）
类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
! E+ m9 N) a5 u+ E0 l4 p对类中得所有成员有五种访问权限：
·  “public” 可以被所有代码访问；
1 J' U4 [$ p6 s& \  K4 t2 G, Y·  “protected” 只可以被继承类访问；
·  “internal” 只可以被同一个项目的代码访问;
9 d9 P; ^2 M: V& g·  “protected internal”只可以被同一个项目的代码或继承类访问；
·  “private” 只可以被本类中的代码访问。
* l5 P% W! V' C+ r3 J" p# c; W* F! \缺省状态是“private”。

8 k& `8 e0 M* Q6 F1。9 结构（Structs）
5 w8 t- O! H% R( ~* W' W结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
+ E, r. x9 m5 E; d7 }: f# N$ L/ g存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
% _( t9 Y9 m/ ?; {: c) ]5 a个points。在类“Point”中需要分配101个独立的对象（object）。*/

class Point
{
public int x, y;
public Point() {
6 w( Y' t  Y9 X4 ]x = 0;
. ?5 W' m( I8 _y = 0;
}
public Point(int x, int y) {
this.x = x;
$ a2 l/ C& ?4 m0 K1 I' Lthis.y = y;
}
9 A+ V9 z/ s$ @+ i; P1 d}
class Test
{
4 @$ Q$ t& L. P# {5 v% mstatic void Main() {
Point[] points = new Point[100];
4 D5 X& ~6 N, I- e6 B7 i( Nfor (int i = 0; i < 100; i++)
' C) z) E( J3 S2 }! P8 `' cpoints = new Point(i, i*i);
}
}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
) g" s. o4 P' b/ c1 u2 fstruct Point
{
0 n. _! G/ [9 c6 ~public int x, y;
' @# N- e4 z9 h; w3 xpublic Point(int x, int y) {
' D5 N9 t: C4 C3 ^this.x = x;
0 ]& s0 w' o9 [3 pthis.y = y;
}
) j. F! V  l: \/ o: Q}
/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
8 Q' u2 h3 o3 x  W0 X" ]4 X6 ?时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
# Q# g; f' {# u0 d2 t4 s了 ^_^ ）。

0 W% @. ]( \; J- j! B1。10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
5 a' |( {/ M# y* c( J
interface IExample
* a; V) e9 N4 p# V, T) M{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
. n% s4 X( x! Z9 bstring P { get; set; }
}
public delegate void EventHandler(object sender, Event e);
3 A9 H7 V  }0 s, P$ i" V/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
. M5 M1 X2 g) Q# S9 `! u界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
: q- p' \/ u% |1 {*/
" d% h- q1 ~7 m( A% kinterface IControl
{
void Paint();
* \7 D' |. K3 ?5 {6 C}
/ D9 q" y6 a& Iinterface ITextBox: IControl
{
void SetText(string text);
}
7 Q& P* ^. C; A* _7 O) ~$ S; Hinterface IListBox: IControl
' B1 S. A  c6 ]& K# S. P{
void SetItems(string[] items);
}
2 G) l. h6 R. t1 b6 U; Ainterface IComboBox: ITextBox, IListBox {}
/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
) A/ p3 R9 u4 v4 Y# @9 A" d和“IControl”继承。
, |' t1 j  P3 c: y" f# r*/
interface IDataBound
{
% F- I. e$ n  \2 r( n4 ]( rvoid Bind(Binder b);
2 ]8 k9 ]- a7 B1 M# j% F}
public class EditBox: Control, IControl, IDataBound
2 Y) Z; @0 k( ]. t0 E2 U" y{
public void Paint();
public void Bind(Binder b) {...}
7 z; O2 M  J5 ?% J}
  v/ M+ Y& j$ I0 V/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
1 e$ T+ `- W: V3 O以“public”的身份在“EditBox”类中实现。