初探c#--8,9,10

韩冰

1。8 类（Classes）
类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
" l. ~" @7 x" f. S. e+ _类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
5 ?% U. e2 ~6 T3 c5 m3 V8 U类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
·  “public” 可以被所有代码访问；
9 `" T' p) O$ M/ T7 s, B·  “protected” 只可以被继承类访问；
# Q/ V  x5 ^3 z5 g·  “internal” 只可以被同一个项目的代码访问;
·  “protected internal”只可以被同一个项目的代码或继承类访问；
·  “private” 只可以被本类中的代码访问。
/ I( @- J: v9 k$ U$ }缺省状态是“private”。

1。9 结构（Structs）
结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
8 E' x, _4 ?& J. v8 T% ]+ C  x别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
- C6 O( o* A6 b& c个points。在类“Point”中需要分配101个独立的对象（object）。*/

class Point
4 G) c2 P" E9 L! w{
public int x, y;
+ g9 n& _9 _7 A* N& Ypublic Point() {
. e1 j- K0 N$ sx = 0;
7 \3 Q0 i. ^& |4 H$ @y = 0;
# \$ b! M) L/ I* D}
  R+ p$ q& K0 `! tpublic Point(int x, int y) {
this.x = x;
0 g% ^4 _. _" n$ h& s$ I6 |this.y = y;
}
}
class Test
{
, \) w2 b! j# K7 |7 ^static void Main() {
, \0 i0 P0 G  X9 a  O; @Point[] points = new Point[100];
for (int i = 0; i < 100; i++)
! H' g+ j7 a: T/ Z+ L7 _% opoints = new Point(i, i*i);
7 V7 z9 x# E9 w/ v}
}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
{
% z4 S3 Z- I9 Cpublic int x, y;
public Point(int x, int y) {
this.x = x;
$ r7 W( o2 @! Cthis.y = y;
}
& N8 `5 l" ^# J) e6 `. {/ l" ~}
7 n5 A. f5 F" j3 g+ d) S/*
, l% n5 r. W& t, u8 F3 ^2 o因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
. \) n2 f: ^; b8 y$ w时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
了 ^_^ ）。
; c  B1 `" l! I, P1 F" c
9 w4 g: g7 W9 X1 f: V1。10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
6 j6 X: G$ e" \6 z# v  e( c. [& o类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/

interface IExample
{
string this[int index] { get; set; }
: z' _2 s. u8 j2 S; Fevent EventHandler E;
! f. W) g% t. v8 F# n$ Hvoid F(int value);
7 x, J0 G9 u. ustring P { get; set; }
}
: D! Z9 k# f# x5 J/ b9 spublic delegate void EventHandler(object sender, Event e);
/*
( E5 h& I# d* Z4 |4 z例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
0 J- ~0 G) @% Q2 I界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
+ n  p+ j1 w7 Z8 m8 m4 {*/
interface IControl
# `# J. _6 h5 S0 `. S{
void Paint();
& b8 e" Y+ U& F# f}
' S" u1 N! Q& ^* Ninterface ITextBox: IControl
6 {& u/ F. [9 E0 s  O8 C" P3 D{
void SetText(string text);
9 Z# V+ \9 X6 h$ a, e) Q* q}
interface IListBox: IControl
- ], N1 r2 B1 ~/ @  |1 r{
void SetItems(string[] items);
1 l8 p1 b5 x% p1 v0 _' C}
interface IComboBox: ITextBox, IListBox {}
2 ^+ P- e, D) b7 F9 b# |. t% l/*
, q' g; u6 N5 p# `0 U类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
和“IControl”继承。
3 N5 l, B: a! b" o*/
interface IDataBound
4 o% G+ R/ D/ T) t7 G) q0 w, ?3 h{
- J  Z1 Y3 t5 ~/ s  R$ xvoid Bind(Binder b);
}
public class EditBox: Control, IControl, IDataBound
1 T" W6 X% n. p  L{
1 c1 H* |" `' Z6 ]" V, Epublic void Paint();
public void Bind(Binder b) {...}
}
- [: Y- P0 Y1 X2 @/*
7 ]' `/ G# a- F" w在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
以“public”的身份在“EditBox”类中实现。