Java中继承、多态、重载和重写介绍
什么是多态?它的实现机制是什么呢?重载和重写的区别在那里?这就是这一次我们要回顾的四个十分重要的概念:继承、多态、重载和重写。 继承(inheritance) 简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲到,这种方式叫重写)的方式,产生一个新的类型。继承是面向对象的三个基本特征--封装、继承、多态的其中之一,我们在使用JAVA时编写的每一个类都是在继承,因为在JAVA语言中,java.lang.Object类是所有类最根本的基类(或者叫父类、超类),如果我们新定义的一个类没有明确地指定继承自哪个基类,那么JAVA就会默认为它是继承自Object类的。 我们可以把JAVA中的类分为以下三种: 类:使用class定义且不含有抽象方法的类。 在这三种类型之间存在下面的继承规律: 类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。 请注意上面三条规律中每种继承情况下使用的不同的关键字extends和implements,它们是不可以随意替换的。大家知道,一个普通类继承一个接口后,必须实现这个接口中定义的所有方法,否则就只能被定义为抽象类。我在这里之所以没有对implements关键字使用“实现”这种说法是因为从概念上来说它也是表示一种继承关系,而且对于抽象类implements接口的情况下,它并不是一定要实现这个接口定义的任何方法,因此使用继承的说法更为合理一些。 以上三条规律同时遵守下面这些约束: 类和抽象类都只能最多继承一个类,或者最多继承一个抽象类,并且这两种情况是互斥的,也就是说它们要么继承一个类,要么继承一个抽象类。 继承给我们的编程带来的好处就是对原有类的复用(重用)。就像模块的复用一样,类的复用可以提高我们的开发效率,实际上,模块的复用是大量类的复用叠加后的效果。除了继承之外,我们还可以使用组合的方式来复用类。所谓组合就是把原有类定义为新类的一个属性,通过在新类中调用原有类的方法来实现复用。如果新定义的类型与原有类型之间不存在被包含的关系,也就是说,从抽象概念上来讲,新定义类型所代表的事物并不是原有类型所代表事物的一种,比如黄种人是人类的一种,它们之间存在包含与被包含的关系,那么这时组合就是实现复用更好的选择。下面这个例子就是组合方式的一个简单示例:
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) 多态是又一个重要的基本概念,上面说到了,它是面向对象的三个基本特征之一。究竟什么是多态呢?我们先看看下面的例子,来帮助理解: //汽车接口 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 继承是多态得以实现的基础。从字面上理解,多态就是一种类型(都是Car类型)表现出多种状态(宝马汽车的名称是BMW,售价是300000;奇瑞汽车的名称是CheryQQ,售价是2000)。将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定,分前期绑定和后期绑定两种。下面解释一下它们的定义: 前期绑定:在程序运行之前进行绑定,由编译器和连接程序实现,又叫做静态绑定。比如static方法和final方法,注意,这里也包括private方法,因为它是隐式final的。 多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的耦合关系,使程序更容易扩展。比如在上例中,新增加一种类型汽车的销售,只需要让新定义的类继承Car类并实现它的所有方法,而无需对原有代码做任何修改,CarShop类的sellCar(Car car)方法就可以处理新的车型了。新增代码如下: // 桑塔纳汽车 class Santana implements Car { public String getName() { return "Santana"; } public int getPrice() { return 80000; } } 重载(overloading)和重写(overriding) 重载和重写都是针对方法的概念,在弄清楚这两个概念之前,我们先来了解一下什么叫方法的型构(英文名是signature,有的译作“签名”,虽然它被使用的较为广泛,但是这个翻译不准确的)。型构就是指方法的组成结构,具体包括方法的名称和参数,涵盖参数的数量、类型以及出现的顺序,但是不包括方法的返回值类型,访问权限修饰符,以及abstract、static、final等修饰符。比如下面两个就是具有相同型构的方法: 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 void method(String s,int i) { // do something } 了解完型构的概念后我们再来看看重载和重写,请看它们的定义: 重写,英文名是overriding,是指在继承情况下,子类中定义了与其基类中方法具有相同型构的新方法,就叫做子类把基类的方法重写了。这是实现多态必须的步骤。 我们来考虑一个有趣的问题:构造器可以被重载吗?答案当然是可以的,我们在实际的编程中也经常这么做。实际上构造器也是一个方法,构造器名就是方法名,构造器参数就是方法参数,而它的返回值就是新创建的类的实例。但是构造器却不可以被子类重写,因为子类无法定义与基类具有相同型构的构造器。 重载、覆盖、多态与函数隐藏 经常看到C++的一些初学者对于重载、覆盖、多态与函数隐藏的模糊理解。在这里写一点自己的见解,希望能够C++初学者解惑。 要弄清楚重载、覆盖、多态与函数隐藏之间的复杂且微妙关系之前,我们首先要来回顾一下重载覆盖等基本概念。 首先,我们来看一个非常简单的例子,理解一下什么叫函数隐藏hide。 #include <iostream> using namespace std; class Base{ public: void fun() { cout << "Base::fun()" << endl; } }; class Derive : public Base{ public: void fun(int i) { cout << "Derive::fun()" << endl; } }; int main() { Derive d; //下面一句错误,故屏蔽掉 //d.fun();error C2660: 'fun' : function does not take 0 parameters d.fun(1); Derive *pd =new Derive(); //下面一句错误,故屏蔽掉 //pd->fun();error C2660: 'fun' : function does not take 0 parameters pd->fun(1); delete pd; return 0; } /*在不同的非命名空间作用域里的函数不构成重载,子类和父类是不同的两个作用域。 接下来的5个例子具体说明一下什么叫隐藏 例1 #include <iostream> using namespace std; class Basic{ public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload }; class Derive :public Basic{ public: void fun2(){cout << "Derive::fun2()" << endl;} }; int main() { Derive d; d.fun();//正确,派生类没有与基类同名函数声明,则基类中的所有同名重载函数都会作为候选函数。 d.fun(1);//正确,派生类没有与基类同名函数声明,则基类中的所有同名重载函数都会作为候选函数。 return 0; } 例2 #include <iostream> using namespace std; class Basic{ public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload }; class Derive :public Basic{ public: //新的函数版本,基类所有的重载版本都被屏蔽,在这里,我们称之为函数隐藏hide //派生类中有基类的同名函数的声明,则基类中的同名函数不会作为候选函数,即使基类有不同的参数表的多个版本的重载函数。 void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;} void fun2(){cout << "Derive::fun2()" << endl;} }; int main() { Derive d; d.fun(1,2); //下面一句错误,故屏蔽掉 //d.fun();error C2660: 'fun' : function does not take 0 parameters return 0; } 例3 #include <iostream> using namespace std; class Basic{ public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload }; class Derive :public Basic{ public: //覆盖override基类的其中一个函数版本,同样基类所有的重载版本都被隐藏hide //派生类中有基类的同名函数的声明,则基类中的同名函数不会作为候选函数,即使基类有不同的参数表的多个版本的重载函数。 void fun(){cout << "Derive::fun()" << endl;} void fun2(){cout << "Derive::fun2()" << endl;} }; int main() { Derive d; d.fun(); //下面一句错误,故屏蔽掉 //d.fun(1);error C2660: 'fun' : function does not take 1 parameters return 0; } 例4 #include <iostream> using namespace std; class Basic{ public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload }; class Derive :public Basic{ public: using Basic::fun; void fun(){cout << "Derive::fun()" << endl;} void fun2(){cout << "Derive::fun2()" << endl;} }; int main() { Derive d; d.fun();//正确 d.fun(1);//正确 return 0; } /* 输出结果 Derive::fun() Base::fun(int i) Press any key to continue */ 例5 #include <iostream> using namespace std; class Basic{ public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload }; class Derive :public Basic{ public: using Basic::fun; void fun(int i,int j)" << endl;} void fun2(){cout << "Derive::fun2()" << endl;} }; int main() { Derive d; d.fun();//正确 d.fun(1);//正确 d.fun(1,2);//正确 return 0; } /* 输出结果 Base::fun() Base::fun(int i) Derive::fun(int i,int j) Press any key to continue */ 好了,我们先来一个小小的总结重载与覆盖两者之间的特征 重载overload的特征: n 相同的范围(在同一个类中); 覆盖override是指派生类函数覆盖基类函数,覆盖的特征是: n 不同的范围(分别位于派生类与基类); 如果基类有某个函数的多个重载(overload)版本,而你在派生类中重写(override)了基类中的一个或多个函数版本,或是在派生类中重新添加了新的函数版本(函数名相同,参数不同),则所有基类的重载版本都被屏蔽,在这里我们称之为隐藏hide。所以,在一般情况下,你想在派生类中使用新的函数版本又想使用基类的函数版本时,你应该在派生类中重写基类中的所有重载版本。你若是不想重写基类的重载的函数版本,则你应该使用例4或例5方式,显式声明基类名字空间作用域。 所以,在派生类中要保持基类的函数重载版本,就应该重写所有基类的重载版本。重载只在当前类中有效,继承会失去函数重载的特性。也就是说,要把基类的重载函数放在继承的派生类里,就必须重写。 这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,具体规则我们也来做一小结: n 如果派生类的函数与基类的函数同名,但是参数不同。此时,若基类无virtual关键字,基类的函数将被隐藏。(注意别与重载混淆,虽然函数名相同参数不同应称之为重载,但这里不能理解为重载,因为派生类和基类不在同一名字空间作用域内。这里理解为隐藏) 插曲:基类函数前没有virtual关键字时,我们要重写更为顺口些,在有virtual关键字时,我们叫覆盖更为合理些,戒此,我也希望大家能够更好的理解C++中一些微妙的东西。费话少说,我们举例说明吧。 例6 #include <iostream> using namespace std; class Base{ public: virtual void fun() { cout << "Base::fun()" << endl; }//overload virtual void fun(int i) { cout << "Base::fun(int i)" << endl; }//overload }; class Derive : public Base{ public: void fun() { cout << "Derive::fun()" << endl; }//override void fun(int i) { cout << "Derive::fun(int i)" << endl; }//override void fun(int i,int j){ cout<< "Derive::fun(int i,int j)" <<endl;}//overload }; int main() { Base *pb = new Derive(); pb->fun(); pb->fun(1); //下面一句错误,故屏蔽掉 //pb->fun(1,2);virtual函数不能进行overload,error C2661: 'fun' : no overloaded function takes 2 parameters cout << endl; Derive *pd = new Derive(); pd->fun(); pd->fun(1); pd->fun(1,2);//overload delete pb; delete pd; return 0; } /* 输出结果 例7-1 #include <iostream> using namespace std; class Base{ public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; } }; class Derive : public Base{}; int main() { Base *pb = new Derive(); pb->fun(1);//Base::fun(int i) delete pb; return 0; } 例7-2 #include <iostream> using namespace std; class Base{ public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; } }; class Derive : public Base{ public: void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } }; int main() { Base *pb = new Derive(); pb->fun(1);//Base::fun(int i) pb->fun((double)0.01);//Base::fun(int i) delete pb; return 0; } 例8-1 #include <iostream> using namespace std; class Base{ public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; } }; class Derive : public Base{ public: void fun(int i){ cout <<"Derive::fun(int i)"<< endl; } }; int main() { Base *pb = new Derive(); pb->fun(1);//Derive::fun(int i) delete pb; return 0; } #include <iostream> using namespace std; class Base{ public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; } }; class Derive : public Base{ public: void fun(int i){ cout <<"Derive::fun(int i)"<< endl; } void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } }; int main() { Base *pb = new Derive(); pb->fun(1);//Derive::fun(int i) pb->fun((double)0.01);//Derive::fun(int i) delete pb; return 0; } #include <iostream> using namespace std; class Base{ public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; } }; class Derive : public Base{ public: void fun(int i){ cout <<"Derive::fun(int i)"<< endl; } void fun(char c){ cout <<"Derive::fun(char c)"<< endl; } void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } }; int main() { Base *pb = new Derive(); pb->fun(1);//Derive::fun(int i) pb->fun('a');//Derive::fun(int i) pb->fun((double)0.01);//Derive::fun(int i) Derive *pd =new Derive(); pd->fun(1);//Derive::fun(int i) //overload pd->fun('a');//Derive::fun(char c) //overload pd->fun(0.01);//Derive::fun(double d) delete pb; delete pd; return 0; } #include <iostream> using namespace std; class Base{ public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; } virtual void fun(char c){ cout <<"Base::fun(char c)"<< endl; } }; class Derive : public Base{ public: void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } }; int main() { Base *pb = new Derive(); pb->fun(0.01);//error C2668: 'fun' : ambiguous call to overloaded function delete pb; return 0; } 好了,我们再来分析一下例8-2。 n 例8-2中,我们也为派生类重载了一个函数版本:void fun(double d) ,同时覆盖了基类的虚函数,我们再来具体来分析一下,基类共有几个函数,派生类共有几个函数: 类型 public class StringTest { public static void main(String[] args) { String a = "ab";// 创建了一个对象,并加入字符串池中 System.out.println("String a = "ab";"); String b = "cd";// 创建了一个对象,并加入字符串池中 System.out.println("String b = "cd";"); String c = "abcd";// 创建了一个对象,并加入字符串池中 String d = "ab" + "cd"; // 如果d和c指向了同一个对象,则说明d也被加入了字符串池 if (d == c) { System.out.println(""ab"+"cd" 创建的对象 "加入了" 字符串池中"); } // 如果d和c没有指向了同一个对象,则说明d没有被加入字符串池 else { System.out.println(""ab"+"cd" 创建的对象 "没加入" 字符串池中"); } String e = a + "cd"; // 如果e和c指向了同一个对象,则说明e也被加入了字符串池 if (e == c) { System.out.println(" a +"cd" 创建的对象 "加入了" 字符串池中"); } // 如果e和c没有指向了同一个对象,则说明e没有被加入字符串池 else { System.out.println(" a +"cd" 创建的对象 "没加入" 字符串池中"); } String f = "ab" + b; // 如果f和c指向了同一个对象,则说明f也被加入了字符串池 if (f == c) { System.out.println(""ab"+ b 创建的对象 "加入了" 字符串池中"); } // 如果f和c没有指向了同一个对象,则说明f没有被加入字符串池 else { System.out.println(""ab"+ b 创建的对象 "没加入" 字符串池中"); } String g = a + b; // 如果g和c指向了同一个对象,则说明g也被加入了字符串池 if (g == c) { System.out.println(" a + b 创建的对象 "加入了" 字符串池中"); } // 如果g和c没有指向了同一个对象,则说明g没有被加入字符串池 else { System.out.println(" a + b 创建的对象 "没加入" 字符串池中"); } } } 运行结果如下: public class StringStaticTest { // 常量A public static final String A = "ab"; // 常量B public static final String B = "cd"; public static void main(String[] args) { // 将两个常量用+连接对s进行初始化 String s = A + B; String t = "abcd"; if (s == t) { System.out.println("s等于t,它们是同一个对象"); } else { System.out.println("s不等于t,它们不是同一个对象"); } } }
public class StringStaticTest { // 常量A public static final String A; // 常量B public static final String B; static { A = "ab"; B = "cd"; } public static void main(String[] args) { // 将两个常量用+连接对s进行初始化 String s = A + B; String t = "abcd"; if (s == t) { System.out.println("s等于t,它们是同一个对象"); } else { System.out.println("s不等于t,它们不是同一个对象"); } } } 它的运行结果是这样: public class StringInternTest { public static void main(String[] args) { // 使用char数组来初始化a,避免在a被创建之前字符串池中已经存在了值为"abcd"的对象 String a = new String(new char[] { 'a','b','c','d' }); String b = a.intern(); if (b == a) { System.out.println("b被加入了字符串池中,没有新建对象"); } else { System.out.println("b没被加入字符串池中,新建了对象"); } } } 运行结果: (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |