精华内容
下载资源
问答
  • 面向对象多态性

    2019-12-29 18:41:28
    面向对象多态性 面向对象的多态性体现在,一个对象有多种形态,例如:对象小明是一个学生,但也是一个人类。面向对象的多态性是建立在继承性之上的。 对象的向上转型。 对象的向上转型是安全的,创建子类当父类用。...

    面向对象多态性

    面向对象的多态性体现在,一个对象有多种形态,例如:对象小明是一个学生,但也是一个人类。面向对象的多态性是建立在继承性之上的。

    1. 对象的向上转型。
      对象的向上转型是安全的,创建子类当父类用。类和接口都是可以向上转型的
      父类 对象名 = new 子类();
      接口 对象名 = new 实现类();

    eg:

    //父类
    public class Fu {
        int num = 10;
    
    
        public void method1(){
            System.out.println("父类方法执行");
        }
        public void method2(){
            System.out.println(num);
        }
        public void methodFu(){
            System.out.println("父类方法");
        }
    }
    
    //子类
    public class Zi extends Fu {
    
        int num = 100;
        int age = 20;
        @Override
        public void method1() {
            System.out.println("子类方法执行");
        }
    
        @Override
        public void method2() {
            System.out.println(num);
        }
    
        public void methodZi(){
            System.out.println("子类方法");
        }
    }
    
    //main
    public static void main(String[] args) {
            Fu obj = new Zi();
            obj.method1();//子类方法执行
            System.out.println("========================");
            //口诀:编译看左边,运行还看左边
    //        System.out.println(zi.age);//错误写法
            System.out.println(obj.num);//100
            obj.method2();//子类方法执行
            System.out.println("=========================");
            //口诀:编译看左边,运行看右边
            //编译时方法必须是父类中有的方法
            // 运行时会优先从子类中寻找,没有则向上找
            obj.methodFu();//父类方法执行
    //        obj.methodZi();错误写法
        }
    

    这时用Fu obj = new Zi(); 语句创建的对象obj被当做父类来使用,obj只能运行子类重写的父类方法和父类中未被重写的方法。编译时能否通过要看obj.方法是否是父类定义中的方法,运行时却会先从子类重写方法中查找,没有则向上找。这样就会产生一个问题,子类中定义的自己的方法无法被调用,这时就需要对象向下转型。
    2. 对象的向下转型。
    当向上转型的对象,需要调用子类原本的方法时,就需要向下转型。向下转型不一定是安全的所以需要判断。
    eg:

    //父类
    public abstract class Animal {
        public abstract void eat();
    }
    
    //子类Cat
    public class Cat extends Animal{
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
    
        }
        public void play(){
            System.out.println("猫玩老鼠");
        }
    }
    
    //子类Dog
    public class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("狗吃shit");
        }
        public void watchHouse(){
            System.out.println("狗看家");
        }
    }
    
    //main
    public class Demo01ClassCast {
        public static void main(String[] args) {
            //multi向上转型,一定是安全的。
            Animal animal = new Cat();
            animal.eat();//猫吃鱼
            //但是会丧失cat类原本的方法play();
    //        animal.play();错误
            //所以需要向下转型
            Cat cat = (Cat) animal;
            cat.eat();//猫吃鱼
            cat.play();//猫玩老鼠
            //向下转型如果不是还原回原本的类型
            // 就会出现运行错误。
    //        Dog dog = (Dog) animal;//类转换错误,ClassCastException
            System.out.println("===============================");
            getPet(new Dog());//调用判断方法
        }
        public static void getPet(Animal animal){
        //判断向下转型能否成功
            if (animal instanceof Dog) {
                Dog dog = (Dog) animal;
                dog.eat();
                dog.watchHouse();
            }
            if (animal instanceof Cat) {
                Cat cat = (Cat) animal;
                cat.eat();
                cat.play();
            }
        }
    }
    

    对于使用了Animal animal = new Cat();语句的animal来说,如果使用 Dog dog = (Dog) animal; 语句向下转型就会发生类转换错误( ClassCastException )。所以向下转型不一定是安全的,所以需要使用 instanceof关键字来判断。animal instanceof Cat为true值,证明可以向下转型。

    1. 多态的用处
      如上例,我们只需要写一个方法getPet(Animal animal),就可以实现调用两个以上的子类方法。而传参只有一个animal,简化了方法数量,和方法参数。
    展开全文
  • 多态性面向对象(OOP)三大特性:封装、继承、多态。多态性(polymorphism)指同一行为具有多种不同表现形式,在面向对象程序设计中...面向对象多态性存在的三个必要条件继承重写父类引用指向子类对象多态性的实现方式...

    多态性

    面向对象(OOP)三大特性:封装、继承、多态。

    多态性(polymorphism)指同一行为具有多种不同表现形式,在面向对象程序设计中表现为同一消息可以根据发送对象的类型不同,做出多种不同的行为。

    多态性的优点

    多态性能够从一定程度上消除类型之间的耦合关系,通过统一接口方式,不同类的对象可以直接替换,程序更加灵活,可扩展。

    面向对象多态性存在的三个必要条件

    继承

    重写

    父类引用指向子类对象

    多态性的实现方式

    重写(Override)与重载(Overload)

    静态多态性:方法重载(Method Overloading)

    方法重载(Method Overloading)允许类具有多个相同名称的方法,但是方法参数列表不同。

    重载形式:

    case 1: 参数数量变化(有效)

    add(int, int)

    add(int, int, int)

    case 2: 参数数据类型变化(有效)

    add(int, int)

    add(int, float)

    case 3: 参数数据类型顺序变化(有效)

    add(int, float)

    add(float, int)

    bad case 1: 仅改变返回类型(无效)

    int add(int, int)

    float add(int, int)

    Java 方法签名由方法名称和其后的参数列表共同决定,仅改变返回类型编译器无法重载。 不过方法重载(Method Overloading)允许改变返回类型和存取权限,但两者不属于方法签名。

    方法重载(Method Overloading)式多态性,即方法调用取决于调用时传递的参数(数量、类型、顺序),属于编译时静态多态性。

    动态多态性:方法重写(Method Overriding)

    方法重写(Method Overriding)允许子类对父类可以访问的方法,实现自定义行为,但是方法签名需要保持一致。重写的优点在于,无需修改父类代码即可改变子类继承的方法。

    重写形式:

    重写依赖继承,通过父类引用,指向子类对象实现动态多态性。

    public class Animal{

    public void sound(){

    System.out.println("Animal is making a sound");

    }

    }

    public class Cat extends Animal{

    @Override

    public void sound(){

    System.out.println("Meow");

    }

    public static void main(String args[]){

    Animal obj = new Cat();

    obj.sound();

    }

    }

    输出:

    Meow

    重写(覆盖)规则:

    方法签名(方法名称和参数列表)必须一样,返回类型需要兼容。

    不能降低方法的存取权限。

    static, private, final 标记的方法以及类的构造方法不能被重写(覆盖)。

    分析原因:

    Java 通过方法签名标识方法,因此重写需要确保是子类继承自父类的同一方法。

    子类不可以降低父类方法的存取权限(可见性),但可以升级。继承反映一种 “is a” 关系,子类是父类,支持父类所有对外开放的行为。降低方法的存取权限,使得父类作为统一接口方式调用方法的能力被破坏。

    private, final 标记的方法以及父类的构造方法无法继承,故无法重写。

    static 标记的方法为静态方法属于类,通过类名.方法名形式调用,无需依赖对象。

    静态方法和属性会被子类继承,子类同样允许定义同名静态方法和属性,区别于实例方法“重写”和属性“重名”,这种情况被称为“隐藏”。此时子类中调用同名的父类静态方法和属性,需要指明父类名.方法名或父类名.变量名。

    静态绑定与动态绑定

    多态性的类型可以分为运行时和编译时,方法重写(Method Overriding)代表运行时动态多态性,方法重载(Method Overloading)代表编译时静态多态性。

    方法调用与方法体的关联称为绑定,有两种类型的绑定:在编译时发生的静态绑定(Static Binding or Early Binding)和在运行时发生的动态绑定(Dynamic Binding or Late Binding)。

    static, private, final 标记的方法以及类的构造方法是静态绑定的,在编译时确定所属类的类型,因此这些方法无法覆盖。其他非标记的方法可以称为“虚函数”,Java 中其实并没有“虚函数”的概念,所有普通函数(方法)默认都相当于 C++ 的”虚函数”允许覆盖(Override),因此虚函数(Virtual Method)能够根据运行时具体对象的类型进行动态绑定实现动态多态性,例如方法重写(Method Overriding)。

    静态绑定示例:

    class Human{

    public static void walk()

    {

    System.out.println("Human walks");

    }

    }

    class Boy extends Human{

    public static void walk(){

    System.out.println("Boy walks");

    }

    public static void main( String args[]) {

    /* Reference is of Human type and object is

    * Boy type

    */

    Human obj = new Boy();

    /* Reference is of Human type and object is

    * of Human type.

    */

    Human obj2 = new Human();

    obj.walk();

    obj2.walk();

    }

    }

    输出:

    Human walks

    Human walks

    声明为 static 的方法不能被重写,但是能够被再次声明(隐藏)。

    Static Binding vs Dynamic Binding

    静态绑定发生在编译时,而动态绑定发生在运行时。

    静态绑定使用的是类信息:类的类型决定调用方法,而动态绑定使用的是对象信息:对象的类型决定调用方法。

    方法重载使用静态绑定,而方法重写使用动态绑定。

    综合练习

    多态性示例程序:

    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 {

    }

    public class Main {

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

    }

    }

    运行结果:

    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

    详细分析:

    A、B、C、D 各类继承关系如图所示:

    3c4fbe07e389df8e1674cd101adca968.png

    A a1 = new A(); 正常创建对象 a1,涉及函数重载 show(),a1 具有调用方法一 show(D obj) 和方法二 show(A obj) 的能力。

    a1.show(b) 由编译器进行静态绑定(前期绑定)方法二 show(A obj)。

    a1.show(c) 由编译器进行静态绑定(前期绑定)方法二 show(A obj)。

    a1.show(d) 由编译器进行静态绑定(前期绑定)方法一 show(D obj)。

    A a2 = new B(); 多态创建父类引用,指向子类对象,a2 向上转型具有调用 A 类方法一 show(D obj) 和方法二 show(A obj) 的能力,其中子类 B 重写父类 A 的方法二 show(A obj) 为方法四 show(A obj)。记住向上转型存在缺点,即不能调用子类中有,父类没有的方法,如方法三 show(B obj)。

    a2.show(b) 运行时动态绑定(后期绑定)方法四 show(A obj)。

    a2.show(c) 运行时动态绑定(后期绑定)方法四 show(A obj)。

    a2.show(d) 由编译器进行静态绑定(前期绑定)方法一 show(D obj)。

    B b = new B(); 正常创建对象 b,涉及函数重载 show(),b 具有调用方法三 show(B obj) 和方法四 show(A obj) 的能力。同时 B 继承自 A 因此拥有方法一 show(D obj) 和方法二 show(A obj) 其中方法二被方法四重写覆盖。

    b.show(b) 由编译器进行静态绑定(前期绑定)方法三 show(B obj)。

    b.show(c) 由编译器进行静态绑定(前期绑定)方法三 show(B obj)。

    b.show(d) 由编译器进行静态绑定(前期绑定)方法一 show(D obj)。

    展开全文
  • 主要介绍了PHP面向对象多态性实现方法,简单说明了面向对象多态性的原理并结合具体实例给出了php实现多态性的相关操作技巧,需要的朋友可以参考下
  • 面向对象多态性 1、多态性的体现: 方法的重载和重写 对象的多态性 2、对象的多态性 向上转型:程序会自动完成 父类 父类对象 = 子类实例 向下转型:强制类型转换 子类 子类对象 = (子类)父类实例 ...

    面向对象多态性

    1、多态性的体现:

    方法的重载和重写

    对象的多态性

    2、对象的多态性

    向上转型:程序会自动完成

             父类  父类对象 = 子类实例

    向下转型:强制类型转换

             子类  子类对象  =  (子类)父类实例

     向上转型:

     

    向下转型: 

     面向对象多态性的应用

     

     面向对象instanceof关键字

     面向对象抽象类应用

     

     

     

     面向对象接口的使用

     

    展开全文
  • Java面向对象多态性

    2017-10-09 14:38:23
    Java面向对象多态性 1、多态性的体现:  方法的重载和重写  对象的多态性 2、对象的多态性:  向上转型:程序会自动完成  父类 父类对象=子类实例  向下转型:强制类型转换  子类 子类对象=...

    Java面向对象多态性


    1、多态性的体现:

      方法的重载和重写

      对象的多态性


    2、对象的多态性:

      向上转型:程序会自动完成

        父类  父类对象=子类实例


      向下转型:强制类型转换

        子类  子类对象=(子类)父类实例


    示例代码:

    public class PolDemo01 {
        
        static class A{
            public void tell1(){
                System.out.println("A--tell1");
            }
            public void tell2(){
                System.out.println("A--tell2");
            }
        }
    
        static class B extends A{
            public void tell1(){
                System.out.println("B--tell1");
            }
            public void tell3(){
                System.out.println("B--tell3");
            }
        }
    
        public static void main(String [] args){
            //向上转型
    //        B b=new B();
    //        A a=b;
    //        a.tell1(); //tell1重写的
    //        a.tell2();
    
            //向下转型
            A a=new B();
            B b=(B)a;
            b.tell1();
            b.tell2();
            b.tell3();
        }
    
    }









    展开全文
  • Java面向对象-对象的多态性Java中的多态性表现:1,方法的重载和重写(覆盖);2,可以用父类的引用指向子类的具体实现,而且可以随时更换为其他子类的具体实现;我们先搞个父类Animal:1 packagecom.java1234.chap03....
  • 多态性方法的重载与重写对象多态性向上转型:程序会自动完成——子类向父类转换,相当于从子类中调取父类成员,筛选父类 父类对象 = 子类实例;向下转型:强制类型转换子类 子类对象 = (子类)父类实例classA{...
  • 多态体现:方法的重载和重写对象多态性2.对象多态性:向上转型:程序会自动完成父类 父类对象 = 子类实例向下转型:强制类型转换子类 子类对象 = (子类)父类实例classA{publicvoidtell01(){System.out.println(...
  • 动态多态指在运行中才能动态的确定方法所指对象,动态多态的实现方式是重写父类中同名成员方法,其调用规则是依据对象在实例化时而非定义时的类型,相应的调用对应类中的同名成员方法,它需要通过动态绑定和重写机制...
  • Java面向对象多态性的应用 示例代码: public class PolDemo2 { static class A1{ public void tell1(){ System.out.println("A1--tell1"); } } static class B1 extends
  • /**1、Java面向对象多态性  * 1多态性的体现  * 1)方法的重写与重载  * 2)对象的多态性  * 2对象的多态性  * 向上转型,程序自动完成  * 父类 父类对象= 子类实例  * 向下转型,强制类型转换  * 子类 子类...
  • 面向对象设计中多态描述的是同一结构在执行时会根据不同的形式展现出不同的效果,在Java中多态性可以分为两种不同的展现形式: 方法的多态性(同样的方法有不同的实现) 对象的多态性(父类与子类实例之间的转换...
  • 测试类 : ... public class TestObj { ... //面向对象多态性 public static void main(String[] args) { //基本调用 Person person =new Person(); person.eat(); Man man =new Man(); // 重写父类 ...
  • C#实现面向对象多态性的三种方式

    千次阅读 2013-05-30 08:54:02
    using System; using System.Collections.Generic; using System.Linq; using System.Text; ... //实现面向对象多态性的有三种方式  //虚方法  //抽象类  //接口  //抽象类:是对
  • 对象多态性(父类与子类实例之间的转换处理); 1、对象多态性之:对象向下转型【子类 子类实例 = (子类) 父类实例,强制完成转换】【向上转型可以实现操作标准的统一性,而向下转型可以保持子类实例的个性化】...
  • 多态这个概念,在Java中指的是变量可以指向的对象的类型,可是变量声明类型的子类。对象一旦创建,它的类型是不变的,多态的是变量。在PHP5中,变量的类型是不确定的,一个变量可以指向任何类型的数值、字符串、对象...
  • java的多态体现的十分清晰,大体分两类:父类引用指向子类对象;接口引用指向实现接口的类对象。...因为php是弱类型语言,如果不开启强类型,对于类型的限制没有那么明显,多态性的作用体现的不清...
  • “` 这里写代码片package jikepol; class A{ public void tell1(){ System.out.println(“a类tell1”); } public void tell2(){ System.out.println(“a类tell2”); ...class B extend
  • 成员变量访问方法: 成员方法访问方法:
  • qq_炫_03909954Java是面向对象的语言,多态性面向对象程序设计代码重用的一个最强大机制,动态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在...
  • 面向对象多态性

    2021-03-10 11:30:35
    面向对象多态性 1.向上转型 多态性: 父类引用于子类的对象 class Person{ private String name; private int age; } class Man extends Person{ private String occupation; } class ManTest{ Person p =...
  • java面向对象多态性

    2021-01-25 22:13:48
    面向对象特征之三:多态性 1.理解多态性:可以理解为一个事物的多种形态。 2.何为多态性: 对象的多态性:父类的引用指向子类的对象(或子类的对象赋给父类的引用) 3. 多态的使用:虚拟方法调用 有了对象的多态性...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,644
精华内容 3,457
关键字:

面向对象多态性