初探c#--8,9,10

韩冰

1。8 类（Classes）
) _- s: {& k6 D) s3 O' r; o% k类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
- h/ T' A5 |. _3 e% b类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
2 W3 B" ~. z/ P% a% s- O·  “public” 可以被所有代码访问；
·  “protected” 只可以被继承类访问；
) k+ T: h( b1 ?·  “internal” 只可以被同一个项目的代码访问;
. C# P  }; e( P1 ?·  “protected internal”只可以被同一个项目的代码或继承类访问；
·  “private” 只可以被本类中的代码访问。
3 I: V# W: k, U0 H, y缺省状态是“private”。

1。9 结构（Structs）
结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
! u: s/ {' J) D2 \1 w4 I别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
, ?. S( v5 M2 L存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
个points。在类“Point”中需要分配101个独立的对象（object）。*/
, \% I( |# a2 c5 j6 x5 _" B
1 h9 b1 x2 e2 h  V* h# e4 R  Kclass Point
{
1 A; }  n1 a* J( C  ?  Zpublic int x, y;
public Point() {
x = 0;
y = 0;
}
public Point(int x, int y) {
, a9 @) P* p% A6 \this.x = x;
this.y = y;
}
}
# p2 S5 E+ l) q/ t  o0 Q+ x1 ?class Test
{
. M, Q% F+ x. wstatic void Main() {
  J% b& ?' L& V% yPoint[] points = new Point[100];
; G: Z: O/ N4 Y* |2 }for (int i = 0; i < 100; i++)
- M, o" F1 d2 npoints = new Point(i, i*i);
}
$ C' e# |& ~" O  o( ^  n/ }6 G}
4 z) M4 T1 b3 x/*
5 e9 K, @- w% F' D0 \如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
{
public int x, y;
  T) t$ A! ]3 q6 |public Point(int x, int y) {
this.x = x;
1 s5 h* r9 v* j: h" kthis.y = y;
, A, e1 c1 \- x% R& o6 g7 I% V}
}
/*
. j( P: a7 V! m% [6 i, \. d因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
8 Q* {3 s6 t$ ~. i时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
. ~1 W8 ?* g" W( E* q$ X了 ^_^ ）。

1。10 界面（Interfaces）
, [' h0 X8 J. |5 \- s+ G9 j界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
& g# N: O2 _& {5 K; w
' d0 f% L+ n5 i; winterface IExample
{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
string P { get; set; }
8 a7 F; q! w' Q7 w" n) \}
public delegate void EventHandler(object sender, Event e);
/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
*/
6 h' i2 ?( c' X$ K. rinterface IControl
6 l# P" {4 k6 m{
void Paint();
}
, z6 E1 @; I! ?$ r3 R) vinterface ITextBox: IControl
{
% M6 J3 |  M$ G8 rvoid SetText(string text);
# m5 F' R/ g" d! H* X- T}
# Z) }; S% v% K8 X# Y, [interface IListBox: IControl
{
void SetItems(string[] items);
  |$ ~9 t8 I. l* ^9 a( ~: ?. L& Q% H}
interface IComboBox: ITextBox, IListBox {}
/ J" x6 E8 N( Z/*
0 ^* d" X3 s! i8 G. N) i& {5 C类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
( z9 c" y% C2 M% f% S( O" e和“IControl”继承。
*/
, J; v' m+ [- k2 s8 T9 linterface IDataBound
{
void Bind(Binder b);
. d+ N( f; V) G1 G7 h}
, p: Y, {. \( u: Z2 G5 `3 T, P2 _- Ipublic class EditBox: Control, IControl, IDataBound
& a) [! C. b4 _{
public void Paint();
4 U. u/ X9 x9 L  Y; o7 k: n9 }3 Npublic void Bind(Binder b) {...}
}
+ }: F2 F7 E* g/ V: Y2 {/ U. K/ d2 L  S/*
, q3 o. N" r8 k* ^在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
+ I3 F7 H% t* g* L7 e& T+ X以“public”的身份在“EditBox”类中实现。