C#简明教程.docx

C#简明教程.docx

《C#简明教程.docx》由会员分享，可在线阅读，更多相关《C#简明教程.docx（27页珍藏版）》请在冰豆网上搜索。

C#简明教程

enum枚举类型

struct结构类型，相当于js中类的属性

Console.write（）；

Console.read（）；

装箱（将值类型转为引用类型）和拆箱

例：

vara=100;

objectobj=a;

Console.write（"对象的值为：

{0}"，obj）;

convert类：

数值类型转换

封装的概念：

黑盒子

类的继承

接口的概念

类与对象的关系：

类定义了一个模板，通过这个模板可以生产一个或多个对象，实例化类（new）就是创建对象的过程。

例：

//定义一个类：

publicclassbankcustomer

{

publicstringfirstName;

publicstringlastName;

publicdecimalbalance;

publicvoiddeposite（decimalamount）

{

this.balance+=amount;

}

}

//实例化类（创建一个对象）

staticvoidMain（string[]args）

{

bankcustomerc;

c=newbankcustomer（）;

this.firstName="wu";

this.lastName="chuande";

this.balance=0.0M;

this.deposite（1000.00M）;

}

访问修饰符：

public：

访问不受限制

protected：

访问仅限于包含类或从包含类派生的类型

internal：

访问仅限于当前程序集

protectedinternal：

访问仅限于从包含类派生的当前程序集或类型

private：

访问仅限于包含类型（只有本身可以访问）

例：

Classcontact

{

Publicstringm_name;

Publicintm_age;

Publicstringm_telephone=“unknown”;

PublicstructAddress

{

Publicstringm_city;

Publicstringm_street;

Publicstringnumber;

}

PublicstringAddressm_address=null;

Publicvoidtelnumber（stringtargetNumber）

{

Console.writeline（）;

}

}

对象引用：

对象变量保存的是对对象的一个引用

静态（static）类成员：

静态类中的成员不属于任何对象，它可以通过类名直接访问。

而实例成员必须通过建立对象的引用来访问。

静态成员的定义：

publicstaticint；

静态方法：

用静态的方法可以返回静态的类成员，静态的方法可以不用创建实例。

构造函数：

构造函数是与类同名的特殊方法成员，它是实现初始化类实例所必须操作的成员，在C#中不允许使用未初始化的变量，因此在执行构造函数之前，对象是不可用的。

默认实例构造函数：

在C#中，如果类不包含任何实例构造函数声明，则自动提供一个默认的无参数的实例构造函数，并使用默认值初始化对象字段（例如，int字段将初始化为0）。

参数化的构造函数：

构造函数的其他作用：

静态构造函数：

初始化静态的成员变量

从其他构造函数中调用构造函数：

可用：

this（）调用。

调用基类的构造函数：

可用：

base（）调用。

析构函数：

~

清理：

IDispoasble接口

对象的方法：

声明方法的语法：

【访问修饰符】返回类型<方法名>（参数列表）

{

}

调用方法的语法：

实例.方法（参数）；

方法的重载：

方法名相同，但是参数不同（参数数量不同或参数的类型不同，或返回值的类型不同），就可以实现方法的重载。

名称空间：

增强可读性，减少类名冲突。

多级的名称空间。

导入名称空间：

usingsystem；

导入别名的方式：

usingBT=teamx.businessTier；

BT.Customer.c;

FxCL:

FrameworkClassLibrary.类库。

如图所示。

组件：

在.net中，组件被称为程序集（assembly）

例：

新建类库，并且调用。

继承：

在C#中用“：

”表示继承。

如

classBase{

intbasevar；

Base_fun1（）

{....}

}

classDerived:

Base

{

intderivedvars;

Derived_fun1（）

{.....}

}

voidmain（）

{

Deriveddr_obj=newDerived（）;

//调用Base类的成员函数

dr_obj.Base_fun1（）;

}

