C#面向对象基础

类与实例

　　•对象：一切事物皆对象，对象就是一个 自包含的实体，用一组可识别的特性和行为来标识

　　•类：具有相同的属性和功能的对象的抽象的集合

1、定义类

class Cat
{
      public string Shout()
    {
         return "喵";   
    }  
}

 

注：“这里的'class'是表示定义类的关键字，'Cat'就是类的名称，'Shout'就是类的方法。”

注意事项：第一，类名称首字母要大写。多个单词则各个首字母大写；第二，对外公开的方法需要使用'public'修饰符

　　 •实例：就是一个真实的对象,比如我们都是'人',而你和我其实就是‘人’类的实例了，而实例化就是创建对象的过程，使用new关键字来创建

private void button1_click(object sender,EventArgs e)
{
     Cat cat=new Cat(); //将Cat类实例化
     MessageBox.Show(cat.Shout());   
}

 注：“'Cat cat=new Cat()；'其实做了两件事。”

Cat cat; //声明一个Cat对象，对象名为cat
cat=new Cat(); //将此cat对象实例化

“Cat实例化后，等同于出生了一只小猫cat，此时就可以让小猫cat.Shout()了，在任何需要小猫叫的地方都可以实例化它。”

2、构造函数

　　•构造函数又叫‘构造方法’，其实就是对类进行初始化。构造方法与类名同名，无返回值，也不需要void，在new时候调用

2.1、有参构造函数

 class Cat
    {
        private string name = "";//声明Cat类的私有字符串变量name
        public Cat(string name) //定义Cat类的构造方法，参数是输入一个字符串
        {
            this.name = name; //将参数赋值给私有变量name
        }
        public string Shout()
        {
            return "我的名字叫:" + name + " 喵";
        }
    }

2.2、有参构造函数调用

 private void button1_Click(object sender, EventArgs e)
        {
            Cat cat = new Cat("咪咪");
            MessageBox.Show(cat.Shout());
        }

 2.3、方法的重载

　　•方法重载提供了创建同名的对个方法的能力，单这些方法需要 使用不同的参数类型

 class Cat
    {
        private string name = "";//声明Cat类的私有字符串变量name
        public Cat(string name) //定义Cat类的构造方法，参数是输入一个字符串
        {
            this.name = name; //将参数赋值给私有变量name
        }
        public Cat() //将构造方法重载
        {
            this.name = "无名";
        }
        public string Shout()
        {
            return "我的名字叫:" + name + " 喵";
        }
    }

注：方法的重载，两个方法必须要方法名相同，但参数类型或个数必须要有所不同，否则就没有意义了。方法重载可在不改变原方法的基础上，新增功能，算是提供了函数可扩展的能力。

2.4、属性与修饰符

　　•属性：是一个方法或一对方法，但在调用他的代码来看，他是一个字段，即属性适合于字段的方法使用方法调用的场合。字段是存储类要满足其设计所需要的数据，字段是与类相关的变量

 private int shoutNum = 3; //声明一个内部字段，注意是private，默认叫的次数为3
        public int ShoutNum //ShoutNum属性，注意是public
        {       
            get
            {
                return shoutNum; //当中有两个方法get表示外界调用时可以得到shoutNum的值
            }

            set
            {
                shoutNum = value; //set表示外界可以给内部的shoutNum赋值
            }
        }

　　•public：表示它所修饰的类成员可以允许其他任何类来访问，俗称公有的

　　•private：表示只允许同一个类中的成员访问，其他类包括它的子类无法访问，俗称私有的

　　注：如果在类的成员没有加修饰符，则被认为是private的。

　　属性的两个方法：

　　　　get：访问器返回与声明的属性相同的数据类型，表示的意思是调用时可以得到内部字段的值或引用

　　　　set：访问器没有显示设置参数，但它有一个隐式参数，用关键字value表示，他的作用是调用属性时可以给内部的字段或引用赋值

3、面向对象

　　3.1、封装

　　•解释：每个对象都包含它能进行操作所需要的所有信息

　　•优点：

　　　　1、良好的封装能够减少耦合，至少我们让Cat和Form1的耦合分离。

　　　　2、类内部的实现可以自由地修改。

　　　　3、类具有清晰的对外接口

　　3.2、继承

　　　•解释：对象的继承代表 了一种‘is-a’的关系，如果两个对象A和B，可以描述为‘B’是‘A’，则表明B可以继承A，继承者还可以理解为对被继承者的特殊化，因为他除了具备被继承者的特性外，还具备自己独有的个性。继承定义了类如何相互关联，共享特性。继承的工作方式是，定义父类和子类，或叫做基类和派生类，其中子类继承父类的所有特性。子类不但继承了父类的所有特性，还可以定的定义新的特性。

　　　•三句便于更好地理解继承概念

　　　　　　1、子类拥有父类非private的属性和功能

　　　　　　2、子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能

　　　　　　3、子类还可以以自己的方式实现父类的功能（方法的重写）

　　　我们来看一下猫和狗有那些共同特性，他们都属于动物，并且都有属于自己的名字，都会叫等等。

