锐客网

  1. 首页 > 睿知 > it技术 > >

java多态性代码演示 java多态性的实现

IT技术方法

写一段能体现多态性的简单代码（java）1. public class Animal
2. {
3.public void bite()
4.{
5.
6.}
7.
8.
9.public static void main(String... args)
10.{
11.Animal A = new Cat();
12.Animal B = new Dog();
13.
14.A.bite();
15.B.bite();
16.}
17.
18. }
19.
20.
21. class Cat extends Animal
22. {
23.public void bite()
24.{
25.System.out.println("MiaoMiao is bitting");
26.}
27. }
【java多态性代码演示 java多态性的实现】28.
29.
30. class Dog extends Animal
31. {
32.public void bite()
33.{
34.System.out.println("WangWang is bitting");
35.}
36. }
谁能详细解释一下Java运行时多态性的实现??本人对多态有点困惑..拜托各位大神运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法” 。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制，下面就继承和接口实现两方面谈谈java运行时多态性的实现 。一、通过继承中超类对象引用变量引用子类对象来实现举例说明java多态性代码演示： //定义超类superA class superA { int i = 100; void fun() { System.out.println(“This is superA”); } } //定义superA的子类subB class subB extends superA { int m = 1; void fun() {System.out.println(“This is subB”); } } //定义superA的子类subC class subC extends superA { int n = 1; void fun() {System.out.println(“This is subC”); } }class Test { public static void main(String[] args) { superA a; subB b = new subB(); subC c = new subC(); a=b; a.fun(); (1) a=c;a.fun(); (2) } }运行结果为java多态性代码演示： This is subB This is subC上述代码中subB和subC是超类superA的子类，java多态性代码演示我们在类Test中声明了3个引用变量a, b, c，通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用 。也许有人会问：“为什么(1)和(2)不输出：This is superA” 。java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的 ， 也就是说被子类覆盖的方法 。所以，不要被上例中(1)和(2)所迷惑 ， 虽然写成a.fun()，但是由于(1)中的a被b赋值，指向了子类subB的一个实例 ， 因而(1)所调用的fun()实际上是子类subB的成员方法fun()，它覆盖了超类superA的成员方法fun()；同样(2)调用的是子类subC的成员方法fun() 。另外，如果子类继承的超类是一个抽象类 ， 虽然抽象类不能通过new操作符实例化，但是可以创建抽象类的对象引用指向子类对象，以实现运行时多态性 。具体的实现方法同上例 。不过 ， 抽象类的子类必须覆盖实现超类中的所有的抽象方法，否则子类必须被abstract修饰符修饰，当然也就不能被实例化了 。二、通过接口类型变量引用实现接口的类的对象来实现接口的灵活性就在于“规定一个类必须做什么，而不管你如何做” 。java多态性代码演示我们可以定义一个接口类型的引用变量来引用实现接口的类的实例，当这个引用调用方法时 ， 它会根据实际引用的类的实例来判断具体调用哪个方法，这和上述的超类对象引用访问子类对象的机制相似 。举例说明： //定义接口InterA interface InterA { void fun(); } //实现接口InterA的类B class B implements InterA { public void fun() {System.out.println(“This is B”); } }//实现接口InterA的类C class C implements InterA { public void fun() {System.out.println(“This is C”); } }class Test { public static void main(String[] args) { InterA a; a= new B(); a.fun();a = new C();a.fun();} } 输出结果为： This is B This is C上例中类B和类C是实现接口InterA的两个类，分别实现了接口的方法fun() ， 通过将类B和类C的实例赋给接口引用a而实现了方法在运行时的动态绑定 ， 充分利用了“一个接口，多个方法”展示了Java的动态多态性 。需要注意的一点是：Java在利用接口变量调用其实现类的对象的方法时，该方法必须已经在接口中被声明，而且在接口的实现类中该实现方法的类型和参数必须与接口中所定义的精确匹配 。结束语：以上就是java运行时多态性的实现方法 ， 大家在编程过程中可以灵活运用，但是在性能要求较高的代码中不提倡运用运行时多态，毕竟Java的运行时动态方法调用较之普通的方法调用的系统开销是比较大的 。
JAVA 接口与多态 求符合下列要求的代码多态是面向对象编程的特征之一java多态性代码演示 ， 而接口是一系列方法的声明java多态性代码演示 ， 是一些方法特征的集合java多态性代码演示，有特定的语法和结构java多态性代码演示，这两者根本不是同一类型和层次上的概念 。接口毫无疑问可以体现出多态性来java多态性代码演示，但是多态性未必一定要用接口，只要存在方法的重写、重载与动态连接即可体现多态性（如存在继承关系的类之间） ， 所以 ， 不存在“什么时候用接口什么时候用多态”的问题，程序里写的具体代码只可能是接口，只是这代码可能会体现出多态性而已，两者可以在不同的概念层次上并存，不存在冲突 。
简而言之 ， 你可以在程序里用代码定义一个接口 ， 但是你不能定义一个多态 ， 多态只是对你代码特征的一种描述 ， 一种概念上的抽象和总结 。
请举例解释一下java的多态 谢谢了 。。。方法的重写和重载是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);
}
}
最后的输出结果分别是father和mother，将派生类的引用传给基类的引用，然后调用重写方法，基类的引用之所以能够找到应该调用那个派生类的方法 ， 就是因为程序在运行时进行了绑定 。
Java运行时多态性的实现 运行时多态性是面向对象程序设计代码重用的一个最强大机制 动态性的概念也可以被说成 一个接口 多个方法 Java实现运行时多态性的基础是动态方法调度 它是一种在运行时而不是在编译期调用重载方法的机制 下面就继承和接口实现两方面谈谈java运行时多态性的实现
一 通过继承中超类对象引用变量引用子类对象来实现
举例说明
//定义超类superA
class superA
{
int i =
void fun（）
{
System out println（ This is superA ）
}
}
//定义superA的子类subB
class subB extends superA
{
int m =
void fun（）
{
System out println（ This is subB ）
}
}
//定义superA的子类subC
class subC extends superA
{
int n =
void fun（）
{
System out println（ This is subC ）
}
}
class Test
{
public static void main（String[] args）
{
superA a
subB b = new subB（）
subC c = new subC（）
a=b
a fun（）（ ）
a=c
a fun（）（ ）
}
}
运行结果为
This is subB
This is subC
上述代码中subB和subC是超类superA的子类 我们在类Test中声明了 个引用变量a b c 通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用 也许有人会问 为什么（ ）和（ ）不输出 This is superA java 的这种机制遵循一个原则 当超类对象引用变量引用子类对象时 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法 但是这个被调用的方法必须是在超类中定义过的 也就是说被子类覆盖的方法
所以 不要被上例中（ ）和（ ）所迷惑 虽然写成a fun（） 但是由于（ ）中的a被b赋值 指向了子类subB的一个实例 因而（ ）所调用的fun（）实际上是子类subB的成员方法fun（） 它覆盖了超类superA的成员方法fun（） 同样（ ）调用的是子类subC的成员方法fun（）
另外 如果子类继承的超类是一个抽象类 虽然抽象类不能通过new操作符实例化 但是可以创建抽象类的对象引用指向子类对象 以实现运行时多态性 具体的实现方法同上例
不过 抽象类的子类必须覆盖实现超类中的所有的抽象方法 否则子类必须被abstract修饰符修饰 当然也就不能被实例化了
二 通过接口类型变量引用实现接口的类的对象来实现
接口的灵活性就在于 规定一个类必须做什么 而不管你如何做 我们可以定义一个接口类型的引用变量来引用实现接口的类的实例 当这个引用调用方法时 它会根据实际引用的类的实例来判断具体调用哪个方法 这和上述的超类对象引用访问子类对象的机制相似
举例说明
//定义接口InterA
interface InterA
{
void fun（）
}
//实现接口InterA的类B
class B implements InterA
{
public void fun（）
{
System out println（ This is B ）
}
}
//实现接口InterA的类C
class C implements InterA
{
public void fun（）
{
System out println（ This is C ）
}
}
class Test
{
public static void main（String[] args）
{
InterA a
a= new B（）
a fun（）
a = new C（）
a fun（）
}
}
输出结果为
This is B
This is C
上例中类B和类C是实现接口InterA的两个类 分别实现了接口的方法fun（） 通过将类B和类C的实例赋给接口引用a而实现了方法在运行时的动态绑定 充分利用了 一个接口 多个方法 展示了Java的动态多态性
需要注意的一点是 Java在利用接口变量调用其实现类的对象的方法时 该方法必须已经在接口中被声明 而且在接口的实现类中该实现方法的类型和参数必须与接口中所定义的精确匹配
lishixinzhi/Article/program/Java/hx/201311/26085
求一个Java的接口使用多态的例子.谢谢例子
public class MainWindow{
........
public void showChildWindow(IChildWindow childWindow)
{
//显示子窗口
//只要子窗口实现了 IChildWindow接口，就可以显示，而显示什么内容，由接口的实现类来决定，在此方法中不用关心子窗口的具体实现类，childWindow可以有多种“形态”，传说中的多态 。
childWindow.show();
}
}
public interface IChildWindow {
//显示子窗口
public void show();
}
public class FirstChildWindow implements IChildWindow
{
public void show(){
//显示窗口的代码
}
}
public class SecondChildWindow implements IChildWindow
{
public void show(){
//显示窗口的代码
}
}
java多态性代码演示的介绍就聊到这里吧，感谢你花时间阅读本站内容 ， 更多关于java多态性的实现、java多态性代码演示的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：html5比较javascript的简单介绍

    下一篇：刘德华抖音直播配乐叫什么，刘德华抖音直播唱的什么歌