`
explore
  • 浏览: 80676 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

继承、多态、重载和重写

    博客分类:
  • J2SE
阅读更多
转自:http://zangweiren.iteye.com/blog/221944

什么是多态?它的实现机制是什么呢?重载和重写的区别在那里?这就是这一次我们要回顾的四个十分重要的概念:继承、多态、重载和重写。

继承(inheritance)

简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲到,这种方式叫重写)的方式,产生一个新的类型。继承是面向对象的三个基本特征--封装、继承、多态的其中之一,我们在使用JAVA时编写的每一个类都是在继承,因为在JAVA语言中,java.lang.Object类是所有类最根本的基类(或者叫父类、超类),如果我们新定义的一个类没有明确地指定继承自哪个基类,那么JAVA就会默认为它是继承自Object类的。

我们可以把JAVA中的类分为以下三种:

类:使用class定义且不含有抽象方法的类。
抽象类:使用abstract class定义的类,它可以含有,也可以不含有抽象方法。
接口:使用interface定义的类。

在这三种类型之间存在下面的继承规律:

类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。
抽象类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。
接口只能继承(extends)接口。

请注意上面三条规律中每种继承情况下使用的不同的关键字extends和implements,它们是不可以随意替换的。大家知道,一个普通类继承一个接口后,必须实现这个接口中定义的所有方法,否则就只能被定义为抽象类。我在这里之所以没有对implements关键字使用“实现”这种说法是因为从概念上来说它也是表示一种继承关系,而且对于抽象类implements接口的情况下,它并不是一定要实现这个接口定义的任何方法,因此使用继承的说法更为合理一些。

以上三条规律同时遵守下面这些约束:

类和抽象类都只能最多继承一个类,或者最多继承一个抽象类,并且这两种情况是互斥的,也就是说它们要么继承一个类,要么继承一个抽象类。
类、抽象类和接口在继承接口时,不受数量的约束,理论上可以继承无限多个接口。当然,对于类来说,它必须实现它所继承的所有接口中定义的全部方法。
抽象类继承抽象类,或者实现接口时,可以部分、全部或者完全不实现父类抽象类的抽象(abstract)方法,或者父类接口中定义的接口。
类继承抽象类,或者实现接口时,必须全部实现父类抽象类的全部抽象(abstract)方法,或者父类接口中定义的全部接口。

继承给我们的编程带来的好处就是对原有类的复用(重用)。就像模块的复用一样,类的复用可以提高我们的开发效率,实际上,模块的复用是大量类的复用叠加后的效果。除了继承之外,我们还可以使用组合的方式来复用类。所谓组合就是把原有类定义为新类的一个属性,通过在新类中调用原有类的方法来实现复用。如果新定义的类型与原有类型之间不存在被包含的关系,也就是说,从抽象概念上来讲,新定义类型所代表的事物并不是原有类型所代表事物的一种,比如黄种人是人类的一种,它们之间存在包含与被包含的关系,那么这时组合就是实现复用更好的选择。下面这个例子就是组合方式的一个简单示例:
Java代码
public class Sub {  
    private Parent p = new Parent();  
 
    public void doSomething() {  
        // 复用Parent类的方法  
        p.method();  
        // other code  
    }  
}  
 
class Parent {  
    public void method() {  
        // do something here  
    }  


public class Sub {
private Parent p = new Parent();

public void doSomething() {
// 复用Parent类的方法
p.method();
// other code
}
}

class Parent {
public void method() {
// do something here
}
}

当然,为了使代码更加有效,我们也可以在需要使用到原有类型(比如Parent p)时,才对它进行初始化。

使用继承和组合复用原有的类,都是一种增量式的开发模式,这种方式带来的好处是不需要修改原有的代码,因此不会给原有代码带来新的BUG,也不用因为对原有代码的修改而重新进行测试,这对我们的开发显然是有益的。因此,如果我们是在维护或者改造一个原有的系统或模块,尤其是对它们的了解不是很透彻的时候,就可以选择增量开发的模式,这不仅可以大大提高我们的开发效率,也可以规避由于对原有代码的修改而带来的风险。

多态(Polymorphism)

多态是又一个重要的基本概念,上面说到了,它是面向对象的三个基本特征之一。究竟什么是多态呢?我们先看看下面的例子,来帮助理解:
Java代码
//汽车接口  
interface Car {  
    // 汽车名称  
    String getName();  
 
    // 获得汽车售价  
    int getPrice();  
}  
 
// 宝马  
class BMW implements Car {  
    public String getName() {  
        return "BMW";  
    }  
 
    public int getPrice() {  
        return 300000;  
    }  
}  
 
// 奇瑞QQ  
class CheryQQ implements Car {  
    public String getName() {  
        return "CheryQQ";  
    }  
 
    public int getPrice() {  
        return 20000;  
    }  
}  
 
// 汽车出售店  
public class CarShop {  
    // 售车收入  
    private int money = 0;  
 
    // 卖出一部车  
    public void sellCar(Car car) {  
        System.out.println("车型:" + car.getName() + "  单价:" + car.getPrice());  
        // 增加卖出车售价的收入  
        money += car.getPrice();  
    }  
 
    // 售车总收入  
    public int getMoney() {  
        return money;  
    }  
 
    public static void main(String[] args) {  
        CarShop aShop = new CarShop();  
        // 卖出一辆宝马  
        aShop.sellCar(new BMW());  
        // 卖出一辆奇瑞QQ  
        aShop.sellCar(new CheryQQ());  
        System.out.println("总收入:" + aShop.getMoney());  
    }  


//汽车接口
interface Car {
// 汽车名称
String getName();

// 获得汽车售价
int getPrice();
}

// 宝马
class BMW implements Car {
public String getName() {
return "BMW";
}

public int getPrice() {
return 300000;
}
}

// 奇瑞QQ
class CheryQQ implements Car {
public String getName() {
return "CheryQQ";
}

public int getPrice() {
return 20000;
}
}

// 汽车出售店
public class CarShop {
// 售车收入
private int money = 0;

// 卖出一部车
public void sellCar(Car car) {
System.out.println("车型:" + car.getName() + "  单价:" + car.getPrice());
// 增加卖出车售价的收入
money += car.getPrice();
}

// 售车总收入
public int getMoney() {
return money;
}

public static void main(String[] args) {
CarShop aShop = new CarShop();
// 卖出一辆宝马
aShop.sellCar(new BMW());
// 卖出一辆奇瑞QQ
aShop.sellCar(new CheryQQ());
System.out.println("总收入:" + aShop.getMoney());
}
}

运行结果:

车型:BMW  单价:300000
车型:CheryQQ  单价:20000
总收入:320000

继承是多态得以实现的基础。从字面上理解,多态就是一种类型(都是Car类型)表现出多种状态(宝马汽车的名称是BMW,售价是300000;奇瑞汽车的名称是CheryQQ,售价是2000)。将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定,分前期绑定和后期绑定两种。下面解释一下它们的定义:

前期绑定:在程序运行之前进行绑定,由编译器和连接程序实现,又叫做静态绑定。比如static方法和final方法,注意,这里也包括private方法,因为它是隐式final的。
后期绑定:在运行时根据对象的类型进行绑定,由方法调用机制实现,因此又叫做动态绑定,或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的耦合关系,使程序更容易扩展。比如在上例中,新增加一种类型汽车的销售,只需要让新定义的类继承Car类并实现它的所有方法,而无需对原有代码做任何修改,CarShop类的sellCar(Car car)方法就可以处理新的车型了。新增代码如下:
Java代码
// 桑塔纳汽车  
class Santana implements Car {  
    public String getName() {  
        return "Santana";  
    }  
 
    public int getPrice() {  
        return 80000;  
    }  


// 桑塔纳汽车
class Santana implements Car {
public String getName() {
return "Santana";
}

public int getPrice() {
return 80000;
}
}


重载(overloading)和重写(overriding)

重载和重写都是针对方法的概念,在弄清楚这两个概念之前,我们先来了解一下什么叫方法的型构(英文名是signature,有的译作“签名”,虽然它被使用的较为广泛,但是这个翻译不准确的)。型构就是指方法的组成结构,具体包括方法的名称和参数,涵盖参数的数量、类型以及出现的顺序,但是不包括方法的返回值类型,访问权限修饰符,以及abstract、static、final等修饰符。比如下面两个就是具有相同型构的方法:
Java代码
public void method(int i, String s) {  
    // do something  
}  
 
public String method(int i, String s) {  
    // do something  


public void method(int i, String s) {
// do something
}

public String method(int i, String s) {
// do something
}

而这两个就是具有不同型构的方法:
Java代码
public void method(int i, String s) {  
    // do something  
}  
 
public void method(String s, int i) {  
    // do something  


public void method(int i, String s) {
// do something
}

public void method(String s, int i) {
// do something
}

了解完型构的概念后我们再来看看重载和重写,请看它们的定义:

重写,英文名是overriding,是指在继承情况下,子类中定义了与其基类中方法具有相同型构的新方法,就叫做子类把基类的方法重写了。这是实现多态必须的步骤。
重载,英文名是overloading,是指在同一个类中定义了一个以上具有相同名称,但是型构不同的方法。在同一个类中,是不允许定义多于一个的具有相同型构的方法的。

我们来考虑一个有趣的问题:构造器可以被重载吗?答案当然是可以的,我们在实际的编程中也经常这么做。实际上构造器也是一个方法,构造器名就是方法名,构造器参数就是方法参数,而它的返回值就是新创建的类的实例。但是构造器却不可以被子类重写,因为子类无法定义与基类具有相同型构的构造器。
分享到:
评论

相关推荐

    继承与多态,重载和重写

    总结起来,继承、多态、重载和重写是面向对象编程中的核心概念,它们相互关联,共同构建出灵活、可扩展的代码结构。通过继承,我们可以构建类的层次结构,多态则提供了代码的通用性和灵活性。而重载和重写则是实现...

    java 重载,重写以及继承,多态的区别

    Java 中的重载、重写、继承和多态是四个不同的概念,它们之间存在一定的关系,但也存在明显的区别。 重载(Overload) 重载是指在同一个类中可以定义多个同名的方法,但这些方法的形参个数或类型必须不同。编译器...

    [Java]重载,重写以及继承,多态的区

    在Java编程语言中,重载、重写、继承与多态是四个非常核心的概念,它们在面向对象编程中扮演着至关重要的角色。接下来,我们将详细探讨这些概念,并通过实例加以说明。 ### 重载(Overload) 重载是指在同一个类中...

    C++随堂测试(继承、多态、重载)(答案).docx

    通过本资源,读者可以了解到C++中继承的特点和种类、多态的实现方式、重载的规则和限制等。 1. 继承:C++中的继承关系具有自反性、传递性和反对称性。继承可以分为公有继承、私有继承和保护继承三种,分别对应基类...

    继承,重载,重写,多态,抽象类,接口,final,static

    继承,重载,重写,多态,抽象类,接口,final,static

    C#重写重载与多态

    在C#编程语言中,重写、重载和多态是面向对象编程的三大核心特性,它们对于构建灵活、可扩展的代码结构至关重要。 首先,我们来看“重写”。重写(Override)允许子类对从基类继承来的方法进行重新定义,以便提供...

    java基础继承封装多态

    在 Java 中,可以通过方法重写和方法重载来实现多态。方法重写是子类继承父类的方法,并提供不同的实现。方法重载是提供多个同名方法,但是参数类型不同。 面向对象的设计 面向对象的设计是 Java 中的一种设计模式...

    java 接口 类 继承 多态的简单实例

    多态分为编译时多态(方法的重载,Overload)和运行时多态(方法的重写,Override)。 - **重载(Overload)**:是指在同一个类中可以有多个同名方法,但参数列表必须不同(参数个数、类型或顺序),这使得我们可以...

    重载,重写,覆盖,多态

    ### 重载、重写、覆盖与多态的深刻剖析 在面向对象编程语言中,如Java、C#等,重载(Overloading)、重写(Overriding)、覆盖(也称为重写)以及多态(Polymorphism)是几个非常重要的概念。它们之间既有关联又有...

    [Java]重载重写以及继承多态的区别.doc

    ### Java中的重载、重写、继承与多态 #### 一、重载(Overloading) 在Java中,**重载**是指在一个类内可以有多个名称相同但参数列表不同的方法。这些方法可以通过不同的参数类型、数量或者顺序来进行区分。需要...

    java中继承与多态的题目

    * 实现继承和多态的应用,例如方法重写和方法重载 实验结果 通过实验,我们可以看到继承和多态的应用,可以简化程序的设计和实现,提高代码的重用性和可维护性。 结论 本资源摘要信息涵盖了 Java 中继承和多态的...

    C#中多态、重载、重写区别分析

    在C#编程语言中,多态(Polymorphism)、重载(Overloading)和重写(Overriding)是面向对象编程的三个核心概念,它们分别提供了不同的功能和灵活性。下面我们将详细探讨这三个概念以及它们之间的区别。 首先,...

    java 多态重载 PPT

    多态在Java中主要体现在方法的重载(Overloading)和覆盖(Overriding)上。 1. 多态(Polymorphism) 多态的概念指的是同一种行为可以有不同的表现形式。在Java中,多态主要通过继承和接口来实现。例如,`Person`...

    关于继承多态集合和IO的一个例子

    在Java编程语言中,继承、多态、集合和IO流是核心概念,它们构成了程序设计的基础框架。让我们逐一深入探讨这些知识点。 首先,**继承**是面向对象编程的一个关键特性,它允许一个类(子类)继承另一个类(父类)的...

    java中的重载和重写的区别

    Java中的重载(Overloading)和重写(Overriding)是面向对象编程中两个重要的概念,它们体现了Java的多态性。多态性是面向对象编程的三大特性之一,另外两个是封装和继承。 首先,让我们详细解释一下方法的重载。重载...

    封装、继承、多态.docx

    多态可以分为两种形式:方法重载和方法重写。 1. 方法重载:是指多个方法具有相同的方法名,但不同的参数列表。 2. 方法重写:是指子类对父类的方法进行重写,以实现不同的行为。 LSP(里氏代换原则): 1. 子类...

    JAVA进阶-Java继承,多态,重写,修饰符以及super与this使用,Oject对象

    在Java中,多态有两种形式:编译时多态(方法重载)和运行时多态(方法重写)。运行时多态是通过接口或继承实现的,它依赖于对象的实际类型而非声明类型。 3. **重写(Override)**: 当子类需要覆盖或修改父类中...

    浅谈c++的精髓之继承和多态

    ### 面向对象编程与C++中的继承和多态 #### 1. 面向对象编程思想的诞生 面向对象编程(Object-Oriented Programming, OOP)的引入,是为了克服传统面向过程编程的一些局限性。面向过程编程,如C语言,更侧重于按...

Global site tag (gtag.js) - Google Analytics