精华内容
下载资源
问答
  • 2021-02-08 21:27:57

    什么是多态?通俗的讲是指事物有多种状态。比如:水在通常情况下是液态,但在外界环境变化时可能会是固态冰或者气态水蒸气。

    Java中多态三个步鄹
    1.要有继承关系
    2.要有方法重写
    3.要有父类应用指向子类对象

    代码案例:动物类
    1.生成一个动物类,成员变量只有名字name和一个成员方法eat。

     package Duotai;
    
     public class Animal {
      private String name;
    
    public Animal() {
    }
    
    public Animal(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println(getName()+"吃饭");
    }
    

    }

    2.生成Dog类为子类继承父类Animal.并重写eat方法
    (因为不同的动物吃的东西不同体现多态)

     package Duotai;
    
    public class Dog extends Animal {
    public void eat(){
        System.out.println(getName()+"吃骨头");
    }
    }
    

    3.写一个测试类

     package Duotai;
    
    public class Test {
    public static void main(String[] args) {
    //父类应用指向子类对象
        Animal an=new Dog();
        an.setName("狗");
        an.eat();
    }
    }
    
    更多相关内容
  • java多态理解

    2018-12-17 14:10:05
    java 个人对于多态理解和一些笔记。
  • Java多态理解

    2021-12-10 15:41:38
    1.多态的定义 所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法...

    1.多态的定义

    所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

    总的来说:多态性指基类型的引用对象指向派生类,指采用多种形式的能力;

    在Java中, 引用变量可以是多态的, 即它可以存放不同类对象的地址,只要这些类是它声明的类的派生类即可。

    2.实例

    向上转型

    1.向上转型 不要强制转型
    2. 父类引用指向的或者调用的方法是子类的方法 , 这个叫动态绑定
    3. 向上转型后父类引用不能调用 子类自己的方法,
    public class triangle {
    
        public void printArea() {
            System.out.println("triangle 's area = ");
        }
    
        public static void main(String[] args) {
            isoscelesTriangle i = new isoscelesTriangle();
            i.printArea();
    
            triangle t = new isoscelesTriangle();// (1)向上转型
            t.printArea();           // (2)动态绑定
          //t. perimeter();  (3)此方法不能编译,报错说trangle类没有此方法
        }
    }
    
    class isoscelesTriangle extends triangle {
        @Override
        public void printArea() {
            System.out.println("triangle 's area = ");
        }
    }

    向下转型

    public class trangle {
        public void printArea() {
            System.out.println("trangle 's area = ");
        }
        public static void main(String[] args) {
        // (1)向上转型
            isoscelesTriangle i1 = new isoscelesTriangle();
            trangle t1 = i1;      
            t1.printArea();
            //t1.printPerimeter();   // 此时需要向下转型,否则不能调用printPerimeter方法。
            
    //        // (2)向下转型
    //        trangle t2 = new isoscelesTriangle();
    //        trangle t2 = i2;  
    //        i2 = (isoscelesTriangle) t2;         
    //        t2.printPerimeter(); 
            
    //        // (3)向下转型:失败
    //        trangle t3 = new trangle();
    //        isoscelesTriangle i3 = (isoscelesTriangle)t3;
    //        t3.printPerimeter();   //此时会出现运行时错误,所以可以用instanceOF判断 
    //        
    //        // (4)向下转型:类型防护
    //        trangle t4 = new trangle();
    //        if (t4 instanceof isoscelesTriangle){  
    //         //因为t4不是isoscelesTriangle的实例,所以不执行if内部代码
    //             isoscelesTriangle i4 = (isoscelesTriangle)t4;
    //             t4.printPerimeter();
    //        }
        }
    }
    class isoscelesTriangle extends trangle {
        @Override
        public void printArea() {
            System.out.println("trangle 's area = ");
        }
    
        public void printPerimeter() {
            System.out.println("trangle 's perimeter = ");
        }
    }

    基类型对象访问派生类重写的方法

    public static void main(String[] args) {
    
    GradedActivity[] tests = new GradedActivity[3];
    
    // 第一次考试采用五级计分制,考了75
    tests[0] = new GradedActivity();
    tests[0].setScore(75);
    
    // 第二次考试采用二级计分制(P或者F)。总共20题,每题分值相同,考生答错5题。
    // 通过的最低分数线是60分
    tests[1] = new PassFailExam(20, 5, 60);
    
    // 第三次是期末考试也采用五级计分制. 总共50题,每题分值相同,考试答错7题
    tests[2] = new FinalExam(50, 7);
    
    // 显示每次考试的分数和等级
    for(int i=0; i<tests.length; i++){
       showValue(tests[i]);
    }
    }
    
    public static void showValue(GradedActivity exam){
    System.out.println("Score: " + exam.getScore()+ "\t" + 
    "Grade: " + exam.getGrade());
    }
    

    3.使用

    前提:多态对象把自己看做是父类类型

    1. 成员变量: 使用的是父类的
    2. 成员方法: 由于存在重写现象,所以使用的是子类的
    3. 静态成员: 随着类的加载而加载,谁调用就返回谁的

    4.总结

    多态指使用父类对象的地方都可以使用子类的对象,多态意味着父类型的变量可以引用子类型的对象。多态的好处是多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法;提高了程序的可扩展性和可维护性。

    展开全文
  • 【Java面试题】谈谈对Java多态理解
  • Java多态理解

    千次阅读 2021-11-29 18:35:26
    Java 多态 除封装和继承之外,面向对象程序设计的第三个支柱。简单来说,多态意味着父类型的变量可以引用子类型的对象 ???? 多态:同一个行为具有不同表现形式或形态的能力,即对象多种表现形式的体现,例如子类的...

    只是小白的学习笔记,有错轻喷🥬

    除封装和继承之外,面向对象程序设计的第三个支柱。简单来说,多态意味着父类型的变量可以引用子类型的对象

    💡 多态:同一个行为具有不同表现形式或形态的能力,即对象多种表现形式的体现,例如子类的实例也可作为父类的实例(Student类是Person类的子类,则一个Student的对象便既是Student,也是Person)


    • 定义与使用格式

      定义格式:父类类型 变量名=new 子类类型();

      例如,通过Object p = new Person(); 代码定义一个变量p

    • 多态中成员的特点

      成员变量:

      Father f=new Son();
      System.out.println(f.num);//f是Father中的值,只能取到父中的值
      

      成员方法:

      Father f1=new Son();
      System.out.println(f1.show());//f1的门面类型是Father,但实际类型是Son,所以调用的是重写后的方法。
      

      例如Object p = new Person();中的变量p只能调用Person类的方法,只能访问Object类的属性

    如图所示,扫描二维码可以对映三种不同的支付方式

    //支付抽象类或者接口
    public abstract class Pay {
        abstract public String pay();
    }
    //支付宝支付
    public class AliPay extends Pay {
        @Override
        public String pay() {
            System.out.println("支付宝pay");
            return "success";
        }
    }
    //微信支付
    public class WeixinPay extends Pay {
        @Override
        public String pay() {
            System.out.println("微信pay");
            return "success";
        }
    }
    //银联支付
    public class YinlianPay extends Pay {
        @Override
        public String pay() {
            System.out.println("银联支付");
            return "success";
        }
    }
    
    //测试支付
    public static void main(String[] args) {
     //支付宝支付
        Pay pay = new AliPay();
        pay.pay();
    
     //微信支付
        pay = new WeixinPay();
        pay.pay();
    
     //银联支付
        pay = new YinlianPay();
        pay.pay();
    }
    
    输出结果如下:
    
    支付宝pay
    微信pay
    银联支付
    
    • 多态产生的必要条件

      1. 继承
      2. 重写
      3. 父类引用指向子类对象
    • 多态的转换

       💡 对象转换:一个对象的引用可以类型转换为对另外一个对象的引用


      1. 隐式转换

        将对象 new Student() 赋值给一个 Object 类型的参数→ Object o = new Student();

        由于Student的实例也是Object的实例,所以语句合法。

      2. 显式转换

        Object o = new Student();
        Student b = o;//编译错误
        

        编译错误原因:通过隐式转换虽然看上去o是一个Student的实例,但是本质仍然为Object,故不能赋值给Student类型的b

        //将(目标对象的类型)放到要转换的对象前面
        Object o = new Student();
        Student b = (Student)o;
        
      3. 向上转换(多态本身就是向上转型过的过程)

        将子类的实例转换为父类的变量

        父类类型 变量名=new 子类类型();

      4. 向下转换(使用(子类名)进行显示转换)

        将父类的实例转换为子类变量

        子类类型 变量名=(子类类型) 父类类型的变量;

    • instanceof操作符

      💡 instanceof操作符:用来判断某个对象是否属于某种数据类型,返回值为布尔类型


    • 多态的优点
    1. 可替换性。多态对已存在代码具有可替换性。例如,多态对圆Circle类工作,对其他任何圆形几何体,如椭圆,也同样工作。
    2. 可扩充性。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性,继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如,对等边三角形的操作,不会影响直角三角形
    3. 接口性。多态是超类通过方法签名, 向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。
    4. 灵活性。它在应用中体现了灵活多样的操作,提高了使用效率。
    5. 简化性。简化了对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。​​​​​​​
    //实例
    public class A {
        public String show(D obj) {
            return ("A and D");
        }
    
        public String show(A obj) {
            return ("A and A");
        } 
    
    }
    
    public class B extends A{
        public String show(B obj){
            return ("B and B");
        }
        
        public String show(A obj){
            return ("B and A");
        } 
    }
    
    public class C extends B{
    
    }
    
    public class D extends B{
    
    }
    
    public class Test {
        public static void main(String[] args) {
            A a1 = new A();
            A a2 = new B();
            B b = new B();
            C c = new C();
            D d = new D();
            
            System.out.println("1--" + a1.show(b));
            System.out.println("2--" + a1.show(c));
            System.out.println("3--" + a1.show(d));
            System.out.println("4--" + a2.show(b));
            System.out.println("5--" + a2.show(c));
            System.out.println("6--" + a2.show(d));
            System.out.println("7--" + b.show(b));
            System.out.println("8--" + b.show(c));
            System.out.println("9--" + b.show(d));      
        }
    }
    //摘自https://blog.csdn.net/thinkGhoster/article/details/2307001
    
    //运行结果
    1--A and A
    2--A and A
    3--A and D
    4--B and A
    5--B and A
    6--A and D
    7--B and B
    8--B and B
    9--A and D
    

    展开全文
  • Java 多态理解

    千次阅读 多人点赞 2018-08-11 13:57:13
    多态:同样的引用调用同样的方法却做了不同的事情。 概述: 在设计一个方法时,通常希望该方法具备定的通用性。 例如要实现一个动物叫的方法,由于每种动物的...在Java中为了实现多态,允许使用一个父类类型的变...
    多态:同样的引用调用同样的方法却做了不同的事情。

    概述:

    在设计一个方法时,通常希望该方法具备定的通用性。 例如要实现一个动物叫的方法,由于每种动物的叫声是不同的,因此可以在方法中接收一个动物类型的参数,当传入猫类对象时就发出猫类的叫声,传人犬类对象时就发出犬类的叫声。在同一个方法中,这种由于参数类型不同而导致执行效果各异的现象就是多态。

    在Java中为了实现多态,允许使用一个父类类型的变量来引用一个子类类型的对象,根据被引用子类对象特征的不同,得到不同的运行结果。

    接下来通过一个程序来演示:

    abstract class Animal {
    	public abstract void shout(); // 定义抽象shout()方法
    }
    
    //定义Cat类继承Animal
    class Cat extends Animal {
    	// 实现shout()方法
    	public void shout() {
    		System.out.println("喵喵...");
    		
    	}
    }
    
    //定义Dog类继承Animal
    class Dog extends Animal {
    	// 实现shout()方法
    	public void shout() {
    		System.out.println("汪汪...");
    		
    	}
    }
    
    public class Duotai {
    	public static void main(String[] args) {
    		Animal cat = new Cat();
    		Animal dog = new Dog();
    		
    		animalShout(dog);
    		animalShout(cat);
    //		运行结果:
    //				汪汪...
    //				喵喵...
    	
    	}
    	
    	// 定义一个静态的animalShout()方法,接收一个Animal类型的对象
    	public static void animalShout(Animal animal) {
    		animal.shout();// 调用实际参数的shout()方法
    	}
    }
    

    Animal cat = new Cat();和 Animal dog = new Dog(); 两行代码实现了父类类型变量引用不同的子类对象。

    调用animalShout()方法时,将父类引用的两个不同子类对象分别传入,结果打印出了“汪汪...”和“喵喵...”。

    由此可见,多态不仅解决了方法同名的问题,而且还使程序变得更加灵括,从而有效地提高程序的可扩展性和可维护性。

    对象的类型转换

    在多态的学习中,涉及到将子类对象当作父类类型使用的情况,例如下面两行代码:

    Animal cat = new Cat();        //将Cat对象当作Animal类型来使用

    Animal dog = new Dog();     //将Dog对象当作Animal类型来使用

    将子类对象当作父类使用时不需要任何显式地声明,需要注意的是,此时不能通过父类变量去调用子类中的某些方法。

    这种不需要显式声明的类型转换叫自动类型转换。

    对于animalShout()方法来说,传入的对象可以是Animal类型,还可以是Animal的子类型,它要怎么知道传入的到到底是哪一个类型呢?Java提供了一个instanceof关键字来判断一个对象的类型,其使用格式如下:

    对象(或对象的引用变量)  instanceof  类(或接口)

    对上面animalShout()方法代码进行修改:

    	public static void animalShout(Animal animal) {
    		if (animal instanceof Cat) {
    			Cat cat = (Cat) animal;
    			cat.shout();
    		} else if (animal instanceof Dog) {
    			Dog dog = (Dog) animal;
    			dog.shout();
    		} else {
    			animal.shout();
    		}
    	}

    利用instanceof进行类型判断的好处就是避免了强制类型转换过程中类型不匹配的错误。

    多态思维导图:

    JAVA基础思维导图 <<

    展开全文
  • Java 多态简单理解

    2022-03-17 19:32:14
    多态: 多态:多种状态 在面向对象的语言中,接口的不同的实现即为多态 多态性: 允许你将你的父类引用设置成为一个或者多个子类对象 class F{} class Z extends F{} public class Test{ public static void ...
  • java多态理解

    2021-11-26 19:01:45
    一、多态是什么 面向对象的三大特性是封装、继承、多态多态(polymorphic)的定义:父类引用变量可以指向子类对象,允许不同类的对象可以调用同一个方法,即同一个方法可以根据调用对象的不同而有不同的实现...
  • Java多态理解

    2021-11-26 17:14:14
    多态的定义:指为不同的数据类型的实体提供统一的接口 多态意味着父类型的变量可以引用子类型的对象 多态的分类: 多态可分为变量多态与函数多态。变量多态是指:基类型的变量,可以被赋值基类型对象,也可以被...
  • JAVA多态理解

    千次阅读 2022-03-24 20:54:23
    JAVA多态理解以及使用。
  • Java多态理解: 这几天学习到多态,就和python里面的感觉有挺多不一样,开始一直不理解,翻了好几个文章,都没能理解这句话:当使用多态调用方法时,首先检查父类是否有该方法,如果没有则编译错误,如果有,就去...
  • Java如何理解多态

    千次阅读 多人点赞 2021-05-19 21:04:12
    多态到底是啥,就是子类继承父类的方法时,对其该方法按照自己的方式重新定义(覆盖重写)。 1.向上转型。 之前继承有提到过。父类引用指向子类对象。这时的引用只能调用子类覆盖重写了的方法,不能调用子类特有...
  • Java中的多态如何理解——详解

    多人点赞 热门讨论 2022-04-30 17:16:40
    本篇文章我们主要讲解的是Java中的多态,那么什么是多态呢?同类型的对象,执行同一个行为,会表现出不同的行为特征。接下来让我们一起对多态进行详细地讲解。
  • Java多态理解

    千次阅读 2022-02-04 22:56:27
    面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。这是我们最后一个概念,也是最重要的知识点。 2.多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以...
  • JAVA多态理解

    2021-03-07 00:12:04
    面向对象的三大特性:封装、继承、多态,其中最难理解的就是多态以下是网上某大神给的一个例子:1.继承关系classA{publicStringshow(Dobj){return("AandD");}publicStringshow(Aobj){return("AandA");}}...
  • java多态理解笔记1

    2018-07-11 17:32:52
    3.浅显理解java中的动态绑定。 tip:多态是针对函数才有意义,对instance variable讲多态没有意义;同时有static, private, final关键字的函数也是不适用多态的,因为它们的机制是静态绑定。 上述这个继承的例子,...
  • Java多态理解

    2018-07-30 19:14:10
    **Java多态理解** - Java 的多态是建立在继承与接口之上的, - Java的继承跟接口给我们提供了安全向上转型。 **多态运用的原理** 1. 动态绑定(OOP的核心技术) 2. 继承与接口作支持 **使用多态时,应注意在哪些...
  • Java多态的认识和理解

    2022-04-30 17:06:05
    多态是面向对象程序设计的三大特征之一,面向对象的三大特征:封装、继承、多态。 封装给对象提供了隐藏内部特性和行为的能力,保护对象内部的状态,提高了代码的可用性和可维护性。...理解 多态是同一个...
  • 本文为学习笔记,学习资料为:【Java面试题】谈谈对Java多态理解_哔哩哔哩_bilibili 多态的英文是polimorphism,poli为“许多”,morphism为“形态”。 多态的形式 1)编译时多态 编译期间决定目标方法;通过...
  • JAVA多态理解及应用

    2021-12-14 18:45:55
    用详细的代码和注释带你理解多态JAVA
  • java多态理解总结

    2017-11-17 16:36:19
    面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。这是我们最后一个概念,也是最重要的知识点。 1.定义: 多态:指允许不同类的对象对同一消息做出响应。即同一消息可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 96,640
精华内容 38,656
关键字:

java多态的理解

java 订阅
友情链接: matlab_image_process.rar