　　　父类：

class Animal
    {
        protected string Name = ""; //注意访问修饰符为protected：表示继承时子类可以对基类有完全访问权
        public Animal(string name)
        {
            this.Name = name;
        }
        public Animal()
        {
            this.Name = "无名";
        }
        protected int shoutNum = 3; //注意访问修饰符为protected

        protected int ShoutNum
        {
            get
            {
                return shoutNum;
            }

            set
            {
                shoutNum = value;
            }
        }
    }

　　　基类：

猫类：

    class Cat:Animal //继承格式---> 子类：父类
    {
        public Cat() : base() //子类构造方法需要调用父类同样参数类型的构造函数，用base关键字代表父类
        {
        }
        public Cat(string name) : base(name)
        {
        }
        public string Shout()
        {
            string result = "";
            for (int i=0;i<shoutNum;i++)
            {
                result += "喵，";
            }
            return "我的名字叫"+Name+" "+result;
        }
    }

狗类：

class Dog:Animal //继承格式---> 子类：父类
    {
        public Dog() : base() //子类构造方法需要调用父类同样参数类型的构造函数，用base关键字代表父类
        {
        }
        public Dog(string name) : base(name)
        {
        }
        public string Shout()
        {
            string result = "";
            for (int i=0;i<shoutNum;i++)
            {
                result += "汪，";
            }
            return "我的名字叫"+Name+" "+result;
        }
    }

注：子类从它的父类中继承的成员有方法、域、属性、事件、索引指示器，但对于构造方法，有一种特殊，他不能被继承，只能被调用，对于调用父类的成员，可以使用base关键字。

　　如果还有动物类的话，按照以前的写法就需要再复制N遍，不用继承的话，如果要修改功能，就必须在所有重复的方法中修改，代码越多，出错的可能就越大，而继承的有点是，继承使得所有子类公共的部分都放在了父类，使得代码得到了共享，这样就避免了重复，另外，继承可使得修改或扩展继承而来的实现都较为容易。

　　继承是有缺点的，那就是父类变，则子类不得不变，另外继承会破坏包装，父类实现细节暴露给子类，这其实是增大了两个类之间的耦合性。

　　3.3、多态

　　•解释：表示不同的对象可以执行相同的动作，但要通过它们自己的实现代码来执行

　　下面通过过一个小故事，更好的理解多态的定义

　　　　我们的国粹‘京剧’以前都是子承父业，代代相传的艺术。假设有这样一对父子，父亲是非常有名的京剧艺术家，儿子长大成人了，模仿父亲的戏也惟妙惟肖。有一天，父亲突然发高烧，上不了台边沿，而票都早就卖出，退票显然会大大影响声誉。怎么办呢？由于京戏都是需要化妆才可以上台的，于是就决定让儿子代父亲上台表演。化妆后谁还认识谁呀，只要长得好久可以混弄过去了。这里面有几点注意：第一、子类以父类的身份出现，儿子代表老子表演，化妆后就是以父亲身份出现了。第二、子类在工作时以自己的方式来实现，儿子模仿得再好，那也是模仿，儿子只能用自己理解的表现方式去模仿父亲的作品。第三、子类以父类的身份出现时，子类特有的属性和方法不可以使用，儿子经过多年学习，其实已经有了自己的创作，自己的绝活，但在此时，代表父亲表演时，绝活是不能表现出来的，当然，如果父亲还有别的儿子会表演，也可以在此时代表父亲上场，道理也是一样。这就是多态。

　　•虚方法

　　解释：为了使子类的实例完全接替来自父类的类成员，父类必须将该成员声明为虚拟的。这是通过在该成员的返回类型之前添加virtual关键字来实现。然后，子类可以选择使用override关键字，将父类实现替换为它自己的实现，这就是方法重写override，或者叫做方法覆写。

父类：

    class Animal
    {
         .......
        public virtual string Shout() // 注意修饰符中增加了一个virtual，它表示此方法是虚方法，可以被子类重写
        {
            return "";
        }
    }    

子类：

 class Dog:Animal //继承格式---> 子类：父类
    {
        public Dog() : base() //子类构造方法需要调用父类同样参数类型的构造函数，用base关键字代表父类
        {
        }
        public Dog(string name) : base(name)
        {
        }
        public override string Shout() //注意增加了override，表示方法重写
        {
            string result = "";
            for (int i=0;i<shoutNum;i++)
            {
                result += "汪，";
            }
            return "我的名字叫"+Name+" "+result;
        }
    }

多态的原理：当方法被调用时，无论对象是否被转换为其父类，都只有位于对象继承链最末端的方法实现会被调用。也就是说，虚方法是按照其运行时类型而非编译时类型进行动态绑定调用的。没有学过设计模式，那么对多态、乃至对面向对象的理解多半都是肤浅和片面的。我相信会有那种天才，可以听一知十，刚学的东西就可以灵活自如地应用，甚至要造汽车，他都能再去发明轮子。但对于绝大多数程序员，还是需要踏踏实实地学习基本的东西，并在不断地实践中成长，最终成为高手。

 4、抽象类

