结构和类
结构是从过程化程序设计中保留下来的一种数据类型，类则是面向对象程序设计中最基本的、也是最重要的概念。
结构
结构是一种值类型，通常用来封装一组相关的变量，结构中可以包含构造函数、变量、字段、方法、属性、运算符、事件和嵌套类型等。结构实际上就是将多个相关的变量包装为一个整体来使用。
结构的特点：
-
结构是值的类型。
-
向方法传递结构时，结构是通过传值的方式传递的，不是引用传递。
-
结构的实例化不可以用new
-
结构可以声明构造函数，但是必须带参数
-
结构可以实现接口
C#中使用struct来声明结构，语法：
结构修饰符 struct 结构名
{
}
例如：
public struct Rect
{
public double width;//宽
public double heigth;//高
public double Area()
{
return width * heigth;
}
}
结构的使用
首先声明一个矩形结构，定义矩形的宽和高，然后在这个结构中定义一个构造函数，用来初始换宽和高，自定义一个方法，Area。然后在Main方法中实例化矩形结构的一个对象，调用结构的自定义计算面积的方法来计算矩形面积。最后使用矩形结构的构造函数再次实例化矩形结构的一个对象，并再次调用结构中自定义方法计算矩形面积。
class Test1
{
public struct Rect
{
public double width;
public double heigth;
public Rect(double x, double y)
{
width = x;
heigth = y;
}
public double Area()
{
return width * heigth;
}
}
static void Main(string[] args)
{
Rect rect1;
rect1.width = 5;
rect1.heigth = 3;
Console.WriteLine("面积为：" + rect1.Area());
Rect rect2 = new Rect(6, 4);
Console.WriteLine("面积为：" + rect2.Area());
}
}
结果：
面积为：15 面积为：24
面向对象概述
因为结构化语言不适合大规模的软件开发，所以这时候就需要一种开发思想，就是面向对象的开发思想，它将所有预处理的问题抽象为对象，同时了解这些对象具体有哪些相应的属性以及展示这些对象的行。
对象
在面向对象中，算法和数据结构被看作一个整体，称为对象，现实世界中如何类的对象都具有一定的属性和操作。
对象=（算法+数据结构），程序=（对象+对象+...）
面向对象程序的设计思想就是要以对象来思考问题，首先要将现实世界的实体抽象为对象，如何考虑这个对象具备的属性和行为。
类
类就是一类事物的统称，如果现实世界中的一个事物抽象成对象，类就是这类对象的统称。类是构造对象时所依赖的规范，比如，鸟具有一对翅膀，它可以通过这对翅膀飞行，基本上所有的鸟都具有翅膀这个特性和飞行的技能，这样具有相同特征和行为的一类事物就称为类。
类是世间事物的抽象称呼，对象是这个事物相对应的实体。
在C#中，类中对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的。
面向对象程序有三大特点：
-
封装
-
继承
-
多态
封装
封装就是面向对象编程的核心思想，将对象的属性和行为封装起来，而将它们封装起来的载体就是类，类通常对客户隐藏实现细节，这就是封装的思想。
采用封装的思想保证了类内部数据结构的完整性，应用该类的用户不能轻易直接操作此数据结构，只能执行允许公开的数据。避免了外部对内部数据的影响，提高了程序的可维护性。
继承
继承就是主要利用特定对象之间的共有属性。比如图形可以分为三角形，四边形，圆形等，其中，图形就是父类，那些具体的形状就是子类，是继承了图形这个父类。其中，要注意的是，可以说三角形是图形，但是不能说图形是三角形，等同于，可以说子类的实例都是父类的实例，但是不能说弗雷德实例都是子类的实例。
一个类在继承中，它既可以是其他类的父类，为其他类提供属性和行为，也可以是子类，继承父类的属性和方法。例如三角形是图形类的子类，但是也是等边三角形的父类。
多态
多态是什么？按照我的理解，就是将父类对象应用于子类的特征。还是可以用图形类的例子来举例，比如，一个图形可以进行绘制，那么它的子类也需要绘制的能力，我们就可以在父类写一个绘制方法，将它的子类的对象统一看作是父类的实例对象，他的子类，比如三角形，需要绘制的时候，就可以调用父类的绘制方法。
多态的实现？多态的实现并不是依赖于具体的类，而且依赖于抽象类和接口。比如图形类绘制的方法，我们需要的只是图像类有一个绘制能力，如何被子类去调用，但是具体要绘制什么东西，需要根据调用的子类去决定，所以我们就需要一个模糊的定义，只是要绘制，而不是具体，这就是抽象类。
对于多态来说，接口的使用比抽象类更加方便， 由查询方法组成的集合就是接口。
类
类是一种数据结构，可以包含数据成员，函数成员，嵌套类型。其中，类支持继承。
类的概念
类是对象概念在面向对象编程语言的反映，是相同对象的集合。它可以把一个对象的各种属性包含在其中，比如，汽车类，可以有颜色，编号，厂家等信息。
类的声明
类修饰符 class 类名
{
}
例子：
public class Car
{
public int number;//编号
public string color;//颜色
public string brand;//厂家
}
构造函数
定义：主要用来对对象进行初始化和回收对象资源。一般对象的生命周期都是由构造函数开始的。构造函数具有与类相同的名称，通常初始化新对象的数据成员。
使用：
class Program
{
public int x = 3;
public int y = 5;
public int z = 0;
public Program()
{
z = x + y;
}
static void Main(string[] args)
{
Program program = new Program();
Console.WriteLine(program.z);
}
}
结果：
8
其中，构造函数是没有带参数的，叫做”默认构造函数“。
对象的创建及使用
1.对象的创建
对象可以认为是在一类事物中抽象出某一个特例，通过这个特例来处理这类事物出现的问题。可以通过new来创建对象。
语法：
Test test = new Test();
Test test = new Test("a");
其中，参数说明：
Test：类名；test：对象；new：创建对象操作符；”a”：构造函数的参数。
test被创建出来的时候，test对象就是一个对象的引用，在内存中为对象分配了存储空间，可以在构造函数中初始化成员变量，在创建对象时，自动调用构造函数，所以说，初始化和创建是被捆绑在一起的。
2.访问对象属性和行为
通过new操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。由于对象的属性和行为在类中是通过类成员变量和方法的形式表示的，所以我们要用对象获取成员的时候，就相应的获取了对象的属性和行为。
例子：
using System.IO.IsolatedStorage;
class Progrom
{
int i = 47;
public void call()
{
Console.WriteLine("调用call方法");
for (i = 0; i < 3; i++)
{
Console.Write(i + " ");
if (i==2)
{
Console.WriteLine("\n");
}
}
}
public Progrom()
{
}
static void Main(string[] arge)
{
Progrom t1 = new Progrom();
Progrom t2 = new Progrom();
t2.i = 60;
Console.WriteLine("第一个实例对象调用变量i的结果" + t1.i++);
t1.call();
Console.WriteLine("第二个实例对象调用变量i的结果" + t2.i++);
t2.call();
Console.ReadLine();
}
}
结果：
第一个实例对象调用变量i的结果47 调用call方法 0 1 2 第二个实例对象调用变量i的结果60 调用call方法 0 1 2
3.对象的引用
引用只是存放一个对象的内存地址，并非是存放一个对象。
4.对象的销毁
每个对象都有生命周期，当生命周期结束时，给该对象分配的内存地址将会被回收，C#可以自动回收，它有一套完整的垃圾回收机制。
其中，会被回收的对象有以下两种情况：
-
对象引用超过其作用范围
-
将对象赋值为null
类和对象关系
对象就是一个类的实例。
类是具有相同或相似结构、操作和约束规则的对象组成的集合，对象是某一类的具体化实例，每一个类都是具有某些共同特征的对象的抽象。
类的面向对象特性
类的封装
类可以使数据和方法封装成单一的元素，以便于通过方法来存取数据。
这样有很多好处：
-
方便维护升级
-
可以在操作数据的时候多一层判断
-
可以解决数据存取的权限问题，可以使用封装将数据隐藏起来，根据类的成员使用的不同修饰符来定义它们的访问级别
-
可以增强安全性和简化编程
class Myclass
{
private int x = 0;
private int y = 0;
//加数
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
public int Y
{
get
{
return y;
}
set
{
y = value;
}
}
public int Add()
{
return X + Y;
}
}
class Program
{
static void Main(string[] arge)
{
Myclass myclass = new Myclass();//实例化Myclass的对象
myclass.X = 3;
myclass.Y = 5;
Console.WriteLine(myclass.Add());
Console.ReadLine();
}
}
结果：
8
类的继承
任何类都可以从另外一个类继承，这个类拥有它继承的类的所有成员，被继承类叫做父类或者基类。但是只支持单继承，不支持多重继承，依次只允许继承一个类，不能继承多个类。继承的基本思想是基于父类的扩展，制定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加原来父类所不具备的属性和方法，或者直接重写父类的某些方法。例子：
//继承
class MyClass
{
private int x = 0;
private int y = 0;
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
public int Y
{
get
{
return y;
}
set
{
y = value;
}
}
public int Add1()
{
return X + Y;
}
}
class MyClass1 : MyClass
{
private int z = 0;
public int Z
{
get
{
return z;
}
set
{
z = value;
}
}
public int Add2()
{
return X + Y + Z;
}
}
class Progeam
{
static void Main(string[] args)
{
MyClass myclass = new MyClass();
MyClass1 myclass1 = new MyClass1();
myclass.X = 3;
myclass.Y = 5;
myclass1.X = 3;
myclass1.Y = 5;
myclass1.Z = 7;
Console.WriteLine(myclass.Add1());
Console.WriteLine(myclass1.Add1());
Console.WriteLine(myclass1.Add2());
}
}
结果：
8 8 15
类的多态
多态使子类的实例可以直接赋予父类的变量，然后直接就可以通过这个变量调用子类的方法。比如，需要一个绘制正方形的方法，我们不可以在他的父类（四边形）里面定义一个绘制四边形的方法，再定义一个绘制正方形方法，那就冗余了，可以在四边形定义一个draw（）方法，使每个继承四边形类的对象作为draw的参数，然后在draw中做一些限定就可以根据不同图形类对象绘制相应的图形。
例子：
//多态
class Program
{
private Program[] qtest = new Program[6];
private int nextIndex = 0;
public void draw(Program q)
{
if (nextIndex<qtest.Length)
{
qtest[nextIndex] = q;
Console.WriteLine(nextIndex);
nextIndex++;
}
}
static void Main(string[] args)
{
Program q = new Program();
q.draw(new Square());
q.draw(new Parallelogramgle());
Console.ReadLine();
}
}
class Parallelogramgle : Program
{
public Parallelogramgle()
{
Console.WriteLine("平行四边形");
}
}
class Square : Program
{
public Square()
{
Console.WriteLine("正方形");
}
}
结果：
正方形 0 平行四边形 1
3105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
