初探c#--8,9,10

韩冰

1。8 类（Classes）
) Y, I- h5 E- v0 _. R类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
4 ^* }! V4 e& ?2 t, e类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
·  “public” 可以被所有代码访问；
·  “protected” 只可以被继承类访问；
1 u4 w6 \% I( r+ k# d0 |·  “internal” 只可以被同一个项目的代码访问;
* J" _$ y* b7 a7 n1 P9 b·  “protected internal”只可以被同一个项目的代码或继承类访问；
·  “private” 只可以被本类中的代码访问。
) W3 l/ t  \4 ]) Y  e0 {' l' D缺省状态是“private”。

1。9 结构（Structs）
: k* a( F+ L0 r结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
- X4 Y( c/ C9 m* U  q存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
2 d* ]' E5 l, l  {& {' z个points。在类“Point”中需要分配101个独立的对象（object）。*/

class Point
{
public int x, y;
public Point() {
x = 0;
y = 0;
* P/ }" m& ?% w, _. @' s}
; E# W" z3 e4 v& p( F% Xpublic Point(int x, int y) {
( M" R- ?& K, n8 c* Q6 f8 Y8 Ethis.x = x;
this.y = y;
}
, X( m3 I& X+ @}
. o3 \( }9 ]8 O5 C, h0 Y: Eclass Test
{
2 x, B% S  d1 `  F  H$ h- V+ ^static void Main() {
Point[] points = new Point[100];
for (int i = 0; i < 100; i++)
points = new Point(i, i*i);
7 ]& ~0 T' X# _; z}
% M# E3 T* o/ L7 i: S! Y1 W- X}
4 f9 Z# [  P: t. t" }/*
如果“Point”被作为一个结构，就可以这样啦：*/
4 T0 W3 \( {1 w: e7 f8 Y- n$ [. ustruct Point
4 t9 z2 O% h6 J, ?( h- R" s{
. o1 a, h  H! r! ?& h' i" ipublic int x, y;
public Point(int x, int y) {
; p: z6 L' I9 j# b* c) Xthis.x = x;
  _1 M/ O1 T- w/ u9 }; g% n% n- O4 ithis.y = y;
}
}
/*
9 J* Z5 k$ f0 l3 ~( ^# D6 z  F因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
" I& d; F. ]5 a, a) R了 ^_^ ）。
6 i# H. h) B5 q# o5 n
1。10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
0 @6 N* h" H  K# I
interface IExample
# e7 o! e5 Z% {" H{
# n* O3 D* h, ?, {+ {string this[int index] { get; set; }
8 _6 ]. I8 u. l6 t6 Ievent EventHandler E;
void F(int value);
string P { get; set; }
/ c- ~: G3 ?5 T- e! F' k: J4 z}
public delegate void EventHandler(object sender, Event e);
  K! a- g4 I" w9 p# w7 M/ W) v/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
6 M- @: l+ W0 C( Y+ k9 B" r界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
; z9 y9 P3 ]3 `! e* ~$ K*/
) c- [) x, _, [) linterface IControl
{
  \9 B4 X% i+ l& c1 [6 gvoid Paint();
- l9 a1 Z7 d2 C6 S}
1 F9 Z. |4 f- kinterface ITextBox: IControl
4 ?  L3 [/ r  _9 \* x. a' C9 }{
3 s, O! g& a) k* |' E" cvoid SetText(string text);
}
interface IListBox: IControl
  O" M- b2 w6 r1 o/ \7 f! B{
void SetItems(string[] items);
! G- c; b" m; u$ E4 h- U}
9 l' L1 g* L& U4 v) I  G3 zinterface IComboBox: ITextBox, IListBox {}
/*
' I. t% M# p  @8 I& e& K类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
9 F8 N2 b& J$ p和“IControl”继承。
& R8 k4 b  W- S  N  O. |*/
# i, G( X# X. p- g: Zinterface IDataBound
* T3 P  m, k) ^2 n& g8 ?% j{
void Bind(Binder b);
+ p: x: H5 ~  i1 o5 S}
public class EditBox: Control, IControl, IDataBound
: c/ |) @  {, g1 ~/ c{
public void Paint();
4 E$ \3 A4 F" {$ t4 `, A; {4 I; g# Cpublic void Bind(Binder b) {...}
}
/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
以“public”的身份在“EditBox”类中实现。