　　•解释：它是一个抽象概念，它提供一个继承的出发点，当设计一个新的抽象时，一定是要来继承的，所以，在一个以继承关系形成的等级结构里面，树叶节点应当是具体类，而树枝节点均应当来抽象类。

　　•特点：

　　　　a.抽象类不能实例化

　　　　b.抽象方法是必须被子类重写的方法，不重写的话，它的存在又有什么意思呢？其实抽象方法可以被看成是没有实现体的虚方法

　　　　c.如果类中包含抽象方法，那么类就必须定义为抽象类，不论是否还包含其他一般方法

5、接口

　　　•解释：接口是把隐式公共方法和属性组合起来，以封装特定功能的一个集合。一旦类实现了接口，类就可以支持接口所特定的所有属性和成员。声明接口在语法上与声明抽象类完全相同，但不允许提供接口中任何成员的执行方式。

　　•特点：

　　　　a.不能实例化，不能有构造方法和字段

　　　　b.不能有修饰符，比如public、private等

　　　　c.不能声明虚拟的或静态的等

　　　　d.实现接口的类就必须要实现接口中 的所有方法和属性

interface Ichange //注意此处不在是Class，接口用interface声明，接口名称前要加'I'，接口中的方法或属性不能有修饰符、方法没有方法体，首字符大写，这是规范
{
      string ChangeThing(string thing); //声明一个Ichange接口，此接口有一个方法ChangeThing,参数是一个字符串变量,返回一个字符串    
}

然后在创建机器猫的类

class MachineCat:Cat,Ichange //机器猫继承猫，并实现Ichange接口，注意Cat与Ichange使用“，”分割
{
        public MachineCat():base()
        {
        }
         public MachineCat(string name):base(name)
         {
         }
          public string ChangeThing(string thing) //是实现接口的方法，注意不能加override修饰符
          {
                  return base.Shout()+"我有万能的口袋，我可以变出："+thing; //base.Shout()表示调用父类的Cat的方法
          }
}            

　　•抽象类和接口的区别

　　　　a.类是对对象的抽象；抽象类是对类的抽象； 接口是对行为的抽象

　　　　b.如果行为跨越不同类的对象，可使用接口；对于一些相似的类对象，用继承抽象类

　　　　c.从设计角度讲，抽象类是从子类中发现公共的东西，泛化出父类，然后子类继承父类，而接口是根本不知子类的存在，方法如何实现还不确定，预先定义

6、集合

　　数组：

　　　　a.优点:数组在内存中连续存储，因此可以快速而容易地从头到尾遍历元素，可以快速修改元素等等。

　　　　b.缺点 ：创建时必须要指定数组变量的大小，还有在两个元素之间添加元素也比较困难

　　ArrayList：它的容器是ArrayList可以保存的元素数。ArrayList的默认初始容量为0.随着元素添加到ArrayList中，容量会根据需要通过重新分配自动添加。使用整数索引可以访问此集合中的元素。此集合中的索引从零开始

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Collections; //引入命名空间

namespace app
{
    public partial class Form3 : Form
    {
        public Form3()
        {
            InitializeComponent();
        }
        IList arrayAnimal;//声明一个集合变量，可以用接口Ilist，也可以直接声明“ArrayList arrayAnimal；”
        private void button1_Click(object sender, EventArgs e)
        {
            arrayAnimal = new ArrayList(); //实例化ArrayList对象，此时没有指定arrayList的大小，这与数组并不相同
            arrayAnimal.Add("小王");
            arrayAnimal.Add("小李");
            arrayAnimal.Add("小红");//调用集合的Add方法增加对象，其参数是objec
            MessageBox.Show(arrayAnimal.Count.ToString()); //随着Add对象的增加，集合中的Count可以得到当前的元素个数
        }

        private void button2_Click(object sender, EventArgs e)
        {
            arrayAnimal.RemoveAt(0); //从集合中移除“小王”
            foreach (var item in arrayAnimal)
            {
                MessageBox.Show(item.ToString()); //遍历ArrayList集合，而非数组
            }
        }
    }
}

　　•装箱

int i = 123;
object obj = (object)i;  //装箱

　　•拆箱

obj = 123;
i = (int)obj;  //拆箱

注：相对于简单的赋值而言，装箱和拆箱过程需要进行大量的计算。对值类型进项装箱时，必须分配并构造一个全新的对象。其次，拆箱所需的强制转换也需要进行大量的计算。

7、泛型

　　•解释：泛型是具有占位符（类型参数）的类、结构、接口和方法，这些占位符是类、结构、接口和方法所存储或使用的一个或多个类型的占位符。泛型集合类可以将类型参数用作它所存储的对象的类型的占位符；类型参数作为其字段的类型和其方法的参数类型出现。通常情况下，都建议使用泛型集合，因为这样可以获得类型安全的直接优点而不需要从基类派生并实现类型特定的成员。此外，如果集合元素为值类型，泛型集合类型的性能通常优于对应的非泛型集合类型（并优于从非泛型基集合类型派生的基类），因为使用泛型时不必元素进行装箱。