初探c#--8,9,10

韩冰

1。8 类（Classes）
" E( }& x! O* V1 E- z3 S" `1 \! [类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
& B, ^+ ]  H* X; V0 b. K  @  x·  “public” 可以被所有代码访问；
7 ]2 F# P4 S+ i* O. F·  “protected” 只可以被继承类访问；
3 Q) r- e' U0 _# \7 F  \. O$ V·  “internal” 只可以被同一个项目的代码访问;
6 g1 e8 H0 b2 \3 e) [! n; ?' a0 }·  “protected internal”只可以被同一个项目的代码或继承类访问；
·  “private” 只可以被本类中的代码访问。
1 `: T  P- G2 r缺省状态是“private”。

: `& S) W" q) z" {, [1。9 结构（Structs）
结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
! Z' ?  F( p0 I存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
& G1 Q& ?3 f+ x/ n# W6 c个points。在类“Point”中需要分配101个独立的对象（object）。*/

" M; d) T  [2 I0 a; E3 Lclass Point
{
/ p: b  a( V% U& O4 h' G, epublic int x, y;
public Point() {
x = 0;
9 A. e  z; m7 E- n6 S! ~y = 0;
  S7 }, ~! I# W% ?}
; L6 O! z; A- c& b) Z) k7 n; x0 @7 bpublic Point(int x, int y) {
( X) p# f* g/ \; _2 [# Hthis.x = x;
this.y = y;
}
) m2 W2 |. m' }2 s2 }}
" U: z4 ~( ?& O" m$ wclass Test
/ t; z: x5 c9 [( N{
static void Main() {
Point[] points = new Point[100];
: j6 D5 D# C, \for (int i = 0; i < 100; i++)
points = new Point(i, i*i);
. r6 g3 K! a; T}
0 o. j; f- @3 j6 i3 x5 g}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
! E8 }2 q' J7 z; m{
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
+ u" D3 ?4 g! \) g}
}
/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
0 _% W7 l2 S( k% f5 L所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
了 ^_^ ）。

  s3 ^% s" O2 ^4 E. B0 @1 W/ p/ z- l1 o1 G1。10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
! Q+ H; a& z  t- v" W/ k类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/

: f( L0 Q$ K  Qinterface IExample
{
9 q3 g* `! h* ~! _3 `  R6 estring this[int index] { get; set; }
event EventHandler E;
) S. O; R' c6 |void F(int value);
string P { get; set; }
}
public delegate void EventHandler(object sender, Event e);
. q2 e  {  E2 |/*
) A* g9 q' q. S( u- V例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
9 b0 f0 H" E9 j1 S8 L界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
7 {* i7 q0 d0 n9 J% @( [) w2 n*/
interface IControl
{
$ f2 I8 E# C" X+ M6 w# K) G% cvoid Paint();
}
. m5 U$ C0 o! I4 R3 F" C4 X0 Qinterface ITextBox: IControl
{
- `& t3 A4 [0 kvoid SetText(string text);
7 \1 o0 ]2 j, `; S+ U. h! I}
4 Y6 N4 H! `& r3 O/ D  t3 Dinterface IListBox: IControl
9 W8 `$ N5 j: m{
& H- i, b5 |. g. n6 Y# fvoid SetItems(string[] items);
1 S9 k/ `& p3 n3 K% M! D3 m! {}
; r% i1 b6 {5 D' F. q  Uinterface IComboBox: ITextBox, IListBox {}
/*
+ ?4 F- l! \* |& \; O类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
2 ^+ Q, `$ ~$ a" @$ _& N7 d和“IControl”继承。
& x9 h3 F1 Q* l, ]- r) A4 L*/
% \; Z: K3 w. i0 Iinterface IDataBound
{
+ D  @$ [% N  p: Q& O$ Yvoid Bind(Binder b);
5 V  u8 k, ]! @+ D2 e* B}
public class EditBox: Control, IControl, IDataBound
{
  n, [1 ~% V! n% F$ `; y8 }public void Paint();
! q0 E, b4 T9 q5 @9 S; Xpublic void Bind(Binder b) {...}
}
/ l% e# k" w; g/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
以“public”的身份在“EditBox”类中实现。