面向对象

1、面向对象
2、类和对象
3、属性
4、静态和非静态的区别
5、new关键字
6、this关键字
7、构造函数
8、析构函数

1 面向对象

面向过程：就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向对象：是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。（意在写出一个通用的代码，屏蔽差异）

2 类和对象

类和**对象(class 万物皆对象)**是两种以计算机为载体的计算机语言的合称。对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型。类不占控件，对象才占空间。
它们的关系是，对象是类的实例，类是对象的模板。对象是通过new 产生的，用来调用类的方法;类的构造方法 。
语法：
[访问修饰符] Class 类名
{
字段；//fields——存储数据
属性；//property——保护字段
方法；//method——描述行为
}//其中字段，属性和方法统称为类的成员，且都需要定义访问级别,类中可以包含变量的定义和方法的定义。

class Person//自定义类{//字段，通常以下划线开头，一般是private修饰的，存储数据的private string _name;private int _age;private char _gender;//属性——保护字段的public string Name{//当输出属性的值的时候，会执行get方法get { return _name; }//当你给属性值的时候，首先会执行set方法set { _name = value; }}public int Age{get{return _age;}set{_age = value;}}public char Gender{get { return _gender; }set { _gender = value; }}//方法——描述行为public void CHLSS(){Console.WriteLine(\"我叫{0}，我今年{1}岁了,我是{2}																	生\",this.Name,this.Age,this.Gender);}}

访问修饰符：Public ，protect ，private
类名：遵循Pascal命名规范

类的实例化

指的是创建类对象的过程，使用new关键字
语法：
类名 对象名=new 类名();

//创建Person的对象——类的实例化Person p = new Person();

类的成员访问

语法：
对象名.属性；
对象名.方法();

p.Name = \"zhagn\";p.Age = 18;p.Gender = \'男\';p.CHLSS();

对象的初始化

当我们创建好一个类的对象后，需要给这个对象的每个属性去赋值。称这个过程称之为对象的初始化。
完整代码：

自定义Person类

class Person//自定义类{//字段，通常以下划线开头，一般是private修饰的，存储数据的private string _name;private int _age;private char _gender;//属性——保护字段的public string Name{//当输出属性的值的时候，会执行get方法get { return _name; }//当你给属性值的时候，首先会执行set方法set { _name = value; }}public int Age{get{return _age;}set{_age = value;}}public char Gender{get { return _gender; }set { _gender = value; }}//方法——描述行为public void CHLSS(){Console.WriteLine(\"我叫{0}，我今年{1}岁了,我是{2}生\",this.Name,this.Age,this.Gender);//this关键字——表示当前类的对象}}

