深入.NET平台和C#编程

深入.NET平台和C#编程

一. Microsoft.NET介绍

.NET对用户来说非常重要，因为计算机得功能将会得到大幅度得提升，同时计算机得操作也会变得简单。更为重要得是，用户将完全摆脱人为硬件得束缚，可以自由冲浪，访问，查看，自由使用自己得数据。.NET得战略目标是在然后时候，任何地方。使用任何工具都能通过.NET得服务获得网咯上得任何信息，享受网络带给人们得便捷和快乐。

1 .NET得魅力

• 提供了一个面向对象得编程环境
• 对Web应用得强大支持
• 对Web Service（Web）得支持
• 实现SOA，支持云计算
• 支持构建.NET程序得炫彩外衣

2、.NET框架结构

主要有两个组件：

CLR：公共语言运行时

FCL：框架类库：表示一部分已经被封装好的功能的集合

3、面向对象的回顾

定义: 类是对象的抽象，对象是类的具体

类的三大特性:

1、类的特性：封装：将一些特性私有化，将底层(实现过程)藏起来（实现方案：将内容用方法包装）

  private string name;
		public string Name
		{
			get{return _name;}
			set{_name =value;}
		}

2 、继承：继承爸爸得东西
3、多态：一个事物的多种形态

定义类：

public class 类名
	{
		字段私有
		属性：get[只读]、set[只写]
		方法
	}

类图

在实际开发中，软件得规模一般都很大，如开源得.NET开发工具得源码就有几十万行

类图就起到很大得作用，使读者不用看很多代码就能理解。

类成员：字段,属性,方法

二.深入C#数据类型

数据类型

1、C#常用得数据类型

常用数据类型	Java	C#	举例
整型	int	int	年龄
浮点型	float	float	成绩
双精度型	double	double	圆周率
字符型	String	string	家庭住宅
布尔型	boolean	bool	是否为少数名族
枚举类型	enum	enum	颜色

2、值类型

数值：int,long,double,float
字符：char
布尔：bool
枚举：enum
结构：struct

3、引用数据类型

1.包括的数据类型

class
string
数组
集合
委托
接口

struct结构

1.定义

.1使用关键字struct

.2字段不能赋初始值

