继承和多态的关系
 
 
 
今天学到了 Java 中的多态，在此记录一下自己的初步理解。
 
 
 
将 Java体系 看成一个整体：
 
 
 
继承：程序向上总结
 
将子类共同的行为和属性集中写到父类中，通过继承，所有子类都能自动获得这些属性和行为，大大减少了重复代码。
 
 
 
继承成为多态实现的基础。
 
 
 
多态：程序向下扩展
 
父类某些行为，子类进行继承重写，从而实现：同种行为，不同的实现。

多态的概念：

 

 

 多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。

 

 

 如果一个语言只支持类而不支持多态，只能说明它是基于对象的，而不是面向对象的。

 

 

 多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。

 

 

 多态就是允许方法重名 参数或返回值可以是父类型传入或返回。

 

 

 多态的作用：

 

 

 把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

 

 

 简单的说，建立一个父类对象的引用，它所指对象可以是这个父类的对象，也可以是它的子类的对象。java中当子类拥有和父类同样的函数，当通过这个父类对象的引用调用这个函数的时候，调用到的是子类中的函数。

 

 

 代码示例：

 

 

 class Animal

 {

     public void sing()

     {

         System.out.println("Animal is singing!");

     }

 }

 class Dog extends Animal

 {

     public void sing()

     {

         System.out.println("Dog is singing!");

     }

 }

 class Cat extends Animal

 {

     public void sing()

     {

         System.out.println("Cat is singing!");

     }

     public void eat()

     {

         System.out.println("Cat is eating!");

     }

 }

 

 

 继承的概念：

 

 

 继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

 

 

 多态的作用：

 

 

 JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口，从而克服单继承的缺点。

 

 

 （1）继承关系是传递的。若类C继承类B，类B继承类A（多层继承），则类C既有从类B那里继承下来的属性与方法，也有从类A那里继承下来的属性与方法，还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的，但仍是类C的属性和方法。继承是在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段。

 （2）继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。

 （3）继承提供了软件复用功能。若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。

 （4）继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。

 （5）提供多重继承机制。从理论上说，一个类可以是多个一般类的特殊类，它可以从多个一般类中继承属性与方法，这便是多重继承。Java出于安全性和可靠性的考虑，仅支持单重继承，而通过使用接口机制来实现多重继承。

 

 

 代码示例：

 

 

 class A{

 //成员变量 其中num是实参

 int num=0;

 //成员方法,其中 i 是型参

 public A(int i){

 //输入int型文件输出下面

 System.out.println("aaaaaaaaaaaaaaaaaaa");

 System.out.println("i= "+i);

 //把输入的i赋值给成员变量num

 num=i;

 }

 }

 //B继承A

 class B extends A{

 int num=0;

 //成员方法B.

 public B(){

 //继承类A的方法.因为B继承了A必然继承了A的特性.所以输入int值10令方法实现.

 super(10);

 System.out.println("bbbbbbbbbbbbbbbbbbbb");

 //这里的num是类B的.

 System.out.println("num= "+num);

 //如果想显示类A的num则需要用下列的super.num.这里注意num在类A中需是成员变量才可以.

 System.out.println("super.num= "+super.num);

 }

 }

 //建立测试类C

 public class C{

 //main

 public static void main(String aa[]){

 //new 一个对象B()

 new B();

 }

 }

 

 

 多态与继承的区别：

 

 

 面向对象的三个基本特征

 

 

 面向对象的三个基本特征是：封装、继承、多态。

 封装

 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

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

 继承

 面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

 通过继承创建的新类称为“子类”或“派生类”。

 被继承的类称为“基类”、“父类”或“超类”。

 继承的过程，就是从一般到特殊的过程。

 要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

 在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

  

 继承概念的实现方式有三类：实现继承、接口继承和可视继承。

 ?         实现继承是指使用基类的属性和方法而无需额外编码的能力；

 ?         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

 ?         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

 在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

 抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。

 OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

  

 多态

 多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

 实现多态，有二种方式，覆盖，重载。

 覆盖，是指子类重新定义父类的虚函数的做法。

 重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

 其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

 那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

 2.继承与多态的区别

  1、  什么是继承，继承的特点？子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。

 特点：在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。

 在继承关系中。父类和子类需要满足is-a的关系。子类是父类。

 表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。

 2、  为什么需要继承？什么时候应该继承？

 使用继承可以有效实现代码复用，避免重复代码的出现。

 当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。

 继承实现了面向对象的原则：write once,only once（编写一次、且编写一次

 3、  如何实现继承？

 在Java语言中，用extends（扩展）关键字来表示一个类继承了另一个类。

 在父类中只定义一些通用的属性和方法。

 子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。

 4、  什么是方法重写？

 如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。

 方法重写在不同类，是实现多态的必要条件。

 5、  super关键字的用法和位置，super关键字调用父类的构造方法，super关键字调用父类的方法？

 在子类的构造方法中，通过super关键字调用父类的构造方法。

 如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。

 父类：

 private String name;

 private String sex;

 public xinxin1(String name,String sex)

 {

            this.name=name;

            this.sex=sex;

 }

          public void hello(){

                    System.out.println(“嗨！我是”+name+”我是”+sex+”孩”);

          }

 子类：

 public xinxin2(String name,String sex)

 {

            //调用父类的构造方法

            super(name,sex);

 }

 public void hello(){

                    System.out.println(“我是新来的！”);

            //调用父类的方法

            super.hello();

 }

 位置注意：调用父类的构造方法的语句（super语句）必须是构造方法中的第一条语句。

 因为创建对象的时候，需要先创建父类对象，再创建子类对象。

 注意：创建对象时，先创建父类对象，在创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法。

 6、  一切类的老大（祖先）Object。

 所有类都直接或者间接地继承了Java.lang.Object类，Object类中定义了所有的java对象都具有的相同行为，是所有类的祖先。

 一个类如果没有使用extends关键字，那么这个类直接继承自Object类。

 7、  什么是多态？

 多态的特征是表现出多种形态，具有多种实现方式。或者多态是具有表现多种形态的能力的特征。或者同一个实现接口，使用不同的实例而执行不同的操作。

 8、  为什么需要使用多态？多态的好处？

 可以增强程序的可扩展性及可维护性，使代码更加简洁。

 不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。

 9、  如何实现多态？

 一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new 一个对象）。

 更具体的说：

 （1）、子类重写父类的方法。使子类具有不同的方法实现。

 （2）、把父类类型作为参数类型，该父类及其子类对象作为参数转入。

 （3）、运行时，根据实际创建的对象类型动态决定使用那个方法。

 在运行时，java虚拟机会根据实际创建的对象类型决定使用那个方法。一般将这称为动态绑定。   

 10、多态小结：多态与继承、方法重写密切相关，我们在方法中接收父类类型作为参数，在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时，java虚拟机会根据实际创建的对象类型，调用子类中相应的方法（存在方法重写时）。

 

