第一部分 ：C#的基本数据类型、数值类型、图形基础

任何一门语言，基础知识非常重要。就昨天所遇到的问题：数据运算得到的值是 0 。程序的运算不是我们所学的数学运算，只用加减乘除就能直接得出结果。还要使用数据类型来使这个数的结果是我们所想要的。比如使用int类型得到的值永远是int的，并且会进行向下取值。要得到准确的数值可以选择使用double类型。
1.C#数据类型及转换
2.类的创建与使用
3.类的继承和多态
4.接口创建与实现
5.委托与事件

成都创新互联专注于甘德企业网站建设,成都响应式网站建设公司,购物商城网站建设。甘德网站建设公司,为甘德等地区提供建站服务。全流程按需定制设计，专业设计，全程项目跟踪，成都创新互联专业和态度为您提供的服务第一章 c#语言基础 1.1 数据类型 1.1.1简单类型

整数类型、布尔类型、字符类型、浮点类型、decimal
例如：byte、short、int、long、uint(无符号32位整数)、
float、double
decimal：用于财务和货币计算的128位数据类型。例如：decimal myMoney = 100.3m;
布尔类型：C#中逻辑量只有 true 和 false。

1.1.2结构类型

结构类型是一种值类型。而类类型是一种引用类型
结构主要用于创建小型的对象以节省内存，如：复数、坐标系中的点、字典中的“键-值”对都是结构的典型示例。

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;
	}
}

1.1.3 枚举类型

用于声明一组命名的常数。每种枚举类型均有一种基础类型，此基础类型可以是除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}
}

1.1.4 数组类型

是由抽象基类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];

1.1.5 类类型

类是C#中最重要的组成部分，也是C#基础，它用来生成新的引用类型。类是一种数据结构，
object 、 string

1.1.6 类型转换

隐式转换、显式转换、用户自定义转换
例如： int a = 100; float b=a;

1.2 类

所有内容都被封装在类中，类是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元起，快前往官网查看详情吧

网站题目：《C#:二维三维图形绘制》阅读记录-创新互联
URL标题：http://lszwz.com/article/dhsopp.html