多重继承：

C#中不能多重继承，但允许多重接口实现

调用base构造函数：

：

base（a,b）；

virtual关键字：

允许在派生类中重写基类中的方法。

例

publicvirtualvoidrecordcall（）

{}

override关键字：

在子类中重写基类的方法，也叫覆盖基类中的方法。

例publicoverridevoidreocrdcall（）

{}

隐藏从基类继承的成员：

使用new修饰符显示隐藏从基类继承的成员。

若要隐藏继承的成员，请使用相同名称在派生类中声明该成员，并用new修饰符修饰它。

object基类：

方法重写：

参数不同，方法名相同。

可以重写函数

抽象类和抽象方法：

abstract，抽象类不能实例化。

就像没有叫做动物的动物一样。

从抽象类派生的类一定要实现抽象类中的抽象方法。

就是动物和猫，狗之间的关系。

动物相当于抽象的一个类，动物定义了眼睛，耳朵。

从动物派生而出的猫，也一定要有眼睛，耳朵。

不然就是异形了。

密封类：

sealed关键字。

为了防止第三方XX扩展自己的类。

多态性：

理解重载和重写。

多态的案例：

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

namespaceduotai

{

classProgram

{

staticvoidMain（string[]args）

{

//创建circle实例

circlett=newcircle（）;

Console.WriteLine（tt.getSides（））;

//创建round实例

roundrr=newround（）;

Console.WriteLine（rr.getSides（））;

//sharp抽象类，创建circle实例，但调用了子类circle的方法

sharpss=newcircle（）;

Console.WriteLine（ss.getSides（））;

}

//定义一个抽象类Sharp

publicabstractclasssharp

{

publicabstractintgetSides（）;

}

//定义一个sharp的子类：

circle

publicclasscircle:

sharp

{

publicoverrideintgetSides（）

{

return1;

}

//定义一个sharp的第二个子类：

round

}

publicclassround:

sharp

{

publicoverrideintgetSides（）

{

return2;

}

}

}

}

继承和多态的关系：

继承是指子类调用了父类的方法，而多态反过来，是指父类调用了子类的方法。

接口：

interface

例：

publicinterfaceIPict

{

intDeleteImage（）；

voidDisplayImag（）；

}

创建一个实现接口的类，必须实现接口中的方法。

可以通过接口实现多继承。

多重接口实现：

一个类可以实现多个接口。

显示接口实现：

向上转型：

例子：

实现一个具体的多态

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

namespacexiangshangzhuanxing

{

classvideo

{

staticvoidmain（string[]args）

{

//DVDdvd=newDVD（）;

//dvd.playVideo（）;

//VCDvcd=newVCD（）;

//vcd.playVideo（）;

//实现多态

videott=newvideo（）;

tt.Playvideo（）;

}

//video的一个方法

publicvoidPlayvideo（）

{

//抽象类vw，vw可以实现两个类里的两种不同方法，可以称之为接口，此即多态性

showVideovw;

//vw的第一种方法

vw=newDVD（）;

Console.WriteLine（"playDVD"）;

//vw的第二种方法

vw=newVCD（）;

Console.WriteLine（"playVCD"）;

}

//定义了一个抽象类

publicabstractclassshowVideo

{

publicabstractstringplayVideo（）;

}

//实现了一个抽象类

publicclassDVD:

showVideo

{

publicoverridestringplayVideo（）

{

return"itisplayingDVD";

}

}

//实现了第二个抽象类

publicclassVCD:

showVideo

{

publicoverridestringplayVideo（）

{

return"itisplayingVCD";

}

}

}

}

运算符重载：

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

namespace运算符重载

