最近看这几个定义以及他们的例子看的迷迷糊糊的！谁给我用通俗点的语言解释一下他们的定义，以及举例说明，最好有举例的代码！谢谢

封装简单说就是不让外界知道内部代码，但是提供给外部访问方法比如 set get方法，继承：父类其实就是子类共性向上抽取，子类继承父类后有父类全部的属性。多态：一个接口，多个方法，经典案例老毕的电脑 网卡 pci 。接口其实简单的理解就是一些比较抽象东西的集合。

封装、继承、多态
比较抽象，只是一种概念，刚开始学的时候无需太过于深究，如果要你一上来学JAVA就理解这些东西，有点牵强，你所要做的就是至少看到代码知道这个用到的是什么。
封装的概念好比一辆汽车，你学开车的时候只需学会诸如踩油门、刹车，转方向盘即可，无需去了解它的发动机是如何发动。
继承，先说说我对类的理解，类起到的作用有：分类（你所用某个类创建的对象实际上该类的个案）和模板的作用，那么继承则起到了对类再次分类的作用，比如，有个类“动物”，“哺乳动物”继承“动物”，再往下“马”又继承了“哺乳动物”这个类。在这里，我们从下往上讲，首先，我们把某种东西划分出来，叫做“马”（当然还有“牛”，“鱼”等等），接着，我们发现，“马”，“羊”等还有很多共同的特点，于是，我们再次划分出了“哺乳动物”这个类，再次分类，我们则有了“动物”。但在实际开发中，我们一般是从上往下定义的，即先有了“动物”，再有“哺乳动物”，最后有“马”。
多态，用汉字来打个比方，比如“开”这个字，在不同的时候各有的意思，比如“开门”，“开窗”，甚至有“开车”，“开饭”等，具有相同名称但操作不同。具体的实现我就不累述了。
说说接口吧，在JAVA不支持多继承的，实际上接口起到了类似多继承的作用，一个类只能继承另一个类（或抽象类）但可以实现多个接口。打个比方，“张三”，他是一个“人”，因此他继承了“人”；与此同时，他是一个“司机”，他的平时行为还有“开车”，很显然，这并不能从“人”这个类里继承下来。怎么办？JAVA里只支持单继承，这个时候，接口就起到了作用，它定义了“司机”这个接口，“张三”实现了它，因此，他会开车了。

封装：平时用的一些方法，直接去调用就行，不需要知道内部是怎样实现的，内部实现那部分就是封装起来了；
继承：一个程序中，其他方法中也可以用到你所定义的方法；
多态：同一个方法名，但是传进去的参数不同；
接口：interface A类：B类，这就是接口；这样定义后B类的方法在A中也可以用了

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承的特性：单根性，传递性。
1.构造函数：在所有的类中，构造函数是不能被隐式继承的。如果子类需要用到父类的构造函数，则需要手动调用。手动调用需要用到关键字base()语法。
例如：
public class Person
{
     public Person()
     {
          //do something;
     }
     public Person(string str1,string str8):this(str1,null,null,null,null,str8)
     {
         
     }
     public Person(string str1,string str2,……string strN)
     {
          //do something;
     }

}
public class Student:Person//代表Student类继承了Person类。
{
     //此处就说明了子类调用了父类的构造函数并把子类的参数传进父类构造函数当参数。
     public Student(string str,int num):base(str,num)
     {
          //do something;
     }
}
当然，子类对象在被创建时（也就是调用子类的构造函数时），如果没有用base来显示调用，则会先调用父类的无参构造函数。
跟base对应的还有一个关键字this.this关键字是针对类本身的，跟子类或父类没有关系。在上例中，用到this关键字，是类中构造函数默认会调用所有构造函数中参数最多的构造函数，如果this所在的构造函数不需要那么多参数的话，传一个空就行了，也就是如果是数值类型，就传0，bool类型就传false,引用类型就传null.

2.被重写的方法：如果父类重写了某个方法，在子类中是可以继续被重写的。
面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
继承概念的实现方式有三类：实现继承、接口继承和可视继承。
Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；
Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。
OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

3.多态
多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
实现多态，有二种方式，覆盖，重载。
覆盖，是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。


以上是我的一些理解。

封装其实是相对C语言的，在C语言中没有类，接口等的概念，只有结构的概念，而且C语言中的结构可以定义在函数中也可以在函数外，这样的混乱定义就会使开发软件很麻烦，费时间，这也正是面向过程语言在软件开发过程中所表现出来的弱点，在C#语言中提出了类，接口等的概念，你可以发现不管是变量，对象，属性，方法，事件，索引器等都要求定义在类等数据结构里面，而不允许定义在类的外面，这种有规律的语法使软件开发效率大大的提高了。封装的总结就是一句话：变量，属性等成员必须定义在类或结构等数据结构里面，而不允许定义在其外面。
继承就像现实世界中的父子关系，你的性格多多少少会要继承自你父亲的性格，同样，在C#中，一个类允许继承自另外一些类，这样可以使这个类的对象使用它继承的那个类的一些属性方法什么的，这样有什么好处呢，其实这也和软件开发效率也有关系，继承可以使你少写一些代码，你只需要指定一个类继承自某个类，那么他继承的那个父类中的很多属性方法什么的你就不用再重新写一遍了，很省事的。
多态：通过继承实现的不同对象调用相同的方法，表现出不同的行为，称之为多态，例如，表示汽车的基类可能包含这样的行为：当考虑的汽车为小型货车或敞篷汽车时，这些行为将会改变。
接口：接口其实是一种行为规范，不是实实在在的实物，他跟类不同，类是一个实物，类中可以包含变量，对象，而接口只允许定义方法，属性等，不允许定义变量，对象。举个很简单的例子：飞机会飞，鸟会飞，他们都可以继承自同一个接口“飞”；这里飞机，鸟都是实物，而“飞”只是一个动作，不是实物，既然不是实物，很显然他是不可以实例化的
一下有个多态的例子：
public class Animal
      {
          public virtual void Eat()
          {
              Console.WriteLine("Animal eat");
          }
      }

      public class Cat : Animal
      {
          public override void Eat()
          {
              Console.WriteLine("Cat eat");
          }
      }

      public class Dog : Animal
      {
          public override void Eat()
          {
              Console.WriteLine("Dog eat");
          }
      }

      class Tester
      {
          static void Main(string[] args)
          {
              Animal[] animals = new Animal[3];

              animals[0] = new Animal();
              animals[1] = new Cat();
              animals[2] = new Dog();

              for (int i = 0; i < 3; i++)
              {
                  animals[i].Eat();
              }
          }
      }





      输出如下：

Animal eat...

Cat eat...

Dog eat...

非常感谢各位的回答，我对这几个名词的理解深了！