初探c#--8,9,10

韩冰

1。8 类（Classes）
0 W" i% ~+ F5 r  [4 e) o5 L类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
4 v; V" t1 ?: @·  “public” 可以被所有代码访问；
: i6 R: k1 G; n* q·  “protected” 只可以被继承类访问；
·  “internal” 只可以被同一个项目的代码访问;
" t2 s$ e. o" ~1 @! Q7 Q* x·  “protected internal”只可以被同一个项目的代码或继承类访问；
' C$ J$ E3 E& p$ v·  “private” 只可以被本类中的代码访问。
缺省状态是“private”。
( R8 G& r6 S# C$ w  T5 f
) J% g3 j8 L6 D" @" F9 @1。9 结构（Structs）
5 z6 W3 d  n7 b( c结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
7 H" {# O9 {9 Y6 B) h4 k别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
" H& N6 E; P6 j: A5 m( p存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
$ R, a% v) _4 d7 C. r个points。在类“Point”中需要分配101个独立的对象（object）。*/
3 E, i' {2 ^7 }4 X
6 I0 V- V4 g; N$ `class Point
/ l, |1 H7 W3 j$ g: P4 t{
  T8 A! V5 I1 {' [public int x, y;
, u/ ^: B8 K  z# B, |public Point() {
x = 0;
  G/ i) r4 [. Z: C$ w0 l( Ry = 0;
2 v1 p+ w  G9 u}
% I/ i* l8 j' d0 F8 Spublic Point(int x, int y) {
4 P/ Y; \; U9 q  {. a1 nthis.x = x;
this.y = y;
8 p1 [& {7 ~' I2 P0 |: I1 c}
}
class Test
0 n1 R* J( Q1 I+ M# h{
: \9 C4 n* y& [+ |* ]. {static void Main() {
( I2 g% h: J6 APoint[] points = new Point[100];
' |7 {( X  b1 jfor (int i = 0; i < 100; i++)
points = new Point(i, i*i);
}
}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
9 Z) T9 `8 Z4 z& X' rstruct Point
2 {" y" T- _( @1 C0 h{
public int x, y;
( x6 E  T& B5 e8 ?. c& Apublic Point(int x, int y) {
this.x = x;
  y- y  J! j/ }: Wthis.y = y;
}
/ O. L0 K! L8 n; H4 Y) c1 S}
/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
; p: F, L; I2 A# N0 P  o" t/ S时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
了 ^_^ ）。

1。10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
2 [' t, z* x8 |: |/ T, a/ F
interface IExample
$ W( j- k% w+ e{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
string P { get; set; }
! ?2 t$ @/ @5 g/ p}
public delegate void EventHandler(object sender, Event e);
/*
. a! ^$ ^* M; ^$ J例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
*/
interface IControl
7 J% c; w  t  \* f  G{
void Paint();
}
( ~2 P, L. A  jinterface ITextBox: IControl
{
void SetText(string text);
}
% l3 X9 ^# N% Z) Q9 g0 z' D! ^interface IListBox: IControl
: G  V' [- H: w+ d0 U; s0 R+ R{
void SetItems(string[] items);
4 E- j; [1 V8 t/ {3 k: r' t; ]}
interface IComboBox: ITextBox, IListBox {}
/*
7 Z. F) ^3 K: d# f类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
: }$ G% J$ r+ `( s# _! M和“IControl”继承。
! w! t& Q9 O1 a5 J$ F4 }3 q*/
* e; [8 G1 e3 b. _6 j8 ]/ v7 }interface IDataBound
{
void Bind(Binder b);
}
8 v6 v) a8 ~$ y- z( d. ^public class EditBox: Control, IControl, IDataBound
{
3 \) C' X+ `% d" k# opublic void Paint();
/ S2 P! \# F: C. O2 }- Z- H  u4 X; Ppublic void Bind(Binder b) {...}
}
& \7 T8 z% r1 {! s# O& \$ _/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
以“public”的身份在“EditBox”类中实现。