一、.net面向对象

什么是面向对象？

1、面向对象编程英文 Object-Oriented Programming 简称 OOP

2、面向过程——是指把问题分解成步骤，一步一步实现。

面向对象——是把构成问题的事务分成各个对象，利用对象之间的关系来解决问题，面向对象因为把事务分成各个对象，所以更容易实现对象的封装，对象的复用。这也就是面向对象的几种特征（封装、继承、多态）。

为了更明白一点，举个例子：要解决去某水表制造公司上班这个问题，采用面向对象
先分解成对象
1.起床 这是一个对象，里面有成员（穿衣、洗脸、刷牙、吃饭）
2.上路 这是第二个对象，里面有成员（交通工具、路线）
3.到岗 这是第三个对象，里面有成员（签到）
4.上班 这是第四个对象，也是一天上班的核心对象，这个对象可以比较复杂一点，包含的成员比较多（进入工作任务、开始抄水表、完成工作流程、汇报工作等）
5.下班 这是第四个对象，这个对象，也有成员（交通工具和路线）这个和上班走同样的路线，只是方向不同，这里可以用到面向对象的一点重用的特性。
通过个例子，就使用面向对象编程的方式完成了一个《水表公司上班超级系统》

二、.net数据类型

1、基本数据类型（C#就15种数据类型）

分类：值类型（13个），引用类型（2个：string和object）

整型8个，浮点型 1个，decimal 型 2个，布尔类型 1 个，char字符类型 1 个，引用类型（string字符串类型1个、object类型1个）

QC:命名空间的作用：

using system; //引用系统命名空间，主要是 int、bool等基本类的命名空间
using system.collection.generic;//主要是泛型集合的命名空间 List<T>……
using system.test;//这个应该是自己定义的命名空间
使用命名空间的好处是 减少代码量
例如:
使用命名空间 Using system;
int a=100;

Console.WriteLine(a);
========================================
不使用命名空间
那么完成相应的事情，就要写：http://System.int a = 100;
System.Console.WritelLine(a);

关于转义字符

为了使用一些特殊的字符型 ，C#使用转义字符

字符型中有下列转义符:
1，'用来表示单引号
2，"用来表示双引号
3， 用来表示反斜杠
4， 0 表示空字符
5， a 用来表示感叹号
6， b 用来表示退格
7， f 用来表示换页
8， n 用来表示换行
9， r 用来表示回车
10， t 用来表示水平tab
11， v 用来表示垂直tab

要点：

1.数据类型分为 值类型 (Value type) 和 引用类型 (reference type)

2.值类型存储实际值，而引用类型则为对存储在内存中某处的值的引用

3.string为引用类型，char为值类型

4.所有值和引用类型都由一个名为object的基本类发展而来

5.枚举(enum) 和结构(struct)为值类型

6.类、接口、数组、委托为引用类型

2、数据类型的转换

（1）c#类型转换的方式： 隐式转换、显示转换、用户自定义转换、使用帮助程序类的转换

隐式转换：由于该转换是一种安全类型的转换，不会导致数据丢失，因此不需要任何特殊的语法。 例如，从较小整数类型到较大整数类型的转换以及从派生类到基类的转换都是这样的转换。

显式转换（强制转换）：显式转换需要强制转换运算符。 在转换中可能丢失信息时或在出于其他原因转换可能不成功时，必须进行强制转换。典型的例子包括从数值到精度较低或范围较小的类型的转换和从基类实例到派生类的转换。

用户定义的转换：可以定义一些特殊的方法来执行用户定义的转换，从而使不具有基类–派生类关系的自定义类型之间可以显式和隐式转换。

使用帮助程序类的转换：若要在不兼容的类型之间进行转换，例如在整数与 DateTime 对象之间转换，或者在十六进制字符串与字节数组之间转换，则可以使用 BitConverter 类、Convert 类和内置数值类型的 Parse 方法，例如 Int32.Parse。

