`
acen.chen
  • 浏览: 157437 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

JAVA笔试面试必考题系列(九)——继承、多态、重载和重写

阅读更多

JAVA面试题解惑系列(九)——继承、多态、重载和重写

关键字: java 面试题 继承 多态 重载 重写

作者:臧圩人(zangweiren)
网址:http://zangweiren.iteye.com

>>>转载请注明出处!<<<

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

继承(inheritance)

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

我们可以把JAVA中的类分为以下三种:
  1. 类:使用class定义且不含有抽象方法的类。
  2. 抽象类:使用abstract class定义的类,它可以含有,也可以不含有抽象方法。
  3. 接口:使用interface定义的类。

在这三种类型之间存在下面的继承规律:
  • 类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。
  • 抽象类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。
  • 接口只能继承(extends)接口。

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

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

继承给我们的编程带来的好处就是对原有类的复用(重用)。就像模块的复用一样,类的复用可以提高我们的开发效率,实际上,模块的复用是大量类的复用叠加后的效果。除了继承之外,我们还可以使用组合的方式来复用类。所谓组合就是把原有类定义为新类的一个属性,通过在新类中调用原有类的方法来实现复用。如果新定义的类型与原有类型之间不存在被包含的关系,也就是说,从抽象概念上来讲,新定义类型所代表的事物并不是原有类型所代表事物的一种,比如黄种人是人类的一种,它们之间存在包含与被包含的关系,那么这时组合就是实现复用更好的选择。下面这个例子就是组合方式的一个简单示例:
Java代码 复制代码
  1. public class Sub {   
  2.     private Parent p = new Parent();   
  3.   
  4.     public void doSomething() {   
  5.         // 复用Parent类的方法   
  6.         p.method();   
  7.         // other code   
  8.     }   
  9. }   
  10.   
  11. class Parent {   
  12.     public void method() {   
  13.         // do something here   
  14.     }   
  15. }  
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代码 复制代码
  1. //汽车接口   
  2. interface Car {   
  3.     // 汽车名称   
  4.     String getName();   
  5.   
  6.     // 获得汽车售价   
  7.     int getPrice();   
  8. }   
  9.   
  10. // 宝马   
  11. class BMW implements Car {   
  12.     public String getName() {   
  13.         return "BMW";   
  14.     }   
  15.   
  16.     public int getPrice() {   
  17.         return 300000;   
  18.     }   
  19. }   
  20.   
  21. // 奇瑞QQ   
  22. class CheryQQ implements Car {   
  23.     public String getName() {   
  24.         return "CheryQQ";   
  25.     }   
  26.   
  27.     public int getPrice() {   
  28.         return 20000;   
  29.     }   
  30. }   
  31.   
  32. // 汽车出售店   
  33. public class CarShop {   
  34.     // 售车收入   
  35.     private int money = 0;   
  36.   
  37.     // 卖出一部车   
  38.     public void sellCar(Car car) {   
  39.         System.out.println("车型:" + car.getName() + "  单价:" + car.getPrice());   
  40.         // 增加卖出车售价的收入   
  41.         money += car.getPrice();   
  42.     }   
  43.   
  44.     // 售车总收入   
  45.     public int getMoney() {   
  46.         return money;   
  47.     }   
  48.   
  49.     public static void main(String[] args) {   
  50.         CarShop aShop = new CarShop();   
  51.         // 卖出一辆宝马   
  52.         aShop.sellCar(new BMW());   
  53.         // 卖出一辆奇瑞QQ   
  54.         aShop.sellCar(new CheryQQ());   
  55.         System.out.println("总收入:" + aShop.getMoney());   
  56.     }   
  57. }  
//汽车接口
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());
	}
}

运行结果:
  1. 车型:BMW  单价:300000
  2. 车型:CheryQQ  单价:20000
  3. 总收入:320000

继承是多态得以实现的基础。从字面上理解,多态就是一种类型(都是Car类型)表现出多种状态(宝马汽车的名称是BMW,售价是300000;奇瑞汽车的名称是CheryQQ,售价是2000)。将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定,分前期绑定和后期绑定两种。下面解释一下它们的定义:
  1. 前期绑定:在程序运行之前进行绑定,由编译器和连接程序实现,又叫做静态绑定。比如static方法和final方法,注意,这里也包括private方法,因为它是隐式final的。
  2. 后期绑定:在运行时根据对象的类型进行绑定,由方法调用机制实现,因此又叫做动态绑定,或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

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

	public int getPrice() {
		return 80000;
	}
}


重载(overloading)和重写(overriding)

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

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

而这两个就是具有不同型构的方法:
Java代码 复制代码
  1. public void method(int i, String s) {   
  2.     // do something   
  3. }   
  4.   
  5. public void method(String s, int i) {   
  6.     // do something   
  7. }  
public void method(int i, String s) {
	// do something
}

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

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

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

相关推荐

    Java常见笔试、面试题目深度剖析

    Java作为一门广泛使用的编程语言,其在笔试和面试中的考察点涵盖了诸多方面。这份资源"Java常见笔试、面试题目深度剖析"显然是为了帮助求职者更好地准备相关考试而设计的。以下将对Java笔试和面试的一些核心知识点...

    JAVA笔试题大全共120道题+SSH框架

    Java中通过方法重载和重写实现多态。 2. **基本数据类型与封装类**: - **String不是基本数据类型**,而是对象。Java的原始数据类型包括byte, int, char, long, float, double, boolean和short。`String`是final类...

    java考试招聘面试题及总结

    为了在Java考试、招聘面试或笔试中脱颖而出,了解并掌握一系列关键知识点至关重要。以下是对这些核心概念的详细解析: 1. **基础语法**:理解Java的基础语法是入门的第一步,包括数据类型(如整型、浮点型、字符型...

    2019武汉小米笔试题

    - **多态**:理解接口和抽象类在多态中的作用,以及重写和重载的概念。 3. **异常处理** - **异常分类**:熟悉Java中的Checked异常和Unchecked异常,理解何时使用try-catch-finally结构。 - **自定义异常**:...

    java初级程序员试题

    这些题目旨在检验你对Java基础知识的理解和应用能力,帮助你在准备Java初级程序员的面试或考试时查漏补缺,提升编程技能。通过解决这些题目,你可以深入理解Java的基本概念,并能在实际编程中灵活运用。

    北京华夏联合汽车网络技术有限公司Java笔试题

    【标题】:“北京华夏联合汽车网络技术有限公司Java笔试题”涉及的Java知识点解析 【描述】:本题目来源于北京华夏联合汽车网络技术有限公司的Java笔试,通常这样的试题会涵盖Java编程语言的基础、进阶特性以及面向...

    Java面向对象高级编程笔试考试题.doc

    本文档总结了 Java 面向对象高级编程笔试考试题的知识点,涵盖了面向对象编程的基本概念、字符串操作、异常处理、多态、线程、流等多个方面。 1. 面向对象的特征有哪些方面? 面向对象编程的四个基本特征是:抽象...

    扬讯科技JAVA笔试.doc

    - **多态**:同一种行为具有多种表现形式,主要体现在父类引用指向子类对象,以及方法的重写和重载等方面。 #### 3. 重写(override)与重载(overload)的区别 - **重写(Override)**:发生在子类与父类之间,子类...

    java笔试题

    Java笔试题是评估Java开发者基础知识和技术能力的重要方式,尤其在国家职业技术认证Java三级考试中,这类模拟理论试题更是备考的关键。下面将详细讲解Java笔试题可能涵盖的知识点,并结合描述和标签,为考生提供全面...

    2007年9月计算机等级考试二级JAVA笔试真题及答桉.pdf

    【2007年9月计算机等级考试二级JAVA笔试真题及答桉】这份资料主要针对的是全国计算机等级考试中的二级Java科目,旨在测试考生对于Java编程语言的基础知识、编程能力以及对Java语言特性的理解。Java作为一种面向对象...

    java基础笔试题.pdf

    Java是一种广泛使用的面向对象的编程语言...以上就是从Java基础笔试题中提取出的一些关键知识点,涵盖了基本语法、对象、类、接口、数组、继承、多态、线程等多个方面。理解并掌握这些概念是成为合格Java程序员的基础。

    java二期笔试及阿娇爱啊挤挤挨挨加加加

    2. **面向对象**:类、对象的创建与使用,构造器,访问修饰符,方法重载与重写,抽象类与接口,继承,多态性。 3. **集合框架**:List、Set、Map接口的理解与应用,ArrayList、LinkedList、HashSet、HashMap的区别与...

    国二Java考试系统

    3. 继承与多态:设计类的继承结构,实现方法重写和方法重载,运用多态性提高代码的灵活性。 4. 文件与流:理解I/O流的概念,学习文件读写,以及使用BufferedReader和BufferedWriter进行高效输入输出。 四、系统特点...

    JAVASE阶段经典笔试题20道

    在Java SE阶段的经典笔试题目中,涵盖了多个关键知识点,这些知识点对于理解和掌握Java编程至关重要。以下是对这些知识点的详细解释: 1. **编译与运行Java程序**: - `javac`命令用于编译Java源代码(.java文件)...

    东南大学C++期末考试题1

    6. 多态性:C++中的多态性分为编译时多态(通过函数重载和运算符重载实现)和运行时多态(通过虚函数和类继承实现)。题目中运行时多态性由虚函数和类继承实现,答案是B. ③和⑤。 7. `delete`运算符:`delete`用于...

    亚信java笔试题-Notes:笔记

    本知识点汇总将围绕“亚信Java笔试题”展开,旨在帮助求职者准备相关考试,理解并掌握Java的核心概念和技术要点。 1. **Java基础** - **数据类型**:Java分为基本数据类型和引用数据类型。了解每种数据类型的存储...

    60道自动化测试题(含答案),内容全面,知识点覆盖广 适合软件测试面试的同学学习

    5. **重写和重载**: 重写(Overriding)是指子类重新定义父类的方法,以实现不同的功能;重载(Overloading)是多态的一种形式,允许一个类中有多个同名但参数列表不同的方法。 6. **Python数据库操作**: 使用...

Global site tag (gtag.js) - Google Analytics