初探c#--8,9,10

韩冰

1。8 类（Classes）
& A3 A: q9 z, T0 g" `% k1 s类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
6 W# \* i& `! P2 @  h类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
·  “public” 可以被所有代码访问；
·  “protected” 只可以被继承类访问；
·  “internal” 只可以被同一个项目的代码访问;
·  “protected internal”只可以被同一个项目的代码或继承类访问；
·  “private” 只可以被本类中的代码访问。
缺省状态是“private”。

4 j2 L/ B% [8 n8 h8 G: N: C8 V1。9 结构（Structs）
  T1 q: a' v' X5 f' d" _; c结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
个points。在类“Point”中需要分配101个独立的对象（object）。*/
; N7 q+ R$ }4 I# y3 S
, q( t. X. T4 qclass Point
{
public int x, y;
7 t8 Z% J% ]% z* O. k, R* o' Jpublic Point() {
x = 0;
% k2 s4 h! f8 }  }' Zy = 0;
6 w  }$ J5 n! c- ~( `, e4 b}
  Y: i% [# {% f& F" xpublic Point(int x, int y) {
5 r) {  B  ?" rthis.x = x;
& V; D" F& ?3 \# Z6 u4 D! F* Ethis.y = y;
) L0 d( y% z5 P% H}
}
class Test
{
static void Main() {
6 u7 X% O. B7 g! }3 k0 wPoint[] points = new Point[100];
% b) q  y6 b! \+ X. {, B- ufor (int i = 0; i < 100; i++)
points = new Point(i, i*i);
}
3 O+ Z, d- ^7 D+ b; o}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
# f/ d/ q' \! w) x; {' C1 xstruct Point
; R1 U% ^$ ?+ c: e& N{
+ G! i, J1 c& `- u# a$ ~, w2 b2 qpublic int x, y;
public Point(int x, int y) {
' r  j# B7 X3 J+ }( P- T, X, Ithis.x = x;
+ V* f6 j. J( v; o# uthis.y = y;
  f) q% |. N: V& A. R% b}
# d1 w% n2 a5 {; a}
/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
9 z# h; ?. q" b! a1 e; L时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
' l8 v, h2 m) c( p7 m所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
了 ^_^ ）。

  ~! A! Y* {, r$ ]1。10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
/ L& \) |4 D! K% f类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/

interface IExample
{
string this[int index] { get; set; }
" E, b% C! R/ u3 _/ b, ievent EventHandler E;
void F(int value);
string P { get; set; }
  r9 ?$ G. ?; |) p1 Q3 j}
public delegate void EventHandler(object sender, Event e);
" p5 w5 }1 B! p& v$ u1 }/*
2 d, c# Z" k! W; q  v8 Z- k  p例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
& m$ P. [; h9 Y界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
$ M( ]# y8 C# j*/
2 f0 s  [/ U/ Ainterface IControl
' L  \( L) H/ v& h6 p( K5 B+ g2 e0 r{
0 I: v- o. h7 Jvoid Paint();
}
interface ITextBox: IControl
{
7 \; Q# H# A& I. @7 f/ |void SetText(string text);
: `' O# G! w. b( W0 E}
interface IListBox: IControl
0 e+ z# F% M0 r" w& ?) F  X{
. h& i# W6 j! rvoid SetItems(string[] items);
. ?6 o: \% U  }" M6 G* u}
interface IComboBox: ITextBox, IListBox {}
( X% ^# i/ i0 V2 n  N/*
3 ~! \; P& y/ S3 U: z7 I- u8 t类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
/ |& |* u3 `3 k# j  o% R9 P和“IControl”继承。
7 |9 ]- g) U; G, m& e" r4 Y7 e*/
interface IDataBound
{
void Bind(Binder b);
. Y) w9 P# N4 Q( U$ X}
public class EditBox: Control, IControl, IDataBound
! Q" f4 M- b0 s/ R/ O{
4 k+ Z; z3 o3 Ipublic void Paint();
: Z# d2 m0 N) R4 @; }public void Bind(Binder b) {...}
* P7 u/ @+ Y% A" R, L1 ~}
; @5 J4 s9 v3 `3 B/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
5 R" y7 M- T% p; S6 p以“public”的身份在“EditBox”类中实现。