想起有一次面试,一位技术部领导问"面向对象的基本特征说一下".于是我说了"封装,继承,多态",然后有啰啰嗦嗦的说了一些对这些知识点的理解.然而,当我说完,面试官说"其实面向对象的基本特征可以总结为两个,继承和多态可以总结为一个特征....."云云,我当时就蒙了.觉得好新鲜的说法,难道是因为自己理解的不够深刻?但是内心还是知道继承和多态是有一定的区别的,于是只好委婉的说"可能是我的理解还没达到过深的层面,从来没有听说过这种说法,我面试结束后会仔细研究研究"......无奈当时面试的时候对这两个特征的理解不够深刻,无法强有力的反驳面试官的论点.导致后面面试官问"8种"基本数据类型都没答出来
 
但是,到现在我都不知道怎么能把继承和多态混为一谈,虽然觉得有些混淆,但还是不能混为一谈,于是想了这么久.决定网上找一些资料好好补补,预防再有上述事件发生.:
 
该文内容引用了一下文章内容:
 
面向对象的三大基本特征                       继承与多态的区别
 
 
 

 
 
 

 1.面向对象的三个基本特征
 

 
 
 

  面向对象的三个基本特征是：封装、继承、多态。
 
 
 
 
 
 封装
 

  封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。
 

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

  面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
 

  通过继承创建的新类称为“子类”或“派生类”。
 

  被继承的类称为“基类”、“父类”或“超类”。
 

  继承的过程，就是从一般到特殊的过程。
 

  要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
 

  在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
 

   
 

  继承概念的实现方式有三类：实现继承、接口继承和可视继承。
 

  Ø
          实现继承是指使用基类的属性和方法而无需额外编码的能力；
 

  Ø
          接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
 

  Ø
          可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
 

  在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
 

  抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。
 

  OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
 

   
 
 
 多态
 

  多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
 

  实现多态，有二种方式，覆盖，重载。
 

  覆盖，是指子类重新定义父类的虚函数的做法。
 

  重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
 

  其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”
 

  那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
 
 
 2.继承与多态的区别
 

   
 1、  什么是继承，继承的特点？子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。 
 
 
  
 特点：在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。
 
  
 在继承关系中。父类和子类需要满足is-a的关系。子类是父类。
 
  
 表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。
 
  
 2、  为什么需要继承？什么时候应该继承？
 
  
 使用继承可以有效实现代码复用，避免重复代码的出现。
 
  
 当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。
 
  
 继承实现了面向对象的原则：write once,only once（编写一次、且编写一次
 
  
 3、  如何实现继承？
 
  
 在Java语言中，用extends（扩展）关键字来表示一个类继承了另一个类。
 
  
 在父类中只定义一些通用的属性和方法。
 
  
 子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。
 
  
 4、  什么是方法重写？
 
  
 如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。
 
  
 方法重写在不同类，是实现多态的必要条件。
 
  
 5、  super关键字的用法和位置，super关键字调用父类的构造方法，super关键字调用父类的方法？
 
  
 在子类的构造方法中，通过super关键字调用父类的构造方法。
 
  
 如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。
 
  
 父类：
 
  
 private String name;
 
  
 private String sex;
 
  
 public xinxin1(String name,String sex)
 
  
 {
 
  
            this.name=name;
 
  
            this.sex=sex;
 
  
 }
 
  
          public void hello(){
 
  
                    System.out.println(“嗨！我是”+name+”我是”+sex+”孩”);
 
  
          }
 
  
 子类：
 
  
 public xinxin2(String name,String sex)
 
  
 {
 
  
            //调用父类的构造方法
 
  
            super(name,sex);
 
  
 }
 
  
 public void hello(){
 
  
                    System.out.println(“我是新来的！”);
 
  
            //调用父类的方法
 
  
            super.hello();
 
  
 }
 
  
 位置注意：调用父类的构造方法的语句（super语句）必须是构造方法中的第一条语句。
 
  
 因为创建对象的时候，需要先创建父类对象，再创建子类对象。
 
  
 注意：创建对象时，先创建父类对象，在创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法。
 
  
 6、  一切类的老大（祖先）Object。
 
  
 所有类都直接或者间接地继承了java.lang.Object类，Object类中定义了所有的java对象都具有的相同行为，是所有类的祖先。
 
  
 一个类如果没有使用extends关键字，那么这个类直接继承自Object类。
 
  
 7、  什么是多态？
 
  
 多态的特征是表现出多种形态，具有多种实现方式。或者多态是具有表现多种形态的能力的特征。或者同一个实现接口，使用不同的实例而执行不同的操作。
 
  
 8、  为什么需要使用多态？多态的好处？
 
  
 可以增强程序的可扩展性及可维护性，使代码更加简洁。
 
  
 不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。
 
  
 9、  如何实现多态？
 
  
 一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new 一个对象）。
 
  
 更具体的说：
 
  
 （1）、子类重写父类的方法。使子类具有不同的方法实现。
 
  
 （2）、把父类类型作为参数类型，该父类及其子类对象作为参数转入。
 
  
 （3）、运行时，根据实际创建的对象类型动态决定使用那个方法。
 
  
 在运行时，java虚拟机会根据实际创建的对象类型决定使用那个方法。一般将这称为动态绑定。   
 
  
 10、多态小结：多态与继承、方法重写密切相关，我们在方法中接收父类类型作为参数，在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时，java虚拟机会根据实际创建的对象类型，调用子类中相应的方法（存在方法重写时）。
 
 
 
 

