创新互联建站服务项目包括常山网站建设、常山网站制作、常山网页制作以及常山网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，常山网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到常山省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！
实现多态的方法：1 基类声明虚函数；2 子类重定义基类声明的虚函数；3 程序中用基类对象引用或指针调用虚函数。
用虚函数是实现运行时多态的实现方法，用vitual关键字实现，你可以先建一个基类，里面声明一个虚函数，然后写出这个基类的5个子类，再里面一一实现对基类的虚函数进行重载，即定义同名函数......具体实现自己去做吧
虚函数可以在继承时被重新定义，在使用时，虽让都是从同一个基类继承来的，函数名也一样，可是会有不同的功能，这个就是它的多态
方法重载和方法重写
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
java多态性的机制
1 重载：有同样的方法名称不同的参数列表。a(){} a(String b){}...
2 重写（也称覆盖）：即可以重新编写与父类同名方法形象的称之为重写（覆盖）。
多态包括重载和重写。
重载是：同样的方法名，包含不同的参数或者参数个数或者参数类型。
重写是：同样的方法名，同样的参数个数。
概念：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。简单的说:就是用基类的引用指向子类的对象。原因：我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了代码重用。而多态除了代码的复用性外，还可以解决项目中紧偶合的问题,提高程序的可扩展性.。耦合度讲的是模块模块之间，代码代码之间的关联度，通过对系统的分析把他分解成一个一个子模块，子模块提供稳定的接口，达到降低系统耦合度的的目的，模块模块之间尽量使用模块接口访问，而不是随意引用其他模块的成员变量。有两个好处：1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。//多态的真正作用，可以用在方法的参数中和方法的返回类型中。在方法中的参数，请看下面的例子：public abstract class Driverclass SBenz : Driverclass JD : Driverclass Personpublic Person()this.driver = driver;}}static void Main(string[] args)JD jd = new JD();//刚开始没钱就买辆JD吧p.setDriver(jd);p.drive();SBenz benz = new SBenz();//有钱换车了p.setDriver(benz);p.drive();}在方法的返回类型中，请看下面的例子：上面的例子中,不管是JD还是Benz都是我们自己直接new出来的.我们可以设计一个工厂类,专门生成汽车/*** 我们将多态使用在方法的返回类型中* Driver可以是抽象类,也可以是接口,JD和Benz分别继承该类或实现该借口*/public class CarFactoryelse if (carName.Equals("Benz"))return null;}}}这实际上就是设计模式中的简单工厂模式!类型的参数.,传入参数的时候,可以传入任何一个类的对象，只要是对应的类的对象名称就可以了这就是多态的应用!
多态,就是重载和重写.重载发生在一个类中.重写发生在子类,意思就是子类重写父类相同名称的方法.刚学语言有的东西,不必搞得那么清楚,只有知道怎么用就行了,有的问题你要想真正把它搞得很懂,短时间是不可能的,比如说接口,没有几年工作经验你根本不可能真正理解什么是接口,甚至有的人工作四,五年也没搞明白什么是接口,不要花太多时间去搞这些不容易搞懂的问题.
重载的特性,方法名相同.返回类型,传入方法的参数不同(包括个数和类型).
重写的特性,方法名相同,返回类型,参数均相同,必须发生在子类.
1.Java语言允许某个类型的引用变量引用子类的实例，而且可以对这个引用变量进行类型转换。
Animal animal=new Dog(); //引用变量animal引用一个Animal子类Dog的实例
Dog dog=(Dog)animal; //向下转型，把Animal类型转换为Dog类型
Creature creature=animal; //向上转型，把Animal类型转换为 Creature类型
animal=new Cat(); //引用变量animal引用另一个Animal子类Cat的实例
注：Creature这里指的是生物。
2.如果把引用变量转换为子类类型，称为向下转型，如果把引用变量转换为父类类型，称为向上转型。
3.在进行引用变量的类型转换时，会受到各种限制。而且在通过引用变量访问它所引用的实例的静态属性、静态方法、实例属性、实例方法，以及从父类中继承的方法和属性时，Java虚拟机会采用不同的绑定机制。
4.成员变量、静态方法按照引用变量声明的类型静态绑定；实例方法按照引用变量引用的实例动态绑定。
例如，对于以下这段代码：
Fathers f＝new Sons();
System.out.println(“f.var=”+f.var);
System.out.println(“f.staticVar=”+f.staticVar);
f.method();
f.staticMethod();
运行时将会输出如下结果：
f.var=FatherVar
f.staticVar=StaticFaterVar
Son method
Static Father method
class Fathers{
String var="FatherVar";
static String staticVar="StaticFatherVar";
void method(){System.out.println("Father method");}
static void staticMethod(){System.out.println("Static Father method");}
}
class Sons extends Fathers{
String var="SonVar";
static String staticVar="StaticSonVar";
void method(){System.out.println("Son method");}
static void staticMethod(){System.out.println("Static Son method");}
String sonVar=null;
void sonMethod(){}
}
Java中的多态允许父类指针指向子类实例。如：Father obj=new Child();（其中Child是Father的子类）。这样就产生了一个问题—— 使用这个父类型的指针访问类的属性或方法时，如果父类和子类都有这个名称的属性或方法，哪一个属性或方法会被调用呢？ 最好的办法是实验： class Father int r; Father() r=4; } void printname() System.out.println("Im father"); } } class Child extends Father int r; Child() r=5; } void printname() System.out.println("Im Child"); } } public class Test public static void main(String[] args) Father obj=new Child(); System.out.println(obj.r); obj.printname(); } } 结果输出： 4 Im Child 实验证明。属性会访问父类的。方法分访问子类的。这就是多态了。不要以为Father obj=new Child();这条语句一定会让obj.printname()指向Chlid定义的printname()。实际上，如果你把Father类中的printname()方法删除，这个程序将编译失败。因为Father中的并没有定义printname()这个函数。多态是晚绑定*(见本文最后的资料)的，在Father obj=new Child();这个语句中，如果Father中没有printname()这个函数，就不会为obj建立一个用于调用printname()函数的指针。所以调用obj.printname()会出错。如果Father中有这个函数。指向printname()函数的指针会被创建。在调用obj.printname()时，不会出错，而且，因为obj指向的是new Child()，是个Chld类的实例。所以调用obj.printname()时调用了Child类中定义的printname()。这就是方法的动态绑定。那么，刚才说到把Father类中的printname()方法删掉后，obj将无法调用Child类中的printname()，因为obj.printname()会编译失败。那么如果我就是需要调用要怎么办呢？其实虽然obj是Father类型的，但是它指向的是一个Child类的实例。那么可以将obj强制类型转换为Child。再调用printname()方法就可以了。在上面程序中，把Father类中的printname()方法整个删掉，再将obj.printname() 改成 ((Child)obj).printname()后，编译成功，结果输出： 4 Im Child 两次输出的结果都是Im Child。那么如何可以运行Child类中的printname()来输出“Im Father”呢？ 其实只需要将Father obj=new Child();改成Father obj=new Father();就可以了，呵呵。另一个办法就是将Child类中定义的printname()整个删掉。为什么这样可以成功呢？自己想想，嘿嘿。最后会有个这样的思考题。看到这儿你可能早就想问了： 为什么obj.r是4？为什么不是5？ 呵呵。其实很简单。Java中的多态仅为方法而言，成员变量还是使用的父类的成员变量。也就是说，因为“Father obj =……”，所以obj是Father类型的，所以obj里面的r是Father里面的r，所以输出obj.r就是4了。你又想问： 那么5去哪了？new Child()的时候，不是会把5放到Child的r中吗？ 实际上5还是有的。只是obj.r是4而已。想访问Child中的r，把5读出来，可以这样写： ((Child)obj).r 就是把obj由Father型强制转换成了Child型。OK，方法和属性在多态中是什么样的你都清楚了。现在做个题测试一下吧： 这是J@Whiz1.4的一道题： class Base int i = 99; public void amethod() System.out.println("Base.amethod()"); } Base() amethod(); } } public class Derived extends Base int i = -1; public static void main(String argv[]) Base b = new Derived(); System.out.println(b.i); b.amethod(); } public void amethod() System.out.println("Derived.amethod()"); } } 会输出什么？ 先想想，再看答案： 答案： ======================== Derived.amethod() 99 Derived.amethod() ======================== 讲解： 这个程序的执行过程是这样的： 第一行：Base b=new Derived(); 执行这一行语句的过程中，要构造Derived这个类，而它有父类Base，所以先构造Base类。构造Base类的默认构造函数有定义。内容是执行amethod()方法。实际上，Base类构造方法中的执行amethod()，相当于执行this.amethod()，在这个程序中，就相当于执行b.amethod()。而b是Base类型的，指向了Derived类的实例的指针。所以跟据上面我们的总结，实际上执行的是Derived类的amethod()函数。所以，第一行“Base b=new Derived();”执行完，输出"Derived.amethod()"。第二行：System.out.println(b.i); 这个很简单，成员变量，不考虑多不多态，只看它定义时前面的类型。这个程序中是Base b，所以b.i就是Base类中的i。输出99 第三行：b.amethod(); 调用Derived类中的amethod()方法。其实这行就是迷惑你的，如果没有这一行。你可能会警觉起来——咦？为什么这儿定义一个amethod()呢？没有地方调用它啊？ 有了这行代码，就会使你放松警惕。觉得，啊。定义了这个是用来让b.amethod();调用的。
继承与多态（二）-国信蓝点JAVA视频教程v.ku6.com/show/1KkeeNf5lbRHIBvI.html 多态（三）—国信蓝点JAVA视频教程v.ku6.com/show/Rpcthe7ZkqC_axe8.html
方法的重写和重载是java多态性的不同表现。重写是父类与子类之间多态性的一种表现。重载是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载。并且重载的方法是可以改变返回值的类型的。应该能懂了吧 …………我给你解释下多态的意思 多态，我觉得它的作用就是用来将接口和实现分离开，改善代码的组织结构，增强代码的可读性。以下是我对多态的小结 1. java中除了static和final方法外，其他所有的方法都是运行时绑定的。在我另外一篇文章中说到private方法都被隐式指定为final 的，因此final的方法不会在运行时绑定。当在派生类中重写基类中static、final、或private方法时，实质上是创建了一个新的方法。
2.在派生类中，对于基类中的private方法，最好采用不同的名字。
3.包含抽象方法的类叫做抽象类。注意定义里面包含这样的意思，只要类中包含一个抽象方法，该类就是抽象类。抽象类在派生中就是作为基类的角色，为不同的子类提供通用的接口。
4.对象清理的顺序和创建的顺序相反，当然前提是自己想手动清理对象，因为大家都知道java垃圾回收器。
5.在基类的构造方法中小心调用基类中被重写的方法，这里涉及到对象初始化顺序。
6.构造方法是被隐式声明为static方法。
7.用继承表达行为间的差异，用字段表达状态上的变化。为了给你讲明白，我再给你写端例子 /** * 定义一个基类 */ public class parents { public void print() { system.out.println(“parents”); } } /** * 定义两个派生类 */ public class father extends parents { public void print() { system.out.println(“father”); } } public class mother extends parents { public void print() { system.out.println(“mother”); } } /** * 测试输出结果的类 */ public class test { public void find(parents p) { p.print(); } public static void main(string[] args) { test t = new test(); father f = new father(); mother m = new mother(); t.find(f); t.find(m); } }
重庆分公司
重庆分公司