Main函数

 		static void Main(string[] args){//创建Person的对象——类的实例化Person p = new Person();//对象的初始化p.Name = \"zhagn\";p.Age = 18;p.Gender = \'男\';p.CHLSS();Console.ReadKey();}

运行结果：

3 属性

作用：是为了保护字段，对字段的赋值和取值进行限定。
属性的本质就是两个方法：get()和set()方法（读 ，写）
当输出属性的值的时候，会执行get方法
当你给属性值的时候，首先会执行set方法

其中，get是判断字段的值，set是判断value的值

public string Name{get{return _name;}set{_name = value;}}public int Age{get{return _age;}set{if (value < 0 || value > 100){value = 0;}_age = value;}}public char Gender{get{//if (_gender != \'男\'&&_gender!=\'女\')//{//    _gender = \'男\';//}return _gender;}set{if (value != \'男\' || value != \'女\'){value = \'男\';}_gender = value;}}

并不是所有的属性都是这两个方法：
既有get()也有set()我们诚之为可读可写属性。
只有get()没有set()我们称之为只读属性
没有get()只有set()我们称之为只写属性

4 静态和非静态的区别

（1）在非静态类中，既可以有实例成员，也可以有静态成员。
（2）在调用实例成员的时候，需要使用 对象名.实例成员;
在调用静态成员的时候，需要使用 类名.静态成员名;
总结：
静态成员必须使用类名去调用，而实例成员使用对象名调用。
静态函数中，只能访问静态成员，不允许访问实例成员。
实例函数中，既可以使用静态成员，也可以使用实例成员。
静态类中只允许有静态成员，不允许出现实例成员。
怎样使用静态类：
（1） 如果你想要你的类当做一个\”工具类\”去使用，这个时候可以考虑将类写成静态的。
（2）静态类在整个项目中资源共享。
只有在程序全部结束之后，静态类才会释放资源。

//**Student类**public static class Student{private static string _name;public static string Name{get{return Student._name;}set{Student._name = value;}}public static  void M1(){Console.WriteLine(\"我是一个静态类\");}}//**Person类**//非静态类——既可以有静态成员也可以有实例成员class Person{private static string _name;private char _gender;public static string Name{get{return Person._name;}set{_name = value;}}public char Gender{get{return _gender;}set{_gender = value;}}public void M1(){Console.WriteLine(\"我是非静态类的方法\");}public static void M2(){Console.WriteLine(\"我是一个静态类的方法\");}}//**Main（）函数**static void Main(string[] args){//调用实例成员Person p = new Person();p.M1();//实例方法Person.M2();//静态方法//调用静态类Student.M1();Console.ReadKey();}

运行结果：

5 new关键字

Person p=new Person();

new关键字帮我们做了3件事：
（1）在内存中开辟一块空间
（2）在开辟的空间中创建对象
（3）调用对象的构造函数进行对象的初始化

6 this关键字

（1）代表当前类的对象
（2）在类中显示的调用本类的构造函数：this（）

public Student(string name, int chinese, int math, int english) : this(name, 0, \'c\', chinese, math, english)//在类中显示的调用本类的构造函数{//表示当前类的对象//this.Name = name;//this.Chinese = chinese;//this.Math = math;//this.English = english;}

7构造函数

通俗的讲，在类中，函数名和类名相同的函数称为构造函数。它的作用是在建立一个对象时，作某些初始化的工作（例如对数据赋予初值）
构造函数是一个特殊的方法：
（1）构造函数没有返回值，连void也不能写
（2）构造函数的名称必须和类名一样
语法：
不带参数的构造函数：一般形式为 类名 (){函数体}
带参数的构造函数：一般形式为：类名（形参表）；
不带参数的构造函数，只能以固定不变的值初始化对象。带参数构造函数的初始化要灵活的多，通过传递给构造函数的参数，可以赋予对象不同的初始值。
注意：
（1）创建对象的时候，会执行构造函数
（2）构造函数是可以重载的
（3）类当中会有一个默认的无参数的构造函数，当你写一个新的构造函数之后，不管是有参数的还是无参数的，那个默认的无参数的构造函数都被干掉了。

//构造函数public Student(string name, int age, char gander, int chiese, int math, int english){this.Name = name;this.Age = age;this.Gender = gander;this.Chinese = chiese;this.Math = math;this.English = english;}//构造函数重载public Student(string name, int chinese, int math, int english) : this(name, 0, \'c\', chinese, math, english){//this.Name = name;//this.Chinese = chinese;//this.Math = math;//this.English = english;}public Student(string name, int age, char gender){this.Name = name;if (age < 0 || age > 100){age = 0;}this.Age = age;this.Gender = gender;}public Student(){}

8 析构函数

作用：帮助我们释放资源
语法：
**~类名()
{
函数体；
}**程序结束时，析构函数才执行
当一个类的对象离开作用域时，析构函数将被调用(系统自动调用)。析构函数的名字和类名一样，不过要在前面加上 ~ 。对一个类来说，只能允许一个析构函数，析构函数不能有参数，并且也没有返回值。析构函数的作用是完成一个清理工作，如释放从堆中分配的内存。

注意：
（1）不能再结构体中定义，只能对类做析构函数
（2）一个类只能有一个析构函数
（3）无法继承和重载析构函数
（4）无法调用析构函数，它是被自动调用的
（5）析构函数既没有修饰符，也没有参数。

~Student(){Console.WriteLine(\"我是析构函数\");}