初探c#--8,9,10

韩冰

1。8 类（Classes）
类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
·  “public” 可以被所有代码访问；
·  “protected” 只可以被继承类访问；
·  “internal” 只可以被同一个项目的代码访问;
·  “protected internal”只可以被同一个项目的代码或继承类访问；
, W% t) z. U/ S! n3 o. `3 ~! G- Y. I·  “private” 只可以被本类中的代码访问。
" z, p( `1 q) j9 V0 a缺省状态是“private”。

3 l/ }3 a, |; {% U+ }9 Y7 C1。9 结构（Structs）
: p' z$ \2 v3 }/ B% g1 r3 n3 c结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
个points。在类“Point”中需要分配101个独立的对象（object）。*/

4 T% Z/ l  c+ `$ ?$ }! S; Q0 Nclass Point
{
public int x, y;
public Point() {
/ B, O1 Z6 e. W7 w0 y- Gx = 0;
y = 0;
2 T9 I" g' }# f$ [' f8 O9 S( v}
4 T% j. B6 U% F! d# ipublic Point(int x, int y) {
this.x = x;
2 ?- V: [) G, z4 i* Ethis.y = y;
4 i" o$ T# X8 S; e# Z( f+ G}
2 s! i* q5 q+ c* O" _( p}
class Test
{
static void Main() {
Point[] points = new Point[100];
for (int i = 0; i < 100; i++)
: G8 T5 {5 f% j7 T4 ^2 ?" bpoints = new Point(i, i*i);
5 a) N, G( d+ {, U2 Z}
0 o! |" b. s/ N# Z" v}
9 u( H& F0 a# e3 C# b! @/*
如果“Point”被作为一个结构，就可以这样啦：*/
( n( _/ Z' `* Zstruct Point
3 q3 p# q/ G6 J' {4 v3 G0 G' A{
- j. w' e3 W* [( zpublic int x, y;
- \! u8 U4 r! M; H/ lpublic Point(int x, int y) {
this.x = x;
this.y = y;
# C9 i0 F6 A7 ?) F4 Y* j# k# X}
}
+ }( |5 u! z- P) y9 G/*
0 `- G' j$ t2 m; F% `因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
% l1 d: |$ v2 l9 R7 |2 d/ R时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
了 ^_^ ）。
2 t6 [; `" q% l
1 q7 g4 c* d9 q! F: p" e- i5 y1。10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
. T/ k8 k9 O! f6 b& P- p
1 o+ ^$ k, Z- P3 Pinterface IExample
{
4 Z% U; q( j- F5 m) ^, [string this[int index] { get; set; }
9 L' T1 n; }! Qevent EventHandler E;
* m4 g5 k$ m$ W: x8 R: p! n4 Nvoid F(int value);
( Y) k0 _' |% K8 M" G! Hstring P { get; set; }
) X3 }6 h3 t, A; q6 W}
7 z  X8 E$ G, a  I! `1 h4 ^8 r3 Npublic delegate void EventHandler(object sender, Event e);
/*
0 B1 E( s9 v) Z4 i: n" {例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
) e0 A2 K3 a; |! X2 ~界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
*/
* Q4 O5 M& e) j& n+ h7 {% rinterface IControl
! h/ v5 y: y6 _- Q{
9 \$ m- z5 D6 H: C% Ivoid Paint();
+ j5 M3 a* m6 S6 E) A6 Q}
  C* Y/ b9 O1 u# J9 s- C$ n& m5 v1 einterface ITextBox: IControl
2 |' k' l( ?% k7 O/ N4 i{
void SetText(string text);
1 {8 _, D: x) ~% ~/ x. @4 l$ \) r}
interface IListBox: IControl
" S$ y7 q3 k: h6 l. U1 d{
( `' z; b2 a6 h4 m% tvoid SetItems(string[] items);
# S- ?: f+ S& {9 B0 ]}
interface IComboBox: ITextBox, IListBox {}
/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
% x) D, d5 l6 i( H* j: ]( o9 I和“IControl”继承。
: a1 O! \1 n+ u7 N. X# [*/
interface IDataBound
{
# S4 H5 C) _. P) w( p8 ~void Bind(Binder b);
}
! C6 Y, T; |) N7 f; _  L' w% Cpublic class EditBox: Control, IControl, IDataBound
5 T5 i, r# H: o0 @{
public void Paint();
3 e. N4 Z1 z. \public void Bind(Binder b) {...}
; h, ^) W( X. ]2 n$ |% n}
/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
以“public”的身份在“EditBox”类中实现。