初探c#--8,9,10

韩冰

1。8 类（Classes）
8 r! ^0 d# S, q) Q8 J类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
1 i$ }2 r/ L- {/ D9 F2 I& B类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
( V  v8 U  Z9 q·  “public” 可以被所有代码访问；
5 y/ m6 k& ?; e·  “protected” 只可以被继承类访问；
·  “internal” 只可以被同一个项目的代码访问;
·  “protected internal”只可以被同一个项目的代码或继承类访问；
  N) j) \6 m* ?* w  k; t1 r·  “private” 只可以被本类中的代码访问。
' d4 \& s! e6 J缺省状态是“private”。

1。9 结构（Structs）
结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
# {6 D# X5 k2 `/ N9 k; o0 g别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
& M. p7 I- d5 _3 l1 \4 R# g存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
个points。在类“Point”中需要分配101个独立的对象（object）。*/

0 f* z( U% ~9 x" aclass Point
( h6 e3 e) i  A# ^2 s6 T' Y{
public int x, y;
. U! p" R% e- i4 x/ [: Tpublic Point() {
$ g5 H8 K! Q1 J* s+ N$ F# Z2 O' Sx = 0;
y = 0;
7 B1 m+ T) r, l7 E6 s}
public Point(int x, int y) {
2 X0 N' d+ v8 ~9 i) [- J  x1 @this.x = x;
this.y = y;
# @; Z2 l/ m$ q- d+ ?}
}
0 e8 l' B( f, H( {class Test
{
static void Main() {
9 a* _) ]  C7 KPoint[] points = new Point[100];
for (int i = 0; i < 100; i++)
' ?! A/ P; b/ w. Zpoints = new Point(i, i*i);
}
! E6 A" }+ Y" `# X! h}
2 [; U* }' @- S& a/*
5 [' R3 t# C" q6 C; M如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
{
public int x, y;
/ [* z* C# X$ |/ ]2 ]5 o4 }; Vpublic Point(int x, int y) {
this.x = x;
this.y = y;
2 Q( E$ p: R& r1 ^! B  D' s0 j}
4 ~: \, @2 {! ^" N}
/*
1 ^6 W* ^( v7 X8 d& U因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
9 D6 L4 E6 _; E' o( f了 ^_^ ）。
2 _( c1 |, ~  u4 u/ E. J
: O% r, y9 C: {1。10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/

interface IExample
% A% r4 z6 T2 Q1 g9 n$ ?$ K, B& U{
. `# P  w0 O* M8 G. b6 W& D0 Tstring this[int index] { get; set; }
event EventHandler E;
$ ~; Z1 s- {1 d' H7 ]/ l2 Gvoid F(int value);
3 M" ?4 d- F$ B! W2 y  I6 `$ Hstring P { get; set; }
0 D- G8 c+ F' e/ M( E5 R. E. K}
2 @4 z& @: P) S5 Cpublic delegate void EventHandler(object sender, Event e);
/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
: h' M, m2 N) P2 `: Y*/
interface IControl
{
void Paint();
}
. D5 L$ L( S& {. C8 m+ v! F" c& [interface ITextBox: IControl
, A$ x+ R9 X7 e7 F{
" l6 q$ S% b5 k- d$ ]* Zvoid SetText(string text);
* T4 J" x. i7 H. X' Z, y}
/ @, C( b  a7 A: K- |& r) @interface IListBox: IControl
{
) p/ ]! n$ k: [2 [# b$ x4 y/ Kvoid SetItems(string[] items);
( ~# ]* T# |$ v' ^$ A% b& m}
; ]/ z( y' U* F* K! }7 Y: t$ jinterface IComboBox: ITextBox, IListBox {}
3 {! z' E4 s/ \7 r  U, C/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
5 @* c6 e" O1 `+ J7 K和“IControl”继承。
*/
interface IDataBound
" i& ~2 q# C, Q8 s1 w. i, T{
. p; y, _; E6 Z- }  N7 hvoid Bind(Binder b);
}
public class EditBox: Control, IControl, IDataBound
{
public void Paint();
, |4 s" C3 x& rpublic void Bind(Binder b) {...}
}
6 \+ I, C1 i% h8 ?9 m" u4 n) `7 D/*
, R$ d; W( j# g( H9 g在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
+ z, }* ~$ i1 }' W  G1 Z以“public”的身份在“EditBox”类中实现。