精华内容
下载资源
问答
  • 继承和多态的区别

    2014-01-15 20:50:00
    继承是子类获得父类成员,重写是...网上看到一个有趣说法是:继承是子类使用父类方法,而多态则是父类使用子类方法。下面例子包含了这四种实现:class Triangle extends Shape {public int getSides() {r...

    继承是子类获得父类的成员重写是继承后重新实现父类的方法。重载是在一个类里一系列参数不同名字相同的方法。多态则是为了避免在父类里大量重载引起代码臃肿且难于维护。
            网上看到一个有趣的说法是:继承是子类使用父类的方法,而多态则是父类使用子类的方法。
    下面的例子包含了这四种实现:
    class Triangle extends Shape {
     public int getSides() {
      return 3;
     }

    }
    class Rectangle extends Shape {
     public int getSides(int i) {
      return i;
     }

    }
    public class Shape {
     public boolean isSharp(){
      return true;
     }
     public int getSides(){
      return 0 ;
     }
     public int getSides(Triangle tri){
      return 3 ;
     }
     public int getSides(Rectangle rec){
      return 4 ;
     }

     public static void main(String[] args) {
      Triangle tri = new Triangle();
      System.out.println("Triangle is a type of sharp? " + tri.isSharp());

      Shape shape = new Triangle();
      System.out.println("My shape has " + shape.getSides() + " sides.");

     }
    }
    红色是重载绿色是重写蓝色是继承粉红是多态
    注意Triangle类的方法是重写,而Rectangle类的方法是重载。
    比较红色的和粉红的部分就可以发现多态对重载的优点:如果用重载,则在父类里要对应每一个子类都重载一个取得边数的方法;如果用多态,则父类只提供取得边数的接口,至于取得哪个形状的边数,怎样取得,在子类里各自实现(重写)。

    原文网址:

    http://blog.sina.com.cn/s/blog_4b622a8e0100byx1.html

    转载于:https://www.cnblogs.com/naliang/p/3521493.html

    展开全文
  • 原文地址:C++的继承和多态的区别作者:狼之行继承:是指子类按照一定方式继承基类的成员及函数。   如果此时定义一个基类的指针,并把子类的对象传给这个基类指针.假如子类和基类都有一个相同函数。那么这个指针...

    继承:是指子类按照一定方式继承基类的成员及函数。

     

    如果此时定义一个基类的指针,并把子类的对象传给这个基类指针.假如子类和基类都有一个相同函数。那么这个指针调用这个函数则到底调用的是基类的函数还是子类的函数呢?答案是:基类的函数。因为函数的调用取决于基类的指针类型,而不是取决于指针指向的对象类型。

     

    如下:

      Class shape

    {

       shape();

       ~shape();

        display(); //画一个多边形

    }

     

    Class CRect:public shape

    {

      CRect();

     ~CRect();

      display();   //画一个矩形

    }

     

    shape*  pshape;

    CRect rct;

    pshape=&rct;        //指向子类对象,最好不要用一个子类指针指向一个基类对象,因为这样危险性大.

    pshape->display();  //它调用的仍然是基类的shape的display函数即画一个多边形

    以上的这种特性就是函数的一般性,即指针调用的函数取决于指针类型,而不取决于指向的对象类型。假如这个基类派生了很多子类,且每个子类都定义了个函数对基类的函数进行覆盖,此时多个基类指针指向不同子类对象,调用子类的覆盖函数,则这些指针的行为都是一样的,即都是调用基类的函数而不是子类相对应的函数。

     

    从上可以看出,这种特性并不具有多态性,因为它不会自动随着指向的对象而调用对象的函数。那么如何能实现这种特性呢?这时就需要一种技术,即虚函数。虚函数是实现多态性的方法。

    虚函数就是在函数的前面加上一个Virtual即可。

     

    虚函数中有一种比较特别:纯虚函数。

    它的目的:纯虚函数不能定义函数的实际动作,它的存在只是为了在衍生类别中对它能够进行重新定义,实现多

              态特性.

    它的定义方式:

     virtual 函数类型 函数名(参数)= 0; //一定要“= 0”

    它的约束:如果一个类中有纯虚函数,则这个类叫做抽象类,它是不能定义对象的。

     

    展开全文
  • 本章学习目标:了解继承的目的了解继承多态的关系知道如何重新定义方法认识java.lang.object简介垃圾回收机制一、继承继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。继承可以理解为一个...

    本章学习目标:

    了解继承的目的

    了解继承与多态的关系

    知道如何重新定义方法

    认识java.lang.object

    简介垃圾回收机制

    一、继承

    继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。继承可以理解为一个对象从另一个对象获取属性的过程。

    如果类A是类B的父类,而类B是类C的父类,我们也称C是A的子类,类C是从类A继承而来的。在Java中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类

    继承中最常使用的两个关键字是extends和implements。

    这两个关键字的使用决定了一个对象和另一个对象是否是IS-A(是一个)关系。

    通过使用这两个关键字,我们能实现一个对象获取另一个对象的属性。

    所有Java的类均是由java.lang.Object类继承而来的,所以Object是所有类的祖先类,而除了Object外,所有类必须有一个父类。

    通过过extends关键字可以申明一个类是继承另外一个类而来的,一般形式如下:

    // A.java

    public class A {

    private int i;

    protected int j;

    public void func() {

    }

    }

    // B.java

    public class B extends A {

    }

    以上的代码片段说明,B由A继承而来的,B是A的子类。而A是Object的子类,这里可以不显示地声明。

    作为子类,B的实例拥有A所有的成员变量,但对于private的成员变量B却没有访问权限,这保障了A的封装性。

    IS-A关系

    IS-A就是说:一个对象是另一个对象的一个分类。

    下面是使用关键字extends实现继承。

    public class Animal{

    }

    public class Mammal extends Animal{

    }

    public class Reptile extends Animal{

    }

    public class Dog extends Mammal{

    }

    基于上面的例子,以下说法是正确的:

    Animal类是Mammal类的父类。

    Animal类是Reptile类的父类。

    Mammal类和Reptile类是Animal类的子类。

    Dog类既是Mammal类的子类又是Animal类的子类。

    分析以上示例中的IS-A关系,如下:

    Mammal IS-A Animal

    Reptile IS-A Animal

    Dog IS-A Mammal

    因此 : Dog IS-A Animal

    通过使用关键字extends,子类可以继承父类所有的方法和属性,但是无法使用 private(私有) 的方法和属性。

    我们通过使用instanceof 操作符,能够确定Mammal IS-A Animal

    实例

    public class Dog extends Mammal{

    public static void main(String args[]){

    Animal a = new Animal();

    Mammal m = new Mammal();

    Dog d = new Dog();

    System.out.println(m instanceof Animal);

    System.out.println(d instanceof Mammal);

    System.out.println(d instanceof Animal);

    }

    }

    以上实例编译运行结果如下:

    true

    true

    true

    介绍完extends关键字之后,我们再来看下implements关键字是怎样使用来表示IS-A关系。

    Implements关键字使用在类继承接口的情况下, 这种情况不能使用关键字extends。

    实例

    public interface Animal {}

    public class Mammal implements Animal{

    }

    public class Dog extends Mammal{

    }

    instanceof 关键字

    可以使用 instanceof 运算符来检验Mammal和dog对象是否是Animal类的一个实例。

    interface Animal{}

    class Mammal implements Animal{}

    public class Dog extends Mammal{

    public static void main(String args[]){

    Mammal m = new Mammal();

    Dog d = new Dog();

    System.out.println(m instanceof Animal);

    System.out.println(d instanceof Mammal);

    System.out.println(d instanceof Animal);

    }

    }

    以上实例编译运行结果如下:

    true

    true

    true

    HAS-A 关系

    HAS-A代表类和它的成员之间的从属关系。这有助于代码的重用和减少代码的错误。

    例子

    public class Vehicle{}

    public class Speed{}

    public class Van extends Vehicle{

    private Speed sp;

    }

    Van类和Speed类是HAS-A关系(Van有一个Speed),这样就不用将Speed类的全部代码粘贴到Van类中了,并且Speed类也可以重复利用于多个应用程序。

    在面向对象特性中,用户不必担心类的内部怎样实现。

    Van类将实现的细节对用户隐藏起来,因此,用户只需要知道怎样调用Van类来完成某一功能,而不必知道Van类是自己来做还是调用其他类来做这些工作。

    Java只支持单继承,也就是说,一个类不能继承多个类。

    下面的做法是不合法的:

    public class extends Animal, Mammal{}

    Java只支持单继承(继承基本类和抽象类),但是我们可以用接口来实现(多继承接口来实现),脚本结构如:

    public class Apple extends Fruit implements Fruit1, Fruit2{}

    一般我们继承基本类和抽象类用extends关键字,实现接口类的继承用implements关键字。

    二、多态

    多态是同一个行为具有多个不同表现形式或形态的能力。

    多态性是对象多种表现形式的体现。

    比如我们说"宠物"这个对象,它就有很多不同的表达或实现,比如有小猫、小狗、蜥蜴等等。那么我到宠物店说"请给我一只宠物",服务员给我小猫、小狗或者蜥蜴都可以,我们就说"宠物"这个对象就具备多态性。

    接下来让我们通过实例来了解Java的多态。

    public interface Vegetarian{}

    public class Animal{}

    public class Deer extends Animal implements Vegetarian{}

    因为Deer类具有多重继承,所以它具有多态性。以上实例解析如下:

    一个 Deer IS-A(是一个) Animal

    一个 Deer IS-A(是一个) Vegetarian

    一个 Deer IS-A(是一个) Deer

    一个 Deer IS-A(是一个)Object

    在Java中,所有的对象都具有多态性,因为任何对象都能通过IS-A测试的类型和Object类。

    访问一个对象的唯一方法就是通过引用型变量。

    引用型变量只能有一种类型,一旦被声明,引用型变量的类型就不能被改变了。

    引用型变量不仅能够被重置为其他对象,前提是这些对象没有被声明为final。还可以引用和它类型相同的或者相兼容的对象。它可以声明为类类型或者接口类型。

    当我们将引用型变量应用于Deer对象的引用时,下面的声明是合法的:

    Deer d = new Deer();

    Animal a = d;

    Vegetarian v = d;

    Object o = d;

    所有的引用型变量d,a,v,o都指向堆中相同的Deer对象。

    虚方法

    我们将介绍在Java中,当设计类时,被重载的方法的行为怎样影响多态性。

    我们已经讨论了方法的重载,也就是子类能够重载父类的方法。

    当子类对象调用重载的方法时,调用的是子类的方法,而不是父类中被重载的方法。

    要想调用父类中被重载的方法,则必须使用关键字super。

    /* 文件名 : Employee.java */

    public class Employee

    {

    private String name;

    private String address;

    private int number;

    public Employee(String name, String address, int number)

    {

    System.out.println("Constructing an Employee");

    this.name = name;

    this.address = address;

    this.number = number;

    }

    public void mailCheck()

    {

    System.out.println("Mailing a check to " + this.name

    + " " + this.address);

    }

    public String toString()

    {

    return name + " " + address + " " + number;

    }

    public String getName()

    {

    return name;

    }

    public String getAddress()

    {

    return address;

    }

    public void setAddress(String newAddress)

    {

    address = newAddress;

    }

    public int getNumber()

    {

    return number;

    }

    }

    假设下面的类继承Employee类:

    /* 文件名 : Salary.java */

    public class Salary extends Employee

    {

    private double salary; //Annual salary

    public Salary(String name, String address, int number, double

    salary)

    {

    super(name, address, number);

    setSalary(salary);

    }

    public void mailCheck()

    {

    System.out.println("Within mailCheck of Salary class ");

    System.out.println("Mailing check to " + getName()

    + " with salary " + salary);

    }

    public double getSalary()

    {

    return salary;

    }

    public void setSalary(double newSalary)

    {

    if(newSalary >= 0.0)

    {

    salary = newSalary;

    }

    }

    public double computePay()

    {

    System.out.println("Computing salary pay for " + getName());

    return salary/52;

    }

    }

    现在我们仔细阅读下面的代码,尝试给出它的输出结果:

    /* 文件名 : VirtualDemo.java */

    public class VirtualDemo

    {

    public static void main(String [] args)

    {

    Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);

    Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);

    System.out.println("Call mailCheck using Salary reference --");

    s.mailCheck();

    System.out.println("\n Call mailCheck using Employee reference--");

    e.mailCheck();

    }

    }

    以上实例编译运行结果如下:

    Constructing an Employee

    Constructing an Employee

    Call mailCheck using Salary reference --

    Within mailCheck of Salary class

    Mailing check to Mohd Mohtashim with salary 3600.0

    Call mailCheck using Employee reference--

    Within mailCheck of Salary class

    Mailing check to John Adams with salary 2400.0

    例子中,我们实例化了两个Salary对象。一个使用Salary引用s,另一个使用Employee引用。

    编译时,编译器检查到mailCheck()方法在Salary类中的声明。

    在调用s.mailCheck()时,Java虚拟机(JVM)调用Salary类的mailCheck()方法。

    因为e是Employee的引用,所以调用e的mailCheck()方法则有完全不同的结果。

    当编译器检查e.mailCheck()方法时,编译器检查到Employee类中的mailCheck()方法。

    在编译的时候,编译器使用Employee类中的mailCheck()方法验证该语句, 但是在运行的时候,Java虚拟机(JVM)调用的是Salary类中的mailCheck()方法。

    该行为被称为虚拟方法调用,该方法被称为虚拟方法。

    Java中所有的方法都能以这种方式表现,借此,重写的方法能在运行时调用,不管编译的时候源代码中引用变量是什么数据类型。

    三、关于设计模式

    四、垃圾回收(GC)

    说到垃圾回收(Garbage Collection,GC),很多人就会自然而然地把它和Java联系起来。在Java中,程序员不需要去关心内存动态分配和垃圾回收的问题,这一切都交给了JVM来处理。顾名思义,垃圾回收就是释放垃圾占用的空间,那么在Java中,什么样的对象会被认定为“垃圾”?(Java垃圾回收机制:http://www.cnblogs.com/dolphin0520/p/3783345.html)

    展开全文
  • 重载,继承,重写和多态的区别: 1)继承是子类获得父类的成员。 2)重写是继承后重新实现父类的方法。  3)重载是在一个类里一系列参数不同名字相同的方法。  4)多态则是为了避免在父类里大量重载引起代码...

    重载,继承,重写和多态的区别:

    1)继承是子类获得父类的成员。
    2)重写是继承后重新实现父类的方法。 
    3)重载是在一个类里一系列参数不同名字相同的方法。 
    4)多态则是为了避免在父类里大量重载引起代码臃肿且难于维护。

    网上看到一个有趣的说法是:继承是子类使用父类的方法,而多态则是父类使用子类的方法。

    下面的例子包含了这四种实现:

    class Triangle extends Shape {

     public int getSides() {
      return 3;
     }

    }

    class Rectangle extends Shape {
     public int getSides(int i) {
      return i;
     }

    }

    public class Shape {
     public boolean isSharp(){
      return true;
     }

     public int getSides(){
      return 0 ;
     }
     public int getSides(Triangle tri){
      return 3 ;
     }
     public int getSides(Rectangle rec){
      return 4 ;
     }


     public static void main(String[] args) {
      Triangle tri = new Triangle();
      System.out.println(“Triangle is a type of sharp? ” + tri.isSharp());

      Shape shape = new Triangle();
      System.out.println(“My shape has ” + shape.getSides() + ” sides.”);

     }
    }

    红色是重载绿色是重写蓝色是继承粉红是多态

    注意Triangle类的方法是重写,而Rectangle类的方法是重载。
    比较红色的和粉红的部分就可以发现多态对重载的优点:如果用重载,则在父类里要对应每一个子类都重载一个取得边数的方法;如果用多态,则父类只提供取得边数的接口,至于取得哪个形状的边数,怎样取得,在子类里各自实现(重写)。

    展开全文
  • 继承:我们封装了数据,形成数据类型后。假如我们想要使用相同数据类型,这时候我们只需对原有数据类型进行“克隆”,再对其进行添加和修改。 多态:无论在创建过程中,还是...请问一下:该怎样区别继承和多态
  • java中继承和多态的区别

    千次阅读 2012-03-08 20:35:48
    从李启铭说的那句:我爸是李刚,是很有科学依据的,用程序设计的原理看,它符合继承和多态的面向对象编程的这2大特性。 先说一说,继承,继承就是子类可以继承父类中的属性和方法。包括私有的属性和方法,只是由于...
  • 重载,继承,重写和多态的区别继承是子类获得父类的成员,重写是继承后重新实现父类的方法。重载是在一个类里一系列参数不同名字相同的方法。多态则是为了避免在父类里大量重载引起代码臃肿且难于维护。网上看到一...
  • C++中继承与多态Java中继承多态的区别
  • 什么是多态?它的实现机制是什么呢?重载重写的区别在那里?这就是这一次我们要回顾的四个十分...继承是面向对象的三个基本特征--封装、继承多态的其中之一,我们在使用JAVA时编写的每一个类都是在继承,因为在...
  • 子类继承父类特征行为,使得子类具有父类各种属性方法。或子类从父类继承方法,使得子类具有父类相同行为。特点:在继承关系中,父类更通用、子类更具体。父类具有更一般特征行为,而子类除了具有父类...
  • 我只是想知道主要的区别在于我自己的想法。我知道有很多类似的问题,但是,我没有看到哪些提供了明确的答案。#1 热门回答(236 赞)继承是指"类"派生自现有的"类"。所以如果你有aPersonclass,那么你有aStudentclass,...
  • 继承多态的区别

    万次阅读 多人点赞 2016-08-23 14:31:28
    想起有一次面试,一位技术部领导问"面向对象的基本特征说一下".于是我说了"封装,继承,多态",然后有啰啰嗦嗦的说了一些对...但是内心还是知道继承和多态是有一定的区别的,于是只好委婉的说"可能是我的理解还没达到过深的
  • 而面向对象基本特性就是封装、继承、与多态。一、继承extends 关键字表示继承某个已存在类,已存在类称为“超类”、“基类”、或“父类”,而新继承的类称为“子类”、“派生类”。子类可以方...
  • @抽象类特点:A:抽象类抽象方法必须用abstract关键字修饰B:抽象类中不一定有抽象方法,但是有抽象方法类必须定义为抽象类C:抽象类不能实例化因为它不是具体。抽象类有构造方法,但是不能实例化?构造方法...
  • 抽象类特点:A:抽象类抽象方法必须用abstract关键字修饰B:抽象类中不一定有抽象方法,但是有抽象方法类必须定义为抽象类C:抽象类不能实例化因为它不是具体。抽象类有构造方法,但是不能实例化?构造方法作用...
  • [2] 继承实现代码重用当多个子类拥有共同属性行为时,人为把共同属性方法提取到父类中,子类继承父类实现代码重用二、抽象类1.抽象类概念C extends B,B extends A,在继承过程中,形成一个继承金字塔,位于...
  • 1. 类的继承继承是面向对象编程技术主要特征之一,也是实现软件复用重要手段,使用继承特性子类(subclass)可以继承父类(superclass)中private方法属性,继承的目的是使程序代码重用,减少冗余。1.1 类的继承的...
  • 先看两段代码,分别是子类父类 父类: class Person(){ String name; int age; public void eat(){ } } 子类: class Student extends Person(){ int grade; int score; public void study...
  • 主要介绍了java中重载,继承,重写和多态的区别,需要的朋友可以参考下
  • 重载重写的区别在那里?这就是这一次我们要回顾的四个十分重要的概念:继承多态、重载重写。 继承(inheritance)  简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲...
  • 实验五 继承与多态理解继承多态的概念,掌握三种访问控制的区别,掌握抽象类、接口与包的应用。二、实验内容:1. 参考教材P112,示例程序C5_17,掌握抽象类的应用。2. 参考教材P116,示例程序C5_19,掌握接口的...
  • 继承和多态有何区别

    千次阅读 2013-04-07 15:43:41
    在OODOOP中,多态组合优于继承多态的基础是继承,没有继承,多态就无从谈起。 1、当对象的类型不影响类中的行为时,就要使用模板来生成这样的一组类 2、当对象的类型影响类中的行为时,就要使用继承来生成这样...
  • 从李启铭说的那句:我爸是李刚,是很有科学依据的,用程序设计的原理看,它符合继承和多态的面向对象编程的这2大特性。 先说一说,继承,继承就是子类可以继承父类中的属性和方法。包括私有的属性和方法,只是由于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,637
精华内容 1,454
关键字:

继承和多态的区别