初探c#--8,9,10

韩冰

1。8 类（Classes）
类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
9 j  q1 [+ {6 t% n! S) V/ ^2 o2 W% e对类中得所有成员有五种访问权限：
2 n8 Z( P/ c; N8 }, h5 m·  “public” 可以被所有代码访问；
·  “protected” 只可以被继承类访问；
- ^  Y- u1 N- g/ s5 t·  “internal” 只可以被同一个项目的代码访问;
·  “protected internal”只可以被同一个项目的代码或继承类访问；
9 Z5 {7 v. a8 ^- m·  “private” 只可以被本类中的代码访问。
8 m: a5 A  u8 @* J7 W( A3 @缺省状态是“private”。
/ T) f& s6 ]) X9 Z
; h+ L+ i8 Q$ _; U* m3 Y4 ?. P1。9 结构（Structs）
结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
# R' Y4 c" Z( ?( ]) q个points。在类“Point”中需要分配101个独立的对象（object）。*/
% e. Q# q$ i5 P6 V
class Point
5 w2 i  t- P* z- Q{
8 |+ C. P) n9 u5 z( p& a3 Z% Upublic int x, y;
, `; D4 M/ N0 |- hpublic Point() {
- i% h  Y$ Q" M* Bx = 0;
: Q5 c, \' a+ F) Cy = 0;
}
3 Q2 w- y5 M% d# s+ B- xpublic Point(int x, int y) {
this.x = x;
this.y = y;
6 e/ D6 D- s' O) `8 O$ U& E& m}
}
( n: s% y/ |# d) z: Aclass Test
) s0 ^8 a4 z' J( `* j5 }+ T& }8 \7 Z{
static void Main() {
Point[] points = new Point[100];
for (int i = 0; i < 100; i++)
points = new Point(i, i*i);
}
, A6 \: o' ^6 g) I+ h' A( t}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
{
' ]- N( d( p7 c1 y1 mpublic int x, y;
+ `* q/ k' M! Kpublic Point(int x, int y) {
6 }' m1 A" r( P  p- rthis.x = x;
this.y = y;
: u$ W* a! T0 g$ X  W% r}
$ G, O& Q; i8 H( Z  v/ t5 {}
% ]+ W2 L" K0 Z# _1 e/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
9 Q( X# W2 J# h时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
了 ^_^ ）。
/ }. T8 R1 v. {. H7 h
1。10 界面（Interfaces）
% J6 }$ L1 t* l& A' \界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
; H% {9 k) T! ]9 o6 T类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/

interface IExample
* m; M, }) X, t. f$ Y) y+ G{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
string P { get; set; }
9 m$ N# n! n' W/ K" o/ v0 _}
public delegate void EventHandler(object sender, Event e);
/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
0 S9 C8 N! R* b*/
# Y( H+ |: W/ xinterface IControl
{
+ z/ a9 j7 @* e/ kvoid Paint();
}
interface ITextBox: IControl
* B) o1 c* ~! n. _# c7 s{
6 n- n# Y  x( J$ \* I  Jvoid SetText(string text);
) x  o9 R/ ~3 g0 [& d$ @5 J, W( h$ Y}
interface IListBox: IControl
{
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}
/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
, }. h% S) t: C( I2 j5 S5 }! w# W和“IControl”继承。
1 Z4 _4 Z6 Y4 `2 ~/ F*/
interface IDataBound
; j9 A- M2 o+ e0 |) J{
void Bind(Binder b);
7 C% f# C8 `; S' O2 m* b  X& \}
public class EditBox: Control, IControl, IDataBound
- t3 ?# Q) a! a5 `( x, Y! B1 T4 z{
' U3 s2 _: T3 i, P0 l! s- ppublic void Paint();
public void Bind(Binder b) {...}
}
! o/ u- S2 C% a$ g" H) @/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
以“public”的身份在“EditBox”类中实现。