初探c#--8,9,10

韩冰

1。8 类（Classes）
$ W2 O# V- a) F. O, o类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
8 l2 }0 y* y' A3 K: B* g/ e$ x类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
$ [) j5 p! C  _$ \·  “public” 可以被所有代码访问；
·  “protected” 只可以被继承类访问；
! }4 z- W" N  A4 i·  “internal” 只可以被同一个项目的代码访问;
* d; K" ?' H9 E9 l$ R/ E. c·  “protected internal”只可以被同一个项目的代码或继承类访问；
·  “private” 只可以被本类中的代码访问。
缺省状态是“private”。

1。9 结构（Structs）
5 f# T0 {- M/ `9 N结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
$ ?3 K8 b3 m3 v7 V/ H& n* W4 L别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
5 G" J' H3 \& L3 I5 V$ G存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
个points。在类“Point”中需要分配101个独立的对象（object）。*/
; F# p% `% u- w% M( f
class Point
{
, w6 G# w! e5 Xpublic int x, y;
public Point() {
6 o1 d8 E7 {9 y1 y+ M  Ix = 0;
  [6 @9 |, m/ ^& Y$ r, N* |y = 0;
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
; I7 @. u( ^& u- E2 xclass Test
) b" q/ U, B2 r6 ?; C{
static void Main() {
# Q" B! H1 L1 ePoint[] points = new Point[100];
; X( `8 ~# u& R" g8 Hfor (int i = 0; i < 100; i++)
points = new Point(i, i*i);
0 M& r& Z6 T$ N* a: `/ `, Y1 ~}
}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
9 |/ B0 p; @+ }3 rstruct Point
{
4 b/ p' N! r, ], z8 u4 Ipublic int x, y;
public Point(int x, int y) {
9 d- i# f& {" E  ^6 _this.x = x;
; L4 Q8 t& r- l: R  A# _, xthis.y = y;
}
3 S, C* \# C6 l' W% q" k}
6 D+ V* w) x( x" m( L/*
; v) U6 g+ A  {- w7 N8 w0 [+ u因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
% _( e, n2 q) P$ h6 ?: Y所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
了 ^_^ ）。
' B0 n" o! ]9 a# F3 K4 c
1。10 界面（Interfaces）
8 O" l! J0 H6 {8 ^# `界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
5 t1 g& n. c* a; r- q
7 \$ Y. R2 ]1 G- ~4 Jinterface IExample
{
string this[int index] { get; set; }
& V! G3 k0 g5 E. Qevent EventHandler E;
, ?& ~  _' z8 h- _+ Wvoid F(int value);
/ o/ k" W+ r. ~- zstring P { get; set; }
" R$ Y0 J% Y+ w0 q% h}
public delegate void EventHandler(object sender, Event e);
/*
5 A$ F3 i- ?, I# s! ?+ D例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
*/
0 f$ L1 b6 L& m0 cinterface IControl
{
7 {: U" F% P$ I# B; ]void Paint();
9 i2 ~0 m4 j  k) t}
  L7 e) S  R8 Sinterface ITextBox: IControl
* j. {! j7 R0 z! n1 \2 K& T{
void SetText(string text);
}
3 ^' Z- }1 G: w1 G" xinterface IListBox: IControl
9 M- h/ L9 s' Q{
: }, W. D8 b/ D5 n3 `$ i4 N# mvoid SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}
+ m4 i" q( b# a1 P  I& E; Z/*
2 q# Y5 X5 O' B0 n  K类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
和“IControl”继承。
; T; g' q9 H# C2 r, A*/
  q; Z9 j# T, O$ ointerface IDataBound
( W2 Y+ B; K; T  A, M1 W% ?! ]{
! V& c$ T% R) f7 J) O# ^8 ~$ Uvoid Bind(Binder b);
}
public class EditBox: Control, IControl, IDataBound
{
7 i6 N' x* ?% e, O! O  u& Zpublic void Paint();
1 k% p$ f) [  V& F9 {$ Spublic void Bind(Binder b) {...}
7 x1 J/ ~1 ~; V( }, k2 p% z}
1 q, {, b  G4 T$ }/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
$ P' h! T# l7 J. ^: [8 A. N以“public”的身份在“EditBox”类中实现。