继承：类与类之间可以共用代码，实现代码重用。
 
基类：被继承的类，即父亲类。
 
派生类：继承的类，拿来主义类，即儿子类。
 
继承方式：
 
private：私有继承
 
基类private成员 不能继承
 基类public、protected成员,可以继承,在派生类中相当于是private访问
 
 
public:公有继承:
 基类private成员 不能继承
 基类public成员,可以继承,在派生类中相当于是public访问
 基类protected成员,可以继承,在派生类中相当于是protected访问
 
 
protected:保护继承:
 基类private成员 不能继承
 基类public成员,可以继承,在派生类中相当于是protected访问
 基类protected成员,可以继承,在派生类中相当于是protected访问
 
 
多态：面向对象过程中，基类与派生类存在相同的方法，但是有不同的方法体，调用是根据对象有选择的调用合适的方法。
 
多态的三个条件：
 
1.必须是公有继承
 2.必须是通过基类的指针或引用 指向派生类对象 访问派生类方法
 3.基类的方法必须是虚函数
 
 
区别：
 
1.多态的实现要求必须是共有继承。
 
2.在继承关系中，父类更通用，子类更具体。父类具有一般的特征和行为，子类除了具有父类的特征和行为，还有自己特殊的行为和特征。
 
继承关系中，并不要求基类方法一定是虚函数。多态要求基类方法必须是虚函数。
 
3.多态：子类重写父类的方法，使得子类具有不同的实现。且运行时，根据实际创建的对象动态决定使用哪个方法。