初探c#--8,9,10

韩冰

1。8 类（Classes）
( h$ n9 u* Q& y* M4 u5 s类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
·  “public” 可以被所有代码访问；
·  “protected” 只可以被继承类访问；
- w8 R! x: g) W$ Y0 Q$ `. g. f·  “internal” 只可以被同一个项目的代码访问;
·  “protected internal”只可以被同一个项目的代码或继承类访问；
; o4 a5 \9 t0 t1 z·  “private” 只可以被本类中的代码访问。
缺省状态是“private”。

1。9 结构（Structs）
结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
( ?8 H$ s5 ]. Q6 W+ j; S别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
2 ^+ e0 \8 D  M* d% e, D$ z, V个points。在类“Point”中需要分配101个独立的对象（object）。*/

1 I3 o, p6 J3 P4 R: w5 aclass Point
& v0 E- z# O. j: N{
  |3 h; g5 e5 S  C& G1 ipublic int x, y;
0 O4 R( O- _/ W1 x) L/ O- I. @8 A! Epublic Point() {
1 T  a2 ^  ?5 _0 ?x = 0;
y = 0;
}
. H2 J- _8 N4 [public Point(int x, int y) {
this.x = x;
# w, A" |# k, M. s8 B, Ethis.y = y;
- m  t$ V% t& K+ p4 f( V% N; g}
}
class Test
{
: v  X2 O) s9 @6 Y, e  m/ F) Pstatic void Main() {
3 G; _$ R8 ^: xPoint[] points = new Point[100];
8 m( O9 T( D# yfor (int i = 0; i < 100; i++)
/ l& C+ {$ X9 {: Gpoints = new Point(i, i*i);
}
}
7 K" e0 R$ \# q( |/*
如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
{
public int x, y;
public Point(int x, int y) {
1 }2 P0 m1 J/ [  g  B( F) h  S, X6 dthis.x = x;
3 g) |3 q. B3 @: w3 _/ u# qthis.y = y;
8 f) V  a1 F5 W& `/ ^}
/ H7 x* R: P6 T0 M' h8 A}
/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
$ Q: n/ ?4 @1 d" h4 r* U; W时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
' n: Y1 w  R7 ?- G1 i' ^: `所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
  G; I) g4 b3 M- Q3 h" z8 E了 ^_^ ）。
1 y7 E, t( H  C0 ~& X# v
1。10 界面（Interfaces）
$ u. {- w3 L: [1 |界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
& ]+ z% Z) B; j4 S& A
interface IExample
9 S; n# }  h4 r& X1 w{
) e8 _" @5 H$ C9 rstring this[int index] { get; set; }
6 C( b9 w0 |6 F# fevent EventHandler E;
void F(int value);
. j/ T& l, q! R1 \# D; h2 m( Bstring P { get; set; }
}
public delegate void EventHandler(object sender, Event e);
. ~5 J! w9 n& t3 a3 K* I: G# C) b/*
0 d. ^6 s+ P" B% r  T例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
# b5 I# o6 n" ]! [- e*/
interface IControl
8 i. t! x" W" d2 K- Q4 c{
void Paint();
}
  M& t" h' Y" w9 }9 }interface ITextBox: IControl
2 I) d8 x& @# h2 F+ ~3 ^{
& g- C  g; J  C4 Lvoid SetText(string text);
}
/ x4 u& \9 g3 Uinterface IListBox: IControl
; G2 c( W& C5 B$ G9 A4 z" Q{
5 L7 S3 ~5 a, \0 U$ Ovoid SetItems(string[] items);
1 [/ x5 R& ~( \  I# H1 g}
5 w# S- E# h1 T& v/ p% v( y, p! x$ dinterface IComboBox: ITextBox, IListBox {}
. r3 \9 v0 i' q2 x" d/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
和“IControl”继承。
! A, l; [5 d* h/ _: [0 [7 ]; V*/
interface IDataBound
{
void Bind(Binder b);
}
public class EditBox: Control, IControl, IDataBound
{
8 v5 ~( ]; U, c5 spublic void Paint();
public void Bind(Binder b) {...}
5 K$ L3 E! i/ ?6 b) Z2 Y}
/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
7 c/ D5 V' x" B# g0 _以“public”的身份在“EditBox”类中实现。