java 多态与多重继承

/**
* java 中的每一中操作,操作的数据类型必须合法。父类有的方法子类都有
* 凡是能够使用父类生成对象的地方都可以使用子类生成对象.
*
* 多态性
* 是指允许不同类的对象对同一消息作出响应。
* 多态性包括参数化多态性和包含多态性。多态性语言具有灵活、
* 抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。
* 多态有两种表现形式:重载和覆盖
* 首先说重载(overload),是发生在同一类中。与什么父类子类、继承毫无关系。
* 标识一个函数除了函数名外,还有函数的参数(个数和类型)。也就是说,一个类中可以有两个或更多的函数,
* 叫同一个名字而他们的参数不同。
* 他们之间毫无关系,是不同的函数,只是可能他们的功能类似,所以才命名一样,增加可读性,仅此而已!
* 再说覆盖(override),是发生在子类中!也就是说必须有继承的情况下才有覆盖发生。
* 我们知道继承一个类,也就有了父类了全部方法,如果你感到哪个方法不爽,功能要变
* 那就把那个函数在子类中重新实现一遍。
* 这样再调用这个方法的时候,就是执行子类中的过程了。
* 父类中的函数就被覆盖了。(当然,覆盖的时候函数名和参数要和父类中完全一样,
* 不然你的方法对父类中的方法就不起任何作用,因为两者是两个函数,毫不关系)
*

package Learnbyoneself;

import java.awt.CardLayout;

public class Polymorphism {
    /**
     * java 中的每一中操作,操作的数据类型必须合法。父类有的方法子类都有
     * 凡是能够使用父类生成对象的地方都可以使用子类生成对象.
     *
     * 多态性
     * 是指允许不同类的对象对同一消息作出响应。
     * 多态性包括参数化多态性和包含多态性。多态性语言具有灵活、
     * 抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。
     * 多态有两种表现形式:重载和覆盖
     * 首先说重载(overload),是发生在同一类中。与什么父类子类、继承毫无关系。
     * 标识一个函数除了函数名外,还有函数的参数(个数和类型)。也就是说,一个类中可以有两个或更多的函数,
     * 叫同一个名字而他们的参数不同。
     * 他们之间毫无关系,是不同的函数,只是可能他们的功能类似,所以才命名一样,增加可读性,仅此而已!
     * 再说覆盖(override),是发生在子类中!也就是说必须有继承的情况下才有覆盖发生。
     *  我们知道继承一个类,也就有了父类了全部方法,如果你感到哪个方法不爽,功能要变
     *  那就把那个函数在子类中重新实现一遍。
     *  这样再调用这个方法的时候,就是执行子类中的过程了。
     *  父类中的函数就被覆盖了。(当然,覆盖的时候函数名和参数要和父类中完全一样,
     *  不然你的方法对父类中的方法就不起任何作用,因为两者是两个函数,毫不关系)
     *
     * */

    public static void main(String[] args) {
        Owls ol=new Owls();
        Brid br=new Brid();
        br.brideat();
        ol.brideat();
        br.bridfiy();
        ol.bridfiy();
        br.bridname();
        ol.bridname();
        ol.bridname("OWL");
        br.bridname("Kalmaegi");
        ol.Owleat("OWL");
        ol.Owlfly("OWL");

    }

}
//定义一个基类Brid
class Brid{

     String name="brid";
   public void bridfiy() {
        // TODO Auto-generated method stub
        System.out.println("The brids can fly");
    }
   public void brideat() {
        // TODO Auto-generated method stub
        System.out.println("The brid need to eat food");
    }
   public void bridname(String name){

       System.out.println("My name is "+name);
   }
   public void bridname(){

       System.out.println("My name is "+name);
   }

}
//定义一个子类
class Owls extends Brid{

     public void Owlfly(String name) {
        // TODO Auto-generated method stub
       System.out.println(name+" can fly!");
    }
     public void Owleat(String name) {
        // TODO Auto-generated method stub
       System.out.println(name +" need to eat food!");
    }

}

结果:

The brid need to eat food
The brid need to eat food
The brids can fly
The brids can fly
OWL need to eat food!
OWL can fly!
My name is brid
My name is brid
My name is OWL
My name is Kalmaegi

如上可以比较得知,父类有的子类都有。

java 多态与多重继承

时间: 2024-10-25 12:46:01

java 多态与多重继承的相关文章

Java多态小总结