（2）装箱和拆箱转换（Boxing,UnBoxing）

主要是值类型与引用类型之间相互转换

如：object obj 1= 10;

int i = (int)obj; //拆箱

int j = 100;

object obj2 = j; //装箱

（3）string类型转换成int类型 bool result = Int32.TryParse(value （string类型）, out number（int类型）);

int.Parse 方法或者 int.TryParse方法都可以将一个string类型的数据转换成int类型。

①int.Parse法：——

intA =int.Parse(str);

②int.TryParse法

int.TryParse(str, out intA)；

（4）Convert类实现数据类型转换

ToBoolean 将指定的值转换为等效的布尔值
ToByte 将指定的值转换为8位无符号整数
ToChar 将指定的值转换为Unicode字符
ToDateTime 将指定的值转换为DateTime
ToDecimal 将指定值转换为Decimal数字
ToDouble 将指定的值转换为双精度浮点数字
ToInt16 将指定的值转换为16位有符号整数
ToInt32 将指定的值转换为32位有符号整数
ToInt64 将指定的值转换为64位有符号整数
ToSByte 将指定的值转换为8位有符号整数
ToSingle 将指定的值转换为单精度浮点数字
ToString 将指定值转换为其等效的String表示形式
ToUInt16 将指定的值转换为16位无符号整数
ToUInt32 将指定的值转换为32位无符号整数
ToUInt64 将指定的值转换为64位无符号整数
那么，类型.Parse与Convert有什么区别呢？他们的区别在于Parse的参数只能是字符串类型(string)，只能把字符串类型转成其它类型，而Convert可以某一对象的值转换成很多类型。
如：
bool Bl = = true;
int a = Convert.ToInt16(Bl); //只能这样转换，否则通不过。

（5）日期类转换

字符串转日期
string dateString = "5/1/2008 8:30:52 AM";
DateTime date1=DateTime.Parse(dateString,System.Globalization.CultureInfo.InvariantCulture);

日期转字符串
DateTime dat1 = new DateTime();

string datastr=
dat1.ToString(System.Globalization.CultureInfo.InvariantCulture);

三、变量和常量

1.常量：在编译时其值能够确定，并且程序运行过程中值不发生变化的量.

通俗来说，就是定义一个不能改变值的量。既然不能变动值，那就必须在定义的时候初始化。

示例：

语法: const 类型名 常量名=常量表达式;

例子: const string cat="hello cat";

2.变量：具有变量名和值的对象

变量就是把数据暂存于某处内存中，以备调用。

示例：

声明：[访问修饰符] 类型 变量名[=初值][变量名=[初值]...];

int int1,int2,int3=3,int4;

3.变量的作用域

变量可以使用修饰符，可用的修饰符如下：

public 不限制访问。

protected 仅限于当前类和派生类。

Internal 访问仅限于当前程序集。

protected internal 访问仅限于当前程序集或从当前派生的类。

private 仅限于当前类。

除以上修饰符外，还可以使用 static(静态)和readonly(只读)

3.命名规范

变量和方法参数命名：根据不同的数据类型前缀+首字母大写的变量描述

要点：

1.但是在方法体内声明的变量，不可以用public private等访问修饰符修饰；

2.在类中声明的变量，称为字段或成员变量；

3.变量名必须是字母或下划线开头不能有特殊符号；

4.变量可以同一语句中声明多个，用逗号分开；

5.变量申明时，可以赋值，也可以不赋值。

6.常量和只读变量区别：

a.常量必须在声明时就被初始化,指定了值后就不能修改了.

只读字段可以在声明时被初始化,也可以在构造函数中指定初始化的值,在构造 以后值就不能修改.

b.常量是静态的,而只读字段可以是静态和动态的

c.Const可以用在字段和局部变量,readonly只可以修饰字段

四、运算符和表达式

1.运算符分类和优先级