{

classProgram

{

staticvoidMain（string[]args）

{

//定义了三个实例

vecturevec1,vec2,vec3;

vec1=newvecture（1.0,2.0,3.0）;

//定义了以vec1为参数的实例vec2

vec2=newvecture（vec1）;

//vec3利用运算符重载

vec3=vec1+vec2;

Console.WriteLine（vec3.ToString（））;

}

//定义一个vecture类

classvecture

{

privatedoublex,y,z;

publicdoubleX

{

get{returnx;}

set{x=value;}

}

publicdoubleY

{

get{returny;}

set{y=value;}

}

publicdoubleZ

{

get{returnz;}

set{z=value;}

}

//定义无参数的构造函数

publicvecture（）

{

x=0;

y=0;

z=0;

}

//定义一个参数的构造函数，以类vecture的实例rhs为参数

publicvecture（vecturerhs）

{

x=rhs.x;

y=rhs.y;

z=rhs.z;

}

//定义一个三个参数的构造函数

publicvecture（doublex,doubley,doublez）

{

this.x=x;

this.y=y;

this.z=z;

}

//重写了ToString方法

publicoverridestringToString（）

{

return"x的坐标是：

"+x+"y的坐标是"+y+"z的坐标是"+z;

}

//定义了一个+号运算符重载,令两个vecture实例的属性进行相加

publicstaticvectureoperator+（vecturelhs,vecturerhs）

{

vectureresult=newvecture（lhs）;

result.x+=rhs.x;

result.y+=rhs.y;

result.z+=rhs.z;

returnresult;

}

}

}

}

索引器实例

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

namespace索引器实例

{

classProgram

{

staticvoidMain（string[]args）

{

AlbummyAlbum=newAlbum

（2）;

photofirst=newphoto（"吴传徳"）;

photosecond=newphoto（"吴传义"）;

myAlbum[0]=first;

myAlbum[1]=second;

phototestPhoto=myAlbum[0];

Console.WriteLine（testPhoto.Title）;

phototestPhoto2=myAlbum["吴传义"];

Console.WriteLine（testPhoto2.Title）;

}

//定义一个photo类

classphoto

{

privatestringPhotoTitle;

//定义两个构造函数，一个为默认值，一个为有一个参数的函数

publicphoto（）

{

PhotoTitle="楚广明";

}

publicphoto（stringtitle）

{

PhotoTitle=title;

}

//定义了属性为只读属性的get访问器

publicstringTitle

{

get{returnPhotoTitle;}

}

}

classAlbum

{

//定义了相册的成员：

相片，将其定义为一个数组

photo[]photos;

//定义构造函数，初始化成员

publicAlbum（）

{

photos=newphoto[3];

}

publicAlbum（intx）

{

photos=newphoto[x];

}

//定义一个根据索引的索引器，索引器是属性的增强版,这里的photo是指返回值为photo类型

publicphotothis[intindex]

{

get{

if（index<0||index>=photos.Length）

{

Console.WriteLine（"索引不存在"）;

returnnull;

}

returnphotos[index];

}

set{

if（index<0||index>=photos.Length）

{

Console.WriteLine（"索引不存在"）;

return;

}

photos[index]=value;

}

}

//定义一个根据title的索引器

publicphotothis[stringtitle]

{

get{

foreach（photopinphotos）

{

if（p.Title==title）

returnp;

}

Console.WriteLine（"找不到"）;

returnnull;

}

}

}

}

}

异常处理：

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

namespace异常处理

{

classProgram

{

staticvoidMain（string[]args）

{

stringuserInput;

while（true）

{

try

{

Console.WriteLine（"请输入一个0到5之间的数，或者按回车键退出"）;

userInput=Console.ReadLine（）;

if（userInput==""）

{

break;

}

intx=Convert.ToInt16（userInput）;

if（x<0||x>5）

{

thrownewException（"您输入的数字是"+x+"超出索引范围"）;

}

}

catch（Exceptione）

{

Console.WriteLine（"成功接住抛出的异常，异常信息为：

"+e.Message）;

}

finally

{

Console.WriteLine（"谢谢您的使用！

"）;

}

}

}

}

}