C#面向对象编程

        由于之前从事Unity开发的原因，需要使用C#写一些游戏脚本，在这个过程中学习和了解了一下C#的基本语法，想起了从前开始接触C++的时光，复习了面向对象和一些基本概念，包括继承、多态、构造函数、静态场合和静态类、转换和操作符重载、泛型、集合、事件和委托等，在看的过程中顺便对这些基本概念做一个总结，估计也只有在考试和面试的时候用到了，可惜学生时光快要结束了，可能以后再也不会有进考场考试的机会了。。。。

 

1、面向对象学习

1.1 特点：

封装： 把整个世界的所有物体看作一个个对象，对象有属性和行为，对象隐藏了属性和行为，只需要调用，关心接口

继承：减轻了工作量，子类继承了父类的特性

多态：派生出来的类，统一的维护，体现各自的特点，动态的

1.2 优点：

易维护，易开发，易扩展

1.3 方法：

掌握面向对象的核心思想：一切皆对象

掌握面向对象的语言技巧

 

2、基本概念

2.1 继承

一个类派生于另一个基类型，则它拥有该基类型的所有成员字段和函数

2.2隐藏方法：不能删除基类中的任何成员时可以用与基类成员名称相同的成员来屏蔽基类成员。语法细节：屏蔽数据成员、屏蔽函数成员、添加new关键词

2.3虚方法和多态

面向对象编程的原则：依赖倒置原则，也就是程序设计要依赖于抽象类而不是具体类

虚方法：声明为virtual的方法，基类的虚方法可以在派生类中使用override重写

多态：通过指向派生类的基类引用，调用虚函数，会根据引用所指向派生类的实际类型，调用派生类中的同名重写函数

虚方法是为了让子类具有个性，而不具有特性的统一特点既可以用积累数组。Pet[] pets = new Pet[](){new Dog(),new Cat()};

不能重写static方法或非虚方法，方法、属性、索引器、事件都可以声明为virtual或override。

2.4构造函数

调用当前类的其他构造函数：Pet(int age,string name):this{}  ——调用进行公共初始化的函数

               Pet(string name)()  ——构造函数重载

2.5 抽象方法和抽象类

abstract public void Function();

抽象类存在的目的就是被继承

抽象类不能实例化

抽象类可以包含抽象成员和普通成员

抽象类重写关键词也是override

基类中抽象函数不能有函数体，必须在子类中使用override重写，虚函数可以有函数体。

密闭类：有些类不能通过继承来修改，也不能重写该方法。  关键词sealed

 

2.6接口

接口就是指定一组函数成员而不实现他们的引用类型，只能用来被实现，它也是一种引用类型，可以通过接口来调用，也可以通过对象来调用，优点在于一个类可以实现多个接口。

Interface ICatchMice{

   void ICatchMice();    //不能加public

}

在实现的时候  public  void ICatchMice(){ console.writeline(“I am a cat”) }；

 

2.7结构和类

结构是值类型，类是引用类型；结构不支持继承，类支持继承，结构不能定义默认构造函数。

结构关键词struct，可以用于小型数据结构，作用域结束就被删除；类则被用于需要继承体系的场合。

 

3、静态场合和静态类

3.1静态成员

静态成员和实例成员分开保存

静态成员直接通过类名来访问  Dog.num +=1；

静态函数成员不能访问实例成员，仅能访问其他静态成员；

静态构造函数只用于初始化静态字段，在引用任何静态成员之前和创建；任何实例之前调用；与类同名，使用static无参数无访问修饰符

 

3.2静态类

类只包含了静态的方法和属性，并且标识为static；不能初始化实例

总结扩展：扩展方法所属的类必须是static类

     扩展方法本身是static方法

扩展方法的第一个参数类型必须是this+类名

 

4、转换和操作符重载

4.1装箱和拆箱

装箱：根据值类型的值，在堆上创建一个完整的引用类型对象，并返回对性的引用，是一种隐式转换。  int i=3;  object 0i=null;  oi=i;  //装箱

 

4.2自定义转换：为自己的结构或者类定义显示和隐式转换，让自己的结构或类变成一个预期的相关类型

4.3 重载运算符

利用某种现有的运算符，针对自定义类或者结构定义某种运算操作。

 

5、泛型

5.1泛型类

泛型类就是一个模子，装入类型的材料，塑造出想要的产品。

Class Cage <T>{       //T就是模板类名

T[] petsArray;

Public void Putln(T pet){...}

Public T Takeout(int index){...}

}

实例化：

Class Cage <T> {...}  //泛型类声明

Cage <Dog>  dogCage;   //Cage<Dog>类型的引用

dogCage = new Cage<Dog>();   //构造实例

 

5.2泛型方法

就是方法的模型，给定具体的类型，就可以实例化出一个操作该类型的具体方法。

 

5.3 约束

用来缩小泛型参数的范围

只有添加了约束，才能调用泛型参数中（比如T）的方法，泛型类和方法都可以添加约束.

Void Cage<T>  

  Where T :Pet,IClimbTree,new()  {....}

5.4 泛型接口

泛型接口允许我们将接口成员的参数和返回类型设置为泛型参数的接口

语法：                                   实现泛型接口语法：

Interface IMfself<T>{                       class A:IMyself<A>{

T Myself(T self);                            public A Myself( A self)

}                                        }

 

6、集合

集合就是一种存放多个数据的容器类型，比如数组Array是个最简单的集合。

动态数组：ArrayList---初始化可以不指定大小，获取长度使用count属性；

添加add;删除Remove，removeAt ；访问[index]

列表：List  

 list<T> list = new List<T>();     //T类名

 List.Add(new Dog(“A”));

list.Add(new Dog(“B”));

List.RemoveAt(1);    //删除了B

for(int i = 0;i<list.Count;++i){

   List[i].PrintName();

}

字典：Dictionary

字典容器存储的是一系列的键值对，每个值对应一个唯一的键，键的意义在于我们可以通过键相对高效的访问到值。

字典的操作：Count -数量    添加-Add(key,value)   删除-Remove  

访问-[key]

 

Example：

Dictionary <string,Dog> dic = new Dictionary<string,Dog>();

dic.Add(“A”,new Dog(“A”));       //添加

Dic[“A”].printName();            //访问

 

队列：Queue   先进先出    出队-Dequeue()        入队-Enqueue()

Example :

Queue<Pet> queue = new Queue<Pet>();

queue.Enqueue(new Dog(“A”));    //入队A

queue.Enqueue(new Dog(“B”));    //入队B

Pet pet =null;

Pet= queue.Dequeue();     //A出队

Pet.PrintName();

Pet= queue.Dequeue();    //B出队

Pet.PrintName();

 

栈：stack<>    先进后出     出栈-Pop  入栈-Push  栈顶元素-Peek

Example:

Stac<(Pet> stack new Satck<Pet>();  //初始化栈

Stack.Push(new Dog(“A”));        //A入栈

Stack.Push(new Cat(“B”));        //B入栈

Stack.Peek(). PrintName();        //栈顶元素B

Stack.Pop();                    //B出栈

 

7、 事件和委托

7.1委托持有一个或者多个方法的对象，该对象可以执行和传递。它是一种引用类型

声明   delegate void ActCute（）;

ActCute  actCute;

7.2事件

声明：delegate void Handler（）;

      Public event Handler  NewDog;      //NewDog是一个成员