2.表达式分类

按运算符数目可分为：一元表达式，二元表达式，三元表达式

按用途分类：正则表达式、Lambda表达式等等。

关于这些复杂类型的表达式，后续会再作详细说明。

要点：

1. / 除法运算符 5/2=2 (并非四舍五入，而是舍去小数)

2. %取模运算符 5%2=1 5.0%2.2=0.6 (第2数整除第1数的余数)

3. ++ 递增运算符 -- 递减运算符

以上两个运算符 ，可以在前也可以在后， 但是在前和在后，其执行顺序不同 例如：

int a=1; int b=a++;

运算符在后，则程序先把a的值赋给b,再对a执行+1；

其运行结果为: a=2 b=1

如果写成下面的例子：

int m=1;int n=++m;

则执行完以后结果为： m=2 n=2;

实际上相当于 int m=1; m=m+1; int n=m;

4.位移运算符<<(左移) 和 >>（右移）

这两个运算符比较不常用，按官方的理解稍有点复杂

可以这样理解：其实就是数据转换成二进制的左右移动;

右移左补0，左移右补0，后面多出来的部分去掉。

如：把89右位移一位,可以这样计算:

string flag = Convert.ToString(89, 2); //这是把你的89转为2进制数。。

//flag结果：1011001

//你要右位移，左边补个0，后面多出来一位去掉

int j = Convert.ToInt32("0101100", 2); //再把2进制转化了10进制数。。

//结果：44

//位移就是这么简单

5.逻辑异或运算符 ^

对于简单逻辑运算符 & || 我们比较熟悉了，但对于异或好多人就 不了解，甚至很少用到

理解这个运算符，首先它虽然是逻辑运算符，但也是可以运算整数的

先说布尔运算,简单说，就是两个操作数不同，则为真；相同时为假

如：true ^ true=false; false^false=false; true ^false=true; false ^true=true;

操作整数时,则进行位运算，如：

100^45=73

数值运算举例

按位异或的3个特点:

(1) 0^0=0,0^1=1 0异或任何数＝任何数

(2) 1^0=1,1^1=0 1异或任何数－任何数取反

(3) 1^1=0,0^0=0 任何数异或自己＝把自己置0

例如：10100001^00010001=10110000

按位异或的几个常见用途:

(1) 使某些特定的位翻转

例如对数10100001的第2位和第3位翻转，则可以将该数与00000110进行按位异或运算。

10100001^00000110 = 10100111

(2) 实现两个值的交换，而不必使用临时变量。

例如交换两个整数a=10100001，b=00000110的值，可通过下列语句实现：

a = a^b； //a=10100111

b = b^a； //b=10100001

a = a^b； //a=00000110

(3) 在汇编语言中经常用于将变量置零：

xor a，a

(4) 快速判断两个值是否相等

举例1: 判断两个整数a，b是否相等，则可通过下列语句实现：

return ((a ^ b) == 0)

1. 字符和字符串运算

由于字符可以隐式转为整型,如 ‘a’+6=103 a被转为Unicode 97

‘a’*’b’=9506 相当于 97*98

‘a’>’b’结果为false 相当于97>98 返回false

‘a’ +”早上好” 返回 “a早上好”

由此可见。不同类型运算在C#中会先执行一次隐式转换

学习： http://edu.51cto.com/c222faa0-275f-42cb-85e6-e161b5dd0bff

四、异常：

 Console.WriteLine("请输入一个数：");//第一种异常：类型转换错误int num = int.Parse(Console.ReadLine());//第二种：存储的值超过范围Console.WriteLine("请输入一个数：");byte num2 = byte.Parse(Console.ReadLine());//第三种：除数为0double num03 = num / num2;//第四种：数组超过索引范围int[] array = { 1,2,3,4,5,6};foreach(int item in array){Console.WriteLine("{0}",item);}//第五种：连接数据库发生的异常Console.ReadKey();