任何一门语言，基础知识非常重要。就昨天所遇到的问题：数据运算得到的值是 0 。程序的运算不是我们所学的数学运算，只用加减乘除就能直接得出结果。还要使用数据类型来使这个数的结果是我们所想要的。比如使用int类型得到的值永远是int的，并且会进行向下取值。要得到准确的数值可以选择使用double类型。
1.C#数据类型及转换
2.类的创建与使用
3.类的继承和多态
4.接口创建与实现
5.委托与事件
整数类型、布尔类型、字符类型、浮点类型、decimal
例如：byte、short、int、long、uint(无符号32位整数)、
float、double
decimal：用于财务和货币计算的128位数据类型。例如：decimal myMoney = 100.3m;
布尔类型：C#中逻辑量只有 true 和 false。
结构类型是一种值类型。而类类型是一种引用类型
结构主要用于创建小型的对象以节省内存，如：复数、坐标系中的点、字典中的“键-值”对都是结构的典型示例。
using System;
struct Rectangle
{public int x,y;
public int width,height;
public Rectangle(int a,int b,int w,int h)
{x=a;
y=b;
width=w;
height=h;
}
}
class TestStruct
{public static void Main()
{Rectangle myRect;
myRect.x = 20;
myRect.y = 30;
myRect.width = 200;
myRect.height = 300;
}
}用于声明一组命名的常数。每种枚举类型均有一种基础类型，此基础类型可以是除char类型外的任何类型。
枚举元素的默认基础类型为int。例如：
enum WeekDay{Sun,Mon,Tue,Wed,Thu,Fri,Sat}
不同元素的值可以相同。
如果枚举元素的数据类型不是int型，则可以用如下方式进行声明。
enum Color:long{Red,Green,Blye};
示例：使用枚举
using System;
public class TestEnum
{enum Range:long{Max=214723233L,Min=255L}
public static void Main()
{long a = (long)Range.Max;
long b = (long)Range.Min;
}
// 下面再看一个例子：
enum Color{Red=Green,Green,Blue}
}是由抽象基类System.Array派生的引用类型，代表一组相同类型变量的集合，其中每一个变量称为数组的元素。
数组元素可以为任意类型，包括数组类型。
对数组元素的访问是通过数组下标来实现的。
声明一个数组时，方括号必须跟在类型后面，例如： int[] color
可以指定数组的长度 ： int[5] color;
1.一维数组和多维数组
int[] a = new int[3];
// 为每个数组元素赋值，完成初始化
a[0] = 1;
a[1] = 2;
a[2] = 3;
// 声明一个2行2列的二维数组如下。
int[,] a = new int[2,2];
// 为每个数组元素赋值，以完成初始化
a[0,0] =1;
a[0,1] =2;
a[1,0] =3;
a[1,1] =4;
// 声明一个三维数组
int[,,] b = new int[3,2,2];类是C#中最重要的组成部分，也是C#基础，它用来生成新的引用类型。类是一种数据结构，
object 、 string
隐式转换、显式转换、用户自定义转换
例如： int a = 100; float b=a;
所有内容都被封装在类中，类是C#基础。
（1）类声明
class关键字、类名、类体
类修饰符包括 new、public、protected、internal、private、abstract
声明一个Person类：
using xxx;
public class Person
{private string name;
private int age;
private long ID;
public Person(string n,int a,long I)
{name = n;
age = a;
ID = I;
}
}
该类声明了三个私有数据成员 name、age、ID。两个共有函数成员Person和Display（2）创建类实例
声明了类之后，就可以通过new 关键字来创建类实例，类实例是一个引用类型的变量。类实例创建的格式为 ： 类名 实例名 = new 类名（参数） Person p = new Person()
实际上，是使用new关键字调用类的构造函数完成类的初始化工作。
（3）类成员
类成员分为两大类。
类本身声明的成员和从基类继承来的成员。
类成员包括函数成员和数据成员。
声明一个含有静态成员和一个实例成员的Student类
using System;
class Student
{int SNO; // 实例成员
static int count; // 静态成员
public Student(int s)
{SNO = s;
Count++;
}
public void display()
{ }
public static void Main()
{Student s1 = new Student(12);
s1.display();
}
}
在上例子中，每生成一个学生实例，静态成员count就自动增一。（4）构造函数和析构函数
构造函数是特殊的成员函数，主要用于为对象分配空间，完成初始化工作。构造函数的特殊性表现在以下几个方面。
构造函数的名字必须与类名相同
构造函数可以带参数，但没有返回值
构造函数在对象定义时被自动调用
使用构造函数和析构函数：
using System;
class Complex
{double imag,real;
public Complex(){} // 无参数构造函数
public Complex(double r,double i)
{imag = i;
real = r;
}
~Complex(){} // 析构函数
}（5）方法
方法是表现类或对象行为的成员函数，用于把程序分解为小的单元。
方法声明
方法声明的格式：
属性集 方法修饰符 返回类型 方法名（形参列表）{方法体}
方法的修饰符：new public void ......
方法参数：值参数、引用参数、输出参数和参数数组
使用参数：
class TestValue
{static void Swap(int a ,int b)
{int t;
t=a;
a=b;
b=t;
}
static void Main()
{int x=10,y=20;
Console.WriteLine("x={0},y={1}",x,y);
Swap(x,y);
Console.WriteLine("x={0},y={1}",x,y);
}
}
输出结果为 x=10,y=20
x=10,y=20;
示例中的函数Swap有两个值参数a和b，在函数内交换了a和b的值并不影响原自变量x和y的值。
引用参数
用ref修饰符声明的参数为引用参数。
使用引用参数
class TestValue
{static void Swap(ref int a , ref int b)
{int t;
t = a;
a = b;
b = t;
}
static void Main()
{int x=10,y=20;
Console.WriteLine("x={0},y={1}",x,y);
Swap(ref x,ref y);
Console.WriteLine("x={0},y={1}",x,y);
}
}
输出结果为
x=10,y=20
x=20,y=10
示例中的函数Swap有两个引用参数a和b，在函数内交换a和b的值同时也交换了原自变量x和y的值。输出参数
用out修饰符定义的参数称为输出参数。如果希望函数返回多个值，可使用输出参数。
class TestOut
{static int OutMultiValue(int a,out char b)
{b=(char) a;
return 0;
}
static void Main()
{int t = 65,r;
char m;
r=OutMultiValue(t,m);
Console.WriteLine("r={0},m={1}",r,m);
}
}
输出结果为 r = 0 m = A参数数组
用params修饰符声明的变量称为参数数组，它允许向函数传递个数变化的参数。
使用参数数组：
using System;
class TestParams
{static void MultiParams(params int[] var)
{for(int I=0;Iint[] arr = {10,20,30};
MultiParams(arr);
MultiParams(100,200);
MultiParams();
}
} 静态方法和实例方法
用static修饰符 声明的方法为静态方法，未用static修饰符声明的方法为实例方法。
静态方法不对特定实例进行操作，不与实例相关联，它属于类。因为静态方法和类相关联，所以调用静态方法不需要创建类实例。要调用静态方法，只需要类名和方法名。静态方法只能访问类中的静态成员，访问非静态成员是错误的。
实例方法对类的某个给定的实例进行操作，而且可以用this来访问该实例。它属于实例对象。实例方法可以访问类中的任何成员。
using System;
class TestMethod
{static int x; // 静态数据成员
int y; // 非静态数据成员
static void A()
{x=10; // 正确，在静态方法中访问静态成员
y=20; // 错误，在静态方法中访问非静态成员
}
void B()
{x=10; // 正确，在实例方法中访问静态成员
y=20; // 正确，在实例方法中访问非静态成员
}
static void Main()
{TestMethod t = new TestMethod();
TestMethod.A(); // 使用类名调用静态方法
t.B(); // 使用实例调用实例方法
}
}方法重载
方法重载允许一个类中有同名的方法存在，即一个类中可以有两个以上的方法取相同的名字。为了区分这些同名的方法，要求方法有不同的参数，要么参数个数不同，要么参数类型不同。
使用方法重载：
using System;
class TestMethod
{int square(int x)
{return x*x;
}
double square(double x)
{return x*x;
}
decimal square(decimal x)
{return x*x;
}
static void Main()
{TestMethod t = new TestMethod();
Console.WriteLine("The square is {0},{1},{2}",t.square(10),......)
}
}
该类有三个重载函数square，用于计算int、double、decimal类型数的平方。三个函数的区别在于参数类型不同。操作符重载
操作符重载可以对C# 中已有的操作符赋予新的功能
重载Point类的 “++” 和 "+"操作符
using System;
class Point(int a,int b)
{private int x,y;
public Point(int a ,int b)
{x=a;
y=b;
}
//操作符"++"重载
public static Point operator ++(Point p)
{p.x ++;
p.y ++;
return p;
}
public void Display()
{Console.WriteLine("Point.x={0},Point.y={1}",x,y);
}
// 操作符 "+" 重载
public static Point operator +(Point p1,Point p2)
{Point p = new Point(0,0);
p.x = p1.x + p2.x;
p.y = p1.y + p2.y;
return p;
}
static void Main(string[] args)
{Point a = new Point(10,20);
Point b = new Point(30,40);
a = a+b;
a.Display();
a++;
a.Display();
}
}
程序输出结果： Point.x=40,Point.y=60 Point.x=41,Point.y=61
程序中分别对一元运算符“++”和二元运算符“+”进行了重载。分别完成点的坐标值自增一和两个点坐标相加的功能。this关键字
引用类的当前实例，成员通过this关键字可以知道自己属于哪个实例。this关键字是一个隐含引用，它隐含于每个类的成员函数中。但需要注意的是静态成员函数没有this指针。this关键字可用于从构造函数、实例方法和实例访问器中访问成员。
以下是this的常用用途。
~ 限定被相似的名称隐藏的成员。例如：
public Employee(string name,string alias)
{this.name = name ;
this.alias = alias;
}
~ 将对象作为参数传递到其他方法，例如：
CalcTax(this)
~ 声明索引器，例如：
public int this [int param]
{get
{return array[param];
}
set
{array[param] = value;
}
}（6）字段与属性
字段
字段表示与对象或类相关联的变量。字段包括静态字段、实例字段和只读字段。用static修饰符声明的字段为静态字段，与静态变量相同，无论存在多少个类实例，他们都共享一个静态字段副本。
使用字段：
using System;
class Goods
{public double high;
public readonly double width = 30;
public static int count = 0;
public Goods(double h,double w)
{high = h;
width = w;
count ++;
}
static void Main(string[] args)
{Goods y = new Goods(100,200);
Console("high={0},width={1};count={2}",y.high,y.width,Goods.count);
Goods z = new Goods(300,400);
Console(...);
}
}
输出结果为：high=100,width=200,count=1
high=300,width=400,count=2
以上例子声明了实例字段high，它的生命周期为类实例生成到类实例撤销为止。静态字段count，它的生命周期为类的载入到类的撤销为止。只读字段width，它的生命周期与实例字段相同。如果在类Goods中声明一个函数:
public void setwidth(double w)
{width = w;
}
则会出现错误，因为只读字段的值只能在声明时和在构造函数中改变。属性
属性用于刻画对象的特征或表示对象的状态,它提供对类或对象性质的访问。比如窗口标题、窗口位置、客户名称等，都可以作为属性。属性和字段不同，它不表示存储位置，相反，属性有访问器。
给属性赋值时使用访问器set,set访问器始终使用value设置属性的值。获取属性值时使用访问器get，get访问器通过return返回属性的值。在访问声明中，如果只有get访问器，表示是只读属性；如果只有set访问器，表示是只写属性。
使用属性：
class Window
{private double m width = 30;
public double width
{get
{ return m width;
}
set
{ m width = value;
}
}
static void Main(string[] args)
{Window y = new Window();
y.width=200;
Console("{0}",y.width);
}
}（7）继承
继承是面向对象程序设计的一个重要特征，它允许在既有类的基础上创建新类，新类从既有类中继承成员，而且可以重新定义或加进新的成员，从而形成类的层次或等级。一般称为继承的类为基类或父类，而称继承后产生的类为子类。
C#继承的重要性质：
1、C#只允许单继承，即派生类只能有一个基类。
2、C#的继承是可传递的，如果C从B派生，而B从A派生，那么C就会即继承在B中声明的成员，又继承在A中声明的成员；
3、派生类扩展它的直接基类，即派生类可以添加新的成员，但不能删除从基类继承的成员
4、构造函数和析构函数不能被继承
5、派生类可以隐藏基类的成员，如果在派生类中声明了与基类同名的新成员时，基类的该成员在派生类中就不能被访问到。
派生类的声明：
属性类修饰符class类名：基类{类体}
在类声明中，通过在类名的后面加上冒号和基类名表示继承。
public class Employee:Person
{private string department;
private decimal salary;
public Employee(string n , int a ,long i ,string d,decimal s):base(n,a,i)
{department=d;
salary = s;
}
public override void Display()
{base.Display();
}
新类继承了基类的成员name、age、ID，并添加了新的成员department和salary，重载了Display成员函数，让Display成员函数不但显示员工的姓名、年龄和身份证号，而且显示员工所属的部门和薪水。base关键字
base关键字用于从派生类中访问基类的成员，它有两种基本用法：
指定创建派生类实例时应调用的基类构造函数，用于调用基类的构造函数完成对基类成员的初始化工作；
在派生类中访问基类成员。
如上述例子在创建派生类Employee实例时，使用base调用其基类Person的构造函数；在派生类Employee的display方法中，使用了base关键字调用基类的Display方法。
后面的接口 、委托什么的感觉看起来好吃力，因为平时写代码用的也比较少，不能准确的理解其的意义。先搁置起来吧，接下来学习第二章。
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