初探c#--8,9,10

韩冰

1。8 类（Classes）
类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
: g# D& w* @9 N/ i% T& w类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
! t1 h5 ~" O( o3 ]4 m对类中得所有成员有五种访问权限：
( P' J# ?1 \/ i% _·  “public” 可以被所有代码访问；
  Y  y9 ]$ N# U·  “protected” 只可以被继承类访问；
+ w+ O4 w7 g2 c3 |·  “internal” 只可以被同一个项目的代码访问;
·  “protected internal”只可以被同一个项目的代码或继承类访问；
·  “private” 只可以被本类中的代码访问。
缺省状态是“private”。
) h# }% h1 u8 g' i/ g
; }5 A) H: T8 f7 d" W$ g3 G1。9 结构（Structs）
  g, E6 E/ M: u8 [, G* q+ S结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
. D( Y, A! M& y- G别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
个points。在类“Point”中需要分配101个独立的对象（object）。*/
; d' i7 Q8 r% V; ^9 @; r1 D
$ X1 ?3 T* j% A* I. Q: Gclass Point
0 @' M0 _# ^' ]: `1 A# f. a0 ?0 {+ c{
/ i$ r- p! d" g+ X2 f  Kpublic int x, y;
public Point() {
: [- v& J* {* M( B8 H) hx = 0;
y = 0;
}
public Point(int x, int y) {
* v: W( H/ `: w; Tthis.x = x;
- L. k0 O) Q$ |* Tthis.y = y;
, W/ ~( A6 W1 ?! V}
}
class Test
{
static void Main() {
/ d! I. x5 ~0 j+ P; X  R, ~Point[] points = new Point[100];
for (int i = 0; i < 100; i++)
. u: |) `3 Q% T* n7 epoints = new Point(i, i*i);
1 O1 {$ j8 A8 o$ [. |5 _}
}
/*
( y7 ?6 b1 A8 ^6 ^7 U6 o如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
' x5 [' c  _, C) Q! l- H{
8 V! `  i! [6 K" a- _public int x, y;
+ Z- R, g0 y8 K0 p6 Ipublic Point(int x, int y) {
this.x = x;
& v! _$ y% v- fthis.y = y;
}
% _- Z9 p6 R5 O4 ]$ z% O/ h' t3 p}
, X& k6 Y0 B- {, V) {. r/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
  _3 s- b! r& s7 l! k' d) ]时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
/ H) T5 H$ t, B$ z所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
9 w% b4 p2 f$ Q5 ^. f了 ^_^ ）。
8 B" s! T6 j1 b' g: @5 ?5 t4 _
9 U5 q: _! R: B8 m9 u1。10 界面（Interfaces）
% n( w: e. p/ Y0 Q0 p5 d8 T6 {界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/

interface IExample
# D! W; S: \* |2 F  {{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
7 R2 _4 N3 G% Nstring P { get; set; }
' q$ m! i$ C2 _& V2 G9 `' A}
public delegate void EventHandler(object sender, Event e);
/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
- j: B* [0 Q3 t& I*/
interface IControl
/ q% t/ o0 \, d5 q( l+ _{
void Paint();
& R5 t% G: _) W0 t* R}
interface ITextBox: IControl
% t( @% x4 T9 A7 R% ]{
1 }  k6 `0 X7 L! Q- G; Nvoid SetText(string text);
}
( q: T6 _' E+ E& e% Q8 Rinterface IListBox: IControl
8 b7 W5 _) G/ D{
# m6 Q  n8 Y! N% Yvoid SetItems(string[] items);
( {( N8 V* V4 B; E}
interface IComboBox: ITextBox, IListBox {}
/ t$ T( [! u; ]' }$ ]3 d% o/*
( k1 X5 j0 u2 l( p! w; |1 D类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
和“IControl”继承。
*/
1 P8 K$ R1 [) @3 d7 I4 Hinterface IDataBound
* D/ \6 s6 U) U+ A. n( `{
void Bind(Binder b);
}
public class EditBox: Control, IControl, IDataBound
$ M" i+ s' Q8 S0 Q5 N& I{
/ ?. d( q% z: P$ ]. b. H9 I, l4 |' apublic void Paint();
4 q5 P9 O+ V. R+ g) y+ {public void Bind(Binder b) {...}
}
- s& m% y. s# J2 Y/*
" t, x# m/ {9 I. e4 R! b在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
5 U5 m  c9 t4 E  H* c; h# s以“public”的身份在“EditBox”类中实现。