精华内容
下载资源
问答
  • 运行时多态—在运行时期绑定代码 体现形式—重写向上造型(继承) 2.向上造型 可以调用哪些父类看父亲,方法的具体执行看子类(父类---目录,子类---正文) 即编译看父类、运行看子类 代码 package ...

    多态

    1.多态

    代码执行过程中呈现的多种形式
    

    java分为编译时期、运行时期
    编译时多态---在编译时期绑定代码  体现形式—重载
    public void m(){}
    public void m(int i){}
    运行时多态—在运行时期绑定代码   体现形式—重写、向上造型(继承)

    2.向上造型
    可以调用哪些父类看父亲,方法的具体执行看子类(父类---目录,子类---正文)
    即编译看父类、运行看子类
    代码

    
    package cn.tedu.duotai;
     
    public class DTDemo{
    public static void main(String[]args){
    /*//养个宠物
    Pet p;
    //养的宠物就是一条狗
    p=new Dog();*/
     
    //左边声明类是父类,右边实际创建类是子类---向上造型
    Pet p=new Dog();
    //向上造型对象可以调用哪些方法看父类
    //方法的具体执行要看子类是否有重写方法
    p.eat();
     
     
    //调用方法
    //匿名对象是当做参数来传递
    m(new Pet());
    m(new Dog());
    m(new Cat());
     
    }
    //可以接收本类对象以及所有的子类对象
    public static void m(Petp){//=new Pet();=new Dog();=new Cat();
    p.eat();
    }
    }
     
     
    //定义代表宠物的类
    class Pet{
    public void eat(){
    System.out.println("在吃东西。。。");
    }
    public void sleep(){
    System.out.println("在睡觉。。。");
    }
    }
     
    //定义代表狗的类
    class Dog extends Pet{
    //重写eat方法
    public void eat(){
    System.out.println("在呼哧呼哧的吃。。。");
    }
    public void brak(){
    System.out.println("在汪汪汪的叫。。。");
    }
    }
     
    //定义代表猫的类
    class Cat extends Pet{
    //重写eat方法
    public void eat(){
    System.out.println("在呼哧呼哧的吃。。。");
    }
     
    public void 磨爪子(){
    System.out.println("在哼哧哼哧的磨爪子。。。");
    }
     
    }
    

    3.解释重写原则(反证法)
    1)子类方法访问权限修饰符要么和父类方法访问权限修饰符范围一致,要么大于父类的方法访问权限修饰符的范围

    class Apublic void main(){}
    }
    calss B extends A{
    void m(){} //代码错误
    }
    

    解释:
    A a=new B();向上造型,声明类是A类可以调用A类里的m方法,表明这个m方法可以在任意位置被调用。
    a.m();向上造型对象调用方法具体执行看子类是否有重写方法,执行B类里的m方法,表明m方法同包范围内被调用。此时前后有矛盾,代码错误。

    2)当父类方法返回值类型是引用类型时,那么子类方法返回值类型要么和父类方法返回值类型一致,要么是父类方法返回值类型的子类

    class A{}
    calss B extends A{}
    class C{
    	public B m(){return null;}
    }
    class D extends C{
    public A m(){return null;}
    }
    

    C c=new D(); 向上造型对象c,调用声明类C类m方法返回B类对象可以获取B类里的信息。
    A a=c.m(); 向上造型执行具体方法看子类D类,调用D类里m方法返回A类对象a,由a对象可以获取A类里信息。此时前后矛盾,证明代码是错误的

    4.多态的优点

     1.统一参数类型  
     2.降低耦合度(高内聚、低耦合)
    
    展开全文
  • 多态向上造型

    2019-12-18 16:08:45
    Java 中的多态向上造型(代码): package cn.tedu.duotai; public class DTDemo { public static void main(String[] args) { ///告诉别人想养宠物 //声明—Pet类型的对象p Pet p; //养具体的宠物 //初始化—给值...

    在这里插入图片描述

    Java 中的多态、向上造型(代码):

    package cn.tedu.duotai;
    public class DTDemo {
    public static void main(String[] args) {
    ///告诉别人想养宠物
    //声明—Pet类型的对象p
    Pet p;
    //养具体的宠物
    //初始化—给值
    p=new Dog();
    /
    //想养一个宠物,这个宠物是狗
    //如果左边类型是声明类型—父类 右边是实际创建对象类—子类
    //向上造型 p就是向上造型的对象
    Pet p=new Dog();
    //调用方法
    //方法的执行看子类
    p.eat();
    //调用的是父类方法子类没有重写只执行父类的方法
    p.sleep();
    //乐意调用哪些方法看父类
    //p.bark();
    //证明向上造型是运行时多态
    m(new Cat());
    m(new Dog());
    }
    //接受宠物类对象
    public static void m(Pet p){//=new Cat() =new Dog();
    p.eat();//只有等到运行时期才能确定具体是哪个子类对象才能知道调用哪个子类的方法
    }
    }
    //代表宠物的类
    class Pet{
    //方法
    public void eat(){
    System.out.println(“在吃东西…”);
    }
    public void sleep(){
    System.out.println(“在睡觉…”);
    }
    }
    //代表狗的类
    class Dog extends Pet{
    //对父类的eat方法进行重写
    public void eat(){
    System.out.println(“在呼呼呼的吃…”);
    }
    public void bark(){
    System.out.println(“在汪汪汪的叫…”);
    }
    }
    //代表猫的类
    class Cat extends Pet{
    //对父类的eat方法进行重写
    public void eat(){
    System.out.println(“在优雅的吃…”);
    }
    public void 磨爪子(){
    System.out.println(“在咔哧咔哧的磨…”);
    }
    }
    输出:
    在呼呼呼的吃…
    在睡觉…
    在优雅的吃…
    在呼呼呼的吃…

    Java 中的多态、向上造型(代码图):

    在这里插入图片描述在这里插入图片描述
    输出:
    在这里插入图片描述

    展开全文
  • Java 多态,向上造型

    千次阅读 2017-07-17 09:30:22
    首先我们来定义四个类, 分别是动物类、猫类、狗类、动物信息类, 猫类动物类都继承了动物类,并且都有自己单独的属性。但是在动物信息类中我们定义了一个是动物类的ArrayList,每次new进去的是猫或者狗,但系统...

    首先我们来定义四个类, 分别是动物类、猫类、狗类、动物信息类,  猫类和动物类都继承了动物类,并且都有自己单独的属性。但是在动物信息类中我们定义了一个是动物类的ArrayList,每次new进去的是猫或者狗而不是animal的对象,但系统知道这是什么,,就是说我一各动物列表,里面可以方任何动物,我也可以管理任何动物,当然是需要重写父类方法的,不然要报错,任何动物的属性都在这里得到保留。

    Java的多态变量:

    1 Java的对象变量是多态的,他们能保存不止一种类型对象

    2 它可以保存申明类型的变量,或申明类型的子类的对象

    3 把子类的对象赋到父类的变量的时候就发生了向上造型

    多态条件: 

    1,有继承的存在。
    2,子类重写父类方法。
    3,父类引用指向子类对象。
    动物类:
    package DuoTai;
    
    public class Animal {
    	private String name;
    	private int sex;
    	public void voice(){
    		System.out.println("普通动物叫声");
    	}
    	public Animal(String name, int sex) {
    		super();
    		this.name = name;
    		this.sex = sex;
    	}
    }
    
    猫类:
    package DuoTai;
    
    public class Cat extends Animal{
    	private String maojiao;
    	public void voice(){
    		System.out.println("喵喵喵");
    	}
    	public Cat(String name, int sex, String maojiao) {
    		super(name, sex);
    		this.maojiao = maojiao;
    	}
    }
    
    狗类:
    package DuoTai;
    
    public class dog extends Animal{
    	public dog(String name, int sex, String jiao) {
    		super(name, sex);
    		this.jiao = jiao;
    	}
    	public void voice(){
    		System.out.println("汪汪汪"+jiao);
    	}
    	private String jiao ;
    }
    动物信息类:
    package DuoTai;
    
    import java.util.ArrayList;
    
    public class DataAnimal {
    	private ArrayList<Animal> animal = new ArrayList<Animal>();
    	public void add(Animal a){
    		animal.add(a);
    	}
    	public void list(){
    		for(Animal a : animal){
    			a.voice();
    		}
    	}
    	public static void main(String[] args) {
    		dog d = new dog("白狗",1,"汪汪汪");
    		Cat c = new Cat("黄猫",0,"喵喵喵");
    		add(d);
    		add(c);
    		list();
    	}
    }
    
    
    话说,多态的单词是:polymorphism 
     
    

    展开全文
  • 最近浏览博客的时候看到一个题,主要讲多态的,看了之后仔细研究了一下,发现自己出了不少问题,由于题主没有详细的解释点击打开链接听说体面的人抄袭都要放人家链接,因此在这里分享一下自己遇到的问题也方便大家...

    最近浏览博客的时候看到一个题,主要讲多态的,看了之后仔细研究了一下,发现自己出了不少问题,由于题主没有详细的解释点击打开链接听说体面的人抄袭都要放人家链接,因此在这里分享一下自己遇到的问题也方便大家理解:

    如何理解多态?

    实例解析:

    (一)相关类

    class A ...{

    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");

    }

    public String show(A obj)...{

    return ("B and A");

    }

    }

    class C extends B...{}

    class D extends B...{}

    (二)问题:以下输出结果是什么?

    A a1 = new A();

    A a2 = new B();

    B b = new B();

    C c = new C();

    D d = new D();

    System.out.println(a1.show(b)); ①

    System.out.println(a1.show(c)); ②

    System.out.println(a1.show(d)); ③

    System.out.println(a2.show(b)); ④

    System.out.println(a2.show(c)); ⑤

    System.out.println(a2.show(d)); ⑥

    System.out.println(b.show(b)); ⑦

    System.out.println(b.show(c)); ⑧

    System.out.println(b.show(d)); ⑨

    (三)答案

    ① A and A

    ② A and A

    ③ A and D

    ④ B and A

    ⑤ B and A

    ⑥ A and D

    ⑦ B and B

    ⑧ B and B

    ⑨ A and D

    相信很多道友跟我一样看了答案之后都有点懵,当然大佬除外,下面看我娓娓道来:

    首先理解上述问题你需要知道什么是多态?什么是向上造型?

    多态:即不同的对象对同一消息能做出不同的反应

    向上造型:父类变量可以指向子类对象,能自动转换   Father f = new Son();

    向上造型:子类的变量不能指向父类对象,需要强制转换

    这是某位博主分享的答案:

    ①,②,③调用a1.show()方法,a1 属于A类,A类有两个方法show(Dobj)和show(A obj)。①a1.show(b),参数b为A类的子类对象,这里为向上转型,相当于A obj=b;所以调用show(A obj)方法,得到A and A结果。②同理,③参数为d,调用show(D obj),得到A and D。

    ④,⑤,⑥调用a2.show()方法,A a2 = new B();是向上转型,所以对a2方法的调用,使用A1类的方法show(D obj)和show(A obj),但此时show(A obj)已经被重写为return ("B and A"), ④a2.show(b),调用show(Aobj),得到B and A。⑤同理,⑥调用show(D obj),得到A and D。

    ⑦,⑧,⑨调用b.show()方法,b为B类,B类的show方法有继承的show(D obj),自己的两个show(B obj)、show(A obj)。

    ⑦调用show(B obj),得到B and B,⑧向上转型,调用show(B obj),得到B and B⑨show(D obj),得到A and D

    如果看完上述解析你还很迷惑,来看看是不是遇到了和我一样的问题:

    下面列出了自己或者你可能遇到的一些问题进行解释说明:

    System.out.println(a1.show(b)); //① 输出 A and A

    System.out.println(a1.show(c)); // ② 输出 A and A

    System.out.println(a1.show(d)); //③ 输出 A and D

    /** 1

    * 对于③的中的方法参数变量,D继承自B,B继承自A,为什么该对象变量没有向上造型输出A and A ?

    *

    * 原因:我猜想这与java中函数参数的匹配有关,在进行动态绑定时,首先肯定是匹配与参数同类型的变量,

    * 不能匹配时然后才会考虑它的派生类,并且也遵循就近原则(继承关系离的比较近),可以自己写代码认证

    *

    * */

    System.out.println(a2.show(b)); //④ 输出 B and A

    System.out.println(a2.show(c)); //⑤ 输出 B and A

    System.out.println(a2.show(d)); // ⑥ 输出 A and D

    /** 2

    * 此处要注意的是向上造型后变量调用的方法是子类的方法还是父类的方法:

    * 向上造型后调用的是父类的方法,但当父类中的方法被子类重写后,就需要调用重写后的方法

    */

    System.out.println(b.show(b)); //⑦ 输出 B and B

    System.out.println(b.show(c)); //⑧ 输出 B and B

    System.out.println(b.show(d)); //⑨ 输出 A and D

    /** 3

    * 此处要注意的问题与第一组数据的情况类似,就是向上造型函数参数的匹配应遵循“就近原则”

    * 比如对于⑧来说,变量c是向上造型成了B类型,而不是A类型,而C->B->A,它离B较近,所以也就造型成了B类类型

    */

    展开全文
  • 可扩展性 3)怎么使用多态 3.1)定义父类 3.2)定义子类继承父类 3.3)子类重写父类方法 3.4)子类对象赋给父类引用 3.5)使用父类引用调用 子类重写后的方法 2.强制类型转换 1)什么是类型转换 就是将一个类型的引用, ...
  • 实现多态的前提 ... 要有方法重写,没有也可以,但是没有的话 就没有意义 3。 要有父类引用 指向子类对象 如: 父类 f=new 子类(); * 多态中的成员访问特点 * A, 成员变量 编译看左边, 运行看左边 * B, 构造...
  • 多态: Father f = new Children(); 1.成员变量 编译看左边,访问看左边(只能访问父类的变量) 2.构造方法 创建子类对象的时候, 访问父类的构造方法, 对父类的数据进行...向上造型 Father f = new Children(); f可以调
  • Java的多态浅谈

    2021-03-17 20:40:29
    如果非要用专业术语来描述什么是多态的话多态是指程序中定义的引用变量所指向具体类型通过该引用变量发出的方法调用在编译的时候并不确定,而是程序运行期间才确定,就是说一个引用变量到底指向哪一个类的实例对象...
  •  面向对象程序设计语言有三大特性:封装、继承多态性。继承是面向对象语言的重要特征之一,没有继承的语言只能被称作“使用对象的语言”。继承是非常简单而强大的设计思想,它提供了我们代码重用程序组织的有力...
  • 继承完成后,子类(Sub class)可以继承父类(Super class)的成员变量及成员方法,同时子类也可以定义自己的成员变量成员方法。届时,子类将具有父类的成员及本类的成员。需要注意的是,Java语言不支持多重继承,即:...
  • 多态:代码在编译中多种状态的展示 ...--向上造型 4、多态中,成员方法编译看左边,运行看右边 就是编译申明变量的时候 a是Animal 而在运行的时候 a是dog 多态中的成员访问特点: A:成员变量 ...
  • 多态通过分离“做什么”“怎么做”,从另外一个角度将接口实现分离开来。多态不但能够改善代码的组织结构可读性,还能够创建“可扩展的”程序,在项目需要添加新功能时,都可以进行扩充。 向上转型 由于继承...
  • 1,重载(overload)是在同一个类中,方法名相同,但参数列表不同;如下: class A{  A(){} A(int a){ this();//调用上面无参构造,对应的还有super();...方法的签名是方法名参数名,不包含返回值,所以重载...
  • 向上造型的意义

    2020-12-29 11:17:24
    1、java向上造型强制转换的好处这还用说,方便了类型之间转换。这样扩展性不好了吗。数据类型不也是这样的吗?望采纳,谢谢2、java向上造型的意义?举例子说明!谢谢!?3、java里面的向上造型是什么?_?抽象类接口有...
  • 一、多态是继封装、继承之后,面向对象的第三大特性。现实事物经常会体现出多种形态,如学生,学生是人的一种,则一个具体的同学张三既是学生也是人,即出现两种形态。 Java作为面向对象的语言,同样可以描述一个...
  • 所有版本 JDK1.7 抽象方法静态常量 ​ 静态常量 ​ 命名规则: ​ //默认添加public static final ​ 全部大写,如果有单词拼接使用_进行拼接 ​ ps: CASE_INSENSITIVE_ORDER ​ 构造方法:接口...
  • 在我的明白:java的向上和向下转型可以看成是类型的转换。————————————————版权声明:本文为CSDN博主「ldsh304」的原创文章,遵照CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。原文链接...
  • 1、java里面的向上造型是什么?_?抽象类接口有什么关系?c++里面的虚函数是java里面的接口向上造型一个泛型对象的引用例如,假设我们有很多箱子,每个箱子里都装有不同的水果,我们需要找到一种方法能够通用的处理...
  • 说到重载和重写,大家可能都知道。它们都是多态性的体现,那么说什么是多态呢?多态是指允许不同子类型的对象对同一行为作出不同的响应。例如在生活中,比如跑的动作,小猫、小狗大象,跑起来是不一样的。再比如飞...
  • 先来捋一下什么是向上造型吧 public class Person{ //定义父类Person public void eat(){ System.out.println("person eat"); }; public void shower(){ System.out.println("person shower"); //父类独有方法...
  • 父类(接口)的 引用指向子类(实现)的对象3、多态的好处弊端:好处:多态的存在提高了程序的扩展性后期可维护性弊端:虽然可以预先使用,但是只能访问父类中已有的功能,运行的是后期子类的功能内容。不能预先...
  •  ps:多态性中,例如方法的重载、覆写,向上转型等都是组成多态性的成分之一;但好像大部分人默认将类似A a = new B;(B继承于A,B覆写了A方法)的直接称为多态。(那我也随流吧)   深度理解:Animal animal = new...
  • 面向对象、类对象、封装继承多态重写和重载、构造方法、内部类、包装类、对象实例化的四种方式
  • 关于Java多态和重载

    2020-10-18 22:14:49
    关于多态和重载 多态 什么是多态 多态是同一个行为具有多个不同表现形式或形态的能力。 多态存在三个条件 继承 重写 父类引用指向子类对象 体现 父类类型的引用 指向 子类的对象 Person p = new Teacher(); 该...
  • 多态是面向对象的重要特性,简单点说:“一个接口,多种实现”,就是同一种事物表现出的多种形态。 编程其实就是一个将具体世界进行抽象化的过程,多态就是抽象化的一种体现,把一系列具体事物的共同点抽象出来, 再...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,933
精华内容 773
关键字:

多态重写和向上造型