初探c#--8,9,10

韩冰

1。8 类（Classes）
* S# L0 }+ Q1 E4 U* i类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
' P" T  K( `: ^  ~* U* [: x类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
0 R* R0 l$ a/ B类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
·  “public” 可以被所有代码访问；
  ~8 f/ b' D# s1 ^2 ?·  “protected” 只可以被继承类访问；
·  “internal” 只可以被同一个项目的代码访问;
; m4 i& S0 R7 U, ~·  “protected internal”只可以被同一个项目的代码或继承类访问；
# Y. c, @$ t7 f2 I·  “private” 只可以被本类中的代码访问。
缺省状态是“private”。

2 ?( Y- w& E" Y1。9 结构（Structs）
( `  r/ y" @% [2 R+ b结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
& ~# a5 u- L" o4 }2 I' [个points。在类“Point”中需要分配101个独立的对象（object）。*/
. q5 J$ }9 N3 l. [# Q
) l0 D' n% c2 C. eclass Point
{
public int x, y;
5 b- S( j7 Q1 s  D- u) y+ o) ~' Fpublic Point() {
7 R6 S# d7 H9 P0 j/ h8 a# N. Ux = 0;
y = 0;
}
public Point(int x, int y) {
0 g0 b# n( F5 l8 U0 c, ~! Kthis.x = x;
this.y = y;
" C, u$ @# H0 L" _' y+ h" b}
8 e; e2 @. y. Z) [' ?, ^8 f}
class Test
, O" I$ N+ F. Y' t$ Y{
static void Main() {
  Q: V3 d4 w5 D# |: bPoint[] points = new Point[100];
7 V0 s/ c: ]) R1 E0 o; G* [for (int i = 0; i < 100; i++)
points = new Point(i, i*i);
}
}
/*
2 g* ]% a( D9 t# H* r如果“Point”被作为一个结构，就可以这样啦：*/
, r* i9 ?8 @& s! i/ D0 m& ]struct Point
{
) H2 O. L: H$ T/ J& A) F1 p! Ppublic int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
3 R% S, I- Y. e* M& w时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
# I2 p+ g! `6 G4 D# o了 ^_^ ）。

1。10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
9 Q5 v, F4 U' A6 d7 }6 H) Y1 H
( J& v! ^6 X# p, minterface IExample
. h) |0 `3 l7 y8 a7 F, e9 r5 o{
string this[int index] { get; set; }
, \0 {! p  J) k4 P- J( Aevent EventHandler E;
void F(int value);
3 ?& r- e8 q) _' i. kstring P { get; set; }
" P1 q0 R* |2 w. S7 b}
public delegate void EventHandler(object sender, Event e);
/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
0 T# H  W& [$ `- `6 ~' {界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
*/
4 j4 ]0 u5 A* f8 F# x$ ?. dinterface IControl
{
" M* m7 T& {" fvoid Paint();
( i) W' T9 D9 v! C! {}
* k9 g9 K$ v2 Cinterface ITextBox: IControl
, i4 p- w, E$ M{
8 Y4 K! r3 A# Nvoid SetText(string text);
}
interface IListBox: IControl
2 z6 R! E7 C. K5 [3 {# d1 r9 s{
void SetItems(string[] items);
8 P. U! f% K7 |+ F2 R# ^}
0 f- j: ], O* b6 yinterface IComboBox: ITextBox, IListBox {}
/*
3 [8 S* J2 h* w; N类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
和“IControl”继承。
! P% Z( c% Z. ^& h! n*/
# S5 ]  ~& E, N. M# K* h2 q9 g- xinterface IDataBound
# E, q7 s3 f6 }{
  p- e0 W$ E; b9 r. G8 Y6 a& ~void Bind(Binder b);
) U1 h& E2 o- i( }$ p) ?; {}
public class EditBox: Control, IControl, IDataBound
{
public void Paint();
public void Bind(Binder b) {...}
}
% _) q6 U  T+ h1 P  H/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
4 ]& i' A$ o6 b以“public”的身份在“EditBox”类中实现。