多态,又可以称为动态绑定,即在运行时确定类型,比如: 1 class A { 2 void draw(){ 3 //输出“A” 4 } 5 } 6 class B { 7 void draw(){ 8 //输出“B” 9 } 10 11 } 这种关系里,如果调用A a = new B(); 此时,被称为向上转型,a的类型可能在很早之前被生命,而在这时候被明确指明是其子类型, 我们如果要去调用draw()方法的时候,会调用输出“B”,这样,便是Java中的“多态”.我们称其为“向上转型”. 但是,

JAVA多态示例

这多态,我觉得是最利害的.在开发大型程序中. 但,也是需要经过足够多的实践经验才能随心利用的. class Quadrangle{ private Quadrangle[] qtest = new Quadrangle[6]; private int nextIndex = 0; public void draw(Quadrangle q){ if(nextIndex < qtest.length){ qtest[nextIndex] = q; System.out.println(nextIn

为什么java不支持多重继承?

什么是钻石问题?如下图所示,B和C继承于A,D继承B和C(多重继承),在D中调用A的方法时,无法判断是调用B中的实现还是C的实现,下图继承关系是个菱形,所以该问题又叫做菱形问题. 如果java要解决这个问题,需要引入更复杂的机制,这和java 的初衷是背道而驰的(simple),但是java中可以实现多个接口,这与多重继承是非常相似的. 为什么java不支持多重继承?,布布扣,bubuko.com

java多态讲解

JAVA多态 一.相关的类结构 class A ...{ //create by danielinbiti public String show(D obj)...{ return ("A and D"); } public String show(A obj)...{ return ("A and A"); } } class B extends A...{ public String show(B obj)...{ return ("B and B&q

Java多态特性:重载和覆写的比较

Java重载: 在同一个类中 方法具有相同的名字,相同或不同的返回值,但参数不同的多个方法(参数个数或参数类型) public class MethoDemo{ public static void main(String args[]){ int one = add(10,20) ; // 调用整型的加法操作 float two = add(10.3f,13.3f) ; // 调用浮点数的加法操作 int three = add(10,20,30) ; // 调用有三个参数的加法操作 Syst

java 中的多重继承

Java中的接口不仅仅是一种更纯粹的抽象类,它的目标比这更高.因为接口是根本没有任具体实现的.也就是说,没有任何与接口相关的存储:因此,也就无法阻止多个接口的组合.这一点是很有价值的,因为你有时候需要去表示"一个X是一个a和一个b以及一个c".在C++中,组合多个类的接口的行为被称作为多重继承.它可能会使你背负很沉重的包袱,因为每个类都有一个具体实现.在java中,你可以执行相同的行为,但是只有一个类可以有具体的实现:因此通过组合多个接口,c++的问题不会在java中发生: 下面展示一

Java多态-继承与清理

通过组合和继承方法来创建新类时,永远不必担心对象的清理问题,子对象通常会留给垃圾回收器进行处理.如果确是遇到清理问题,那必须用心为新的类创建dispose()方法(在这里我们选用此名).并且由于继承的缘故,如果我们有其他作为垃圾回收一部分的特殊清理动作,就必须在导出类中覆盖被继承的dispose()方法.当覆盖被继承的diopose()方法时,务必记住调用基类版本dispose()方法:否则,基类的清理动作就不会发生.下例便是一个证明: package polymorphism; class C

从JVM角度看Java多态

Java多态的三个必要条件: 1. 继承 2. 子类重写父类方法 3. 父类引用指向子类对象 然后看一个例子 输出结果为: 给出结论:当满Java多态的三个条件时,可以发现c.eat()调用的实际上是子类的eat,但c.age调用的还是父类的age,而c.play()则不会通过编译. 但是在java的引用中Father不但指定了c以何种方式访问内存,也规定了能够访问内存空间的大小. 我们看Father实例对象的大小是占两行,但Child实例对象占三行(这里就是简单量化一下). 所以虽然c指向的是

Java 多态(动态绑定)

Java 多态(动态绑定) @author ixenos 绑定 将一个方法的调用和一个方法的主体关联起来,称作(方法调用)绑定: 1.前期绑定:在程序执行前绑定(由编译器和连接程序实现): 2.后期绑定:在运行时根据对象的类型绑定(也称动态绑定或运行时绑定): a) 实现条件:能在运行时判断对象的类型,从而关联对应主体,调用其方法 b) 编译器一直不知道真实对象类型,只将其认作引用变量的类型且知道有继承关系 c) Java中除了static方法和final方法(private方法属于final方