public struct A(){//结构体}

• 结构中可以有字段，也可以有方法
• 定义时，结构中得字段不能被赋初始值

​ .4结构里有多少个字段,定义构造函数就要有多少个参数

2.struct的使用

结构得构成和类很相似。在使用结构时要注意以下几个方面：

​ .1可以new出来,也可以不new出来

[注意:如果不new直接赋初始值会语法报错]

​ .2结构在使用的时候要给所有字段赋初始值,不然会语法报错

3、不能手写无参构造函数

拆箱和装箱

static void Main(string[] args)
{
    int i =123;
    object o =i;//装箱
    i=456;//改变i得内容
}

static void Main(string[] args)
{
    int i =123;
    object o =i;//装箱
    int j=(int)o;//拆箱
}

1.值传递

​ 1.基本数据类型:形参所做改变不会影响实参

​ 2.引用数据类型:形参所做改变会影响实参[同一个堆里面],string除外

2.引用传递

​ 1.形参所做修改会影响实参

​ 2.形参和实参都要在前面加ref

​ 3.、加了ref，表示，当前变量，指针，指向前一个变量的地址

三.使用集合组织相关信息

基本定义:

1、集合：保存一组大小不固定的值
2、类似数组：

3、泛型跟非泛型：
泛型：限定了数据类型
非泛型：没有限定数类型

ArrayList

​ ArrayList:跟数组一样，没有限定数据类型，涉及到频繁的拆箱装箱，类型转换

必须导入命名空间：System.Collections。

​ 1、创建对象
​ ArrayList list = new ArrayList();
​ 2、属性：
​ Count：得到长度
​ 3、方法：
​ Add(Object value)：添加
​ RemoveAt(int index)：移除的是下标
​ Remove(Object value）：移除的是值
​ Clear()：清空所有的
​ [int index]：1、获取值；2、赋值【注意：下标一定是已经存在的】
​ 4、遍历
​

ArrayList list = new ArrayList();
list.Add(1);
list.Add(2);
list.Add(3);
list.RemoveAt(0)//删除下标为0得数据
list.Remove(3）//删除数据为3得
foreach(object obj in list)
{
    cw(obj);
}

List

List跟ArrayList 一样，属性和方法都是一样。

但是List限定了数据类型

​ 1、创建对象
​ List list = new List();
​ 2、属性：
​ Count：得到长度
​ 3、方法：
​ Add(Object value)：添加
​ RemoveAt(int index)：移除的是下标
​ Remove(Object value）：移除的是值
​ Clear()：清空所有的
​ [int index]：1、获取值；2、赋值【注意：下标一定是已经存在的】
​ 4、遍历：

	
List<T> list = new List<T>();
list.Add(1);
list.Add(2);
list.Add(3);
list.RemoveAt(0)//删除下标为0得数据
list.Remove(3）//删除数据为3得
foreach(object obj in list)
{
    cw(obj);
}

ArrayList与List得区别

异同点	List	ArrayList
不同点	对所保存元素进行类型约束	可以增加任何类型
	添加/读取值类型元素无需拆箱和装箱	添加/读取值类型元素需要拆箱和装箱
	删除元素方法相同
相同点	通过索引访问集合中得值
	添加元素方法相同

Hashtable

​ 1、创建对象
​ Hashtable ht = new Hashtable();
​ 2、属性
​ Count–》得到长度
​ Keys：到当前Hashtable里面所有的键
​ Values：得到当前hashtabale里面所有的值
​ 3、方法
​ Add(Object key, Object value)
​ Remove(Object key):根据key移除
​ Clear()清空
​ 5、遍历：
​ 1、遍历所有key

     foreach(Object key in ht.Keys)
	{
		key +  ht[key]
	}

​ 2、遍历所有的value

      foreach(Object value in ht.Values) 
      {
          value
      }

​

Dictionary

​ 1、创建对象
​ Dictionary<Tkey, Tvalue> dic = new Dictionary<TKey, Tvalue>();
​ 2、属性
​ Count:得到长度
​ Keys:得到当前Hashtable里面所有的键
​ Values:得到当前hashtabale里面所有的值
​ 3、方法
​ Add(Object key, Object value)
​ Remove(Object key):根据key移除
​ Clear()清空
​ ContainsKey(TKey key);:判断key是否已经存在，存在返回true
​ 5、遍历：
​ 1、遍历所有key

      foreach(T key in ht.Keys)
	  {
		 key +  ht[key]
	  }

​ 2、遍历所有的value

	foreach(T value in ht.Values) 
	{
	      value 
	}

**

异同点	Hashtable	Dictionary
不同点	对所保存元素进行类型约束	可以增加任何类型
	添加/读取值类型元素无需拆箱和装箱	添加/读取值类型元素需要拆箱和装箱
	删除元素方法相同
相同点	通过索引访问集合中得值	通过Key获取Value
	添加元素方法相同

泛型类：

C#自定义泛型类用得最广泛，就是集合（Collection）中。实际上，泛型的产生其中一个原因就是为了解决原来集合类中元素的装箱和拆箱问题（如果对装箱和拆箱概念不明，请百度搜索）。由于泛型的使用，使得集合内所有元素都属于同一类，这就把类型不同的隐患消灭在编译阶段——如果类型不对，则编译错误。

这里只讨论C#自定义泛型类。基本自定义如下：

语法：

​ public class MyGeneric < T>

​ …{

​ private T member;

​ public void Method (T obj)

​ …{

​ }

​ }

四.深入类的方法

构造函数

构造函数主要是用来创建对象时为对象赋初值来初始化对象。总与new运算符一起使用在创建对象的语句中 。A a=new A();

构造函数具有和类一样的名称；但它是一个函数具有函数的所有特性，同一个类里面可以有多个参数不同的构造函数，也就是函数的多态。

构造函数是在实例化类时最先执行的方法，通过这个特性可以给对象赋初值。

构造函数没有返回值，也不能用void修饰，只有访问修饰符。

语法：

public A(){}

每个类中都会一个构造函数，如果用户定义的类中没有显式的定义任何构造函数，编译器就会自动为该类型生成默认构造函数，类里面没有构造函数也可以，系统会为你自动创建无参构造函数。

重载和重写及运用

重载的条件：

​ 1.必须在同一个类中2.方法名必须相同3.参数列表不能相同。
重写的条件：
1. 在不同的类中
2. 发生方法重写的两个方法返回值，方法名，参数列表必须完全一致
3. 子类抛出的异常不能超过父类相应的方法抛出的异常
4. 子类方法的访问级别不能低于父类相应方法的访问级别（public，package，protected， private）
5.方法体不同

super()调用父类构造，super.只能调用父类的实例方法
this()调用该类的其他构造方法,this.调用类的属性，方法
如果父类有有参构造，子类必须定义构造方法

重载:

​ 重载发生在同一个类中；重载主要是针对同一个类中方法名相同但参数（必须的）不同或返回类型（不是必须的）不同的情况。可以参照如下的代码

语法：

public A(){}
public A(int a){}

六.继承

继承是面向对象程序设计的主要特征之一，它可以让您重用代码，可以节省程序设计的时间。继承就是在类之间建立一种相交关系使得新定义的派生类的实例可以继承已有的基类的特征和能力，而且可以加入新的特性或者是修改已有的特性建立起类的新层次。

base关键字和protected修饰符

都知道this表示当前实例，通过他可以访问类本身的成员，C#中还有一个关键字base，他表示父类，可以用于访问父类的成员。

在子类中可以用base调用父类的属性。实际上，还可以用base关键字调用父类的方法及父类的构造函数

父类中的成员如果用private修饰，他将作为私有成员，其他任何类都无法访问。如果设置为public成员，任何类都可以访问该成员。

在C#中提供了另一种访问修饰符protected，被这个访问修饰符修饰的成员允许被其子类访问，而不允许其他非子类访问

public ，private ，protected的区别

修饰符	类内部	子类	其他类
public	可以	可以	可以
protected	可以	可以	不可以
private	可以	不可以	不可以

可以看出，三种访问修饰符对类成员的访问限制强度:private>protected>public

子类构造函数

隐式调用父类构造函数

继承的价值

体会一下继承的特点

继承模拟了现实世界的关系，oop中强调一切皆对象，这符合我们面向对象编程的思考方向

继承实现了代码的重用，合理的使用继承，会使代码更加简洁

继承使程序结构清晰，子类和父类的层次结构清晰，最终的目的是使子类只关注子类的相关行为和状态，无须关注父类的行为与状态

解决继承带来的问题

像这种使用virtual 关键字修饰的方法，称为虚方法。虚方法有方法体

语法如下:

public virtual string SayHi(){
   //方法体
}

像这种使用virtual 关键字修饰的方法，称为虚方法。虚方法有方法体

public  override string SayHi(){
  //方法体
}

7.多态

里氏代换原则

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

举个例子:

先创建一个类

public class A()
{
	public void AA()
	{
		//代码块
	}
}

在创建一个类继承A类

public class B:A
{
	public void AA()
	{
		//代码块
	}
}

相当于子类拥有父类的全部方法和属性

运行之后可以直接调用父类的方法

is和as操作符的使用

is操作符用于检查对象的指定的类型是否兼容

例如:

List<A> list =new List<A>();
if(list[i] is B)
{
	//代码块
}

as操作符是用于两个类型的转换

例如:

List<A> list =new List<A>();
if(list[i] is B)
{
	B b =list[i] as B
}

抽象方法与抽象类

抽象方法：带abstract修饰的方法，定义时没有函数体，只能在派生类中写函数体。
抽象类：还有抽象方法的类就是抽象类，需要用abstract修饰，抽象类不能实例化。
对抽象方法的理解：抽象方法比虚方法还虚，虚到没有函数体了，只能在派生类中用override来重写

语法:

//访问修饰符 abstract 返回类型 方法名();

注意:含抽象方法的必然是抽象类

ic void AA()
{
//代码块
}
}

相当于子类拥有父类的全部方法和属性

运行之后可以直接调用父类的方法

**is和as操作符的使用**

is操作符用于检查对象的指定的类型是否兼容

例如:

```c#
List<A> list =new List<A>();
if(list[i] is B)
{
	//代码块
}

as操作符是用于两个类型的转换

例如:

List<A> list =new List<A>();
if(list[i] is B)
{
	B b =list[i] as B
}

抽象方法与抽象类

抽象方法：带abstract修饰的方法，定义时没有函数体，只能在派生类中写函数体。
抽象类：还有抽象方法的类就是抽象类，需要用abstract修饰，抽象类不能实例化。
对抽象方法的理解：抽象方法比虚方法还虚，虚到没有函数体了，只能在派生类中用override来重写

语法:

//访问修饰符 abstract 返回类型 方法名();

注意:含抽象方法的必然是抽象类