首页 / JAVA / 【Java】面向对象之多态

【Java】面向对象之多态

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了【Java】面向对象之多态，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5873字，纯文字阅读大概需要9分钟。

内容图文

生活中，比如动物中跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一类的事物通过不同的实际对象可以体现出来的不同的形态。多态，描述的就是这样的状态。

多态： 是指同一行为，具有多个不同表现形式。

具备多态的前提：

（1）具备继承或者实现【二选一】；
（2）方法的重写【不重写，无意义】；
（3）父类引用指向子类对象【格式体现】。

多态的体现

多态体现的格式：

　　父类类型 变量名 = new 子类对象；
　　变量名.方法名();

注意事项：父类类型指子类对象继承的父类类型，或者实现的父接口类型。

定义父类：

            public
            class
             Fu {

    
            public
            void
             method() {
        System.out.println("父类方法");
    }

    publicvoid methodFu() {
        System.out.println("父类特有方法");
    }

}

定义子类：

            public
            class Zi extends Fu {

    @Override
    publicvoid method() {
        System.out.println("子类方法");
    }
} 

定义测试类：

            public
            class
             Demo {

    
            public
            static
            void
             main(String[] args) {
        
            //
             使用多态的写法
        
            //
             左侧父类的引用，指向了右侧子类的对象
            Fu obj = new
            
                 Zi();

        obj.method();
        obj.methodFu();
    }
}
1、访问成员变量

定义父类：

            public
            class
             Fu {

    
            int num = 10;

    public void showNum() {
        System.out.println(num);
    }
}

定义子类：

            public
            class Zi extends Fu {

    int num = 20;

    int age = 16;

    @Override
    public void showNum() {
        System.out.println(num);
    }
}
（1）直接通过对象名称访问成员变量

定义测试类：

            public
            class
             Demo{

    
            public
            static
            void
             main(String[] args) {

        Fu obj = new Zi();

        System.out.println(obj.num); // 父：10    }

}
看 “=” 左边是谁，优先用谁，没有则向上找。
（2）间接通过成员方法访问成员变量
定义测试类：
                public
                class
                 Demo {

    
                public
                static
                void
                 main(String[] args) {

        Fu obj = new Zi();
        // 子类没有覆盖重写，就是父：10
        // 子类如果覆盖重写，就是子：20        obj.showNum(); 
    }

}
看该方法属于谁，优先用谁，没有则向上找。
 
现在我们将上面的测试类添加一段代码，代码如下：
                    public
                    class
                     Demo{

    
                    public
                    static
                    void
                     main(String[] args) {

        Fu obj = new Zi();
        obj.showNum(); 

        System.out.println(obj.age);
    }
}

你会发现编译的时候报错了，这是为什么呢？

那是因为 “=” 左边时父类，但是父类当中没有 age 成员变量，所以编译报错。因此：

成员变量：编译看左边，运行也看左边。

1、访问成员方法
定义父类：
                public
                class
                 Fu {
                public
                void
                 method() {
        System.out.println("父类方法");
    }

    publicvoid methodFu() {
        System.out.println("父类特有方法");
    }

}

定义子类：

                public
                class Zi extends Fu {

    @Override
    publicvoid method() {
        System.out.println("子类方法");
    }

    publicvoid methodZi() {
        System.out.println("子类特有方法");
    }
}
定义测试类：
                public
                class
                 Demo {

    
                public
                static
                void
                 main(String[] args) {

        Fu obj = new Zi(); 

        // 父子都有，优先用子类
        obj.method(); // 子类方法

        // 子类没有，父类有，向上找到父类
        obj.methodFu(); // 父类特有方法    }

}
看 new 的是谁，就优先用谁，没有则向上找。
 
现在我们将上面的测试类添加一段代码，代码如下：
                public
                class
                 Demo {

    
                public
                static
                void
                 main(String[] args) {

        Fu obj = new Zi();
        obj.method(); 
        obj.methodFu(); 

        obj.methodZi(); 
    }

}

你会发现编译时直接就报错了，这是为什么呢？

那是因为 “=” 左边时父类，但是父类当中没有 methodZi 方法，所以编译报错。因此：

成员方法：编译看左边，运行看右边。

多态的好处 

先看一组例子，定义父类：

            public
            abstract
            class
             Animal {
    
            public
            abstract
            void
             eat();
}
定义子类：
                //
                 子类Cat
                public
                class Cat extends Animal {
　　@Override
    publicvoid eat() {
        System.out.println("吃鱼");
    }
}

// 子类Dogpublicclass Dog extends Animal {
　　@Override
    publicvoid eat() {
        System.out.println("吃骨头");
    }
}

如果不使用多态的方式，测试类代码如下：

                public
                class
                 Demo {

    
                public
                static
                void
                 main(String[] args) {
        
        Cat cat = new Cat();
        cat.eat();
    
        Dog dog = new Dog();
        dog.eat();
    }

}
如果使用多态的方式，测试类代码如下：
                public
                class
                 Demo {

    
                public
                static
                void
                 main(String[] args) {
        
        Animal cat 
                = new
                
                     Cat();
        cat.eat();
    
        Animal dog 
                = new
                
                     Dog();
        dog.eat();
    }

}

因此，无论右边 new 的是哪个子类对象，“=” 左边调用方法都不会发生变化。

再看一组例子，子类和父类的与上面一样，请注意测试类代码。

 如果不使用多态的方式：
                public
                class
                 Demo {
    
                public
                static
                void
                 main(String[] args) {

        Cat cat = new Cat();
        Dog dog = new Dog();

        // 调用showCatEat        showCatEat(cat);

        // 调用showDogEat        showDogEat(dog);
    }

    publicstaticvoid showCatEat(Cat c) {
        c.eat();
    }

    publicstaticvoid showDogEat(Dog d) {
        d.eat();
    }

}

 如果使用多态的形式：

                public
                class
                 Demo {
    
                public
                static
                void
                 main(String[] args) {
        
                //
                 以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代而执行效果一致
                
                    
        showAnimalEat(cat);
        showAnimalEat(dog);
    }

    
                public
                static
                void
                 showAnimalEat(Animal a) {
        a.eat();
    }
}

因此：

（1）由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。
（2）当eat方法执行时多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
（3）不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。
所以，多态的好处体现在可以使程序编写的更简单并有良好的扩展。实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法进行方法的调用，更能体现出多态的扩展性与便利。

多态转型

多态的转型分为向上转型与向下转型两种。
定义父类：
                public
                abstract
                class
                 Animal {
    
                public
                abstract
                void
                 eat();
}

定义子类：

                //
                 子类Cat
                public
                class Cat extends Animal {
    @Override
    publicvoid eat() {
        System.out.println("猫吃鱼");
    }
publicvoid catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

// 子类Dogpublicclass Dog extends Animal {
    @Override
    publicvoid eat() {
        System.out.println("狗吃SHIT");
    }

    publicvoid watchHouse() {
        System.out.println("狗看家");
    }
}
1、向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型，使用格式如下：

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

定义测试类：
                public
                class
                 Demo {

    
                public
                static
                void
                 main(String[] args) {

        
                //
                 对象的向上转型就是：父类引用指向之类对象。
        Animal animal = new Cat(); // 本来创建的时候是一只猫
        animal.eat(); // 猫吃鱼

        // animal.catchMouse(); // 错误写法！
    }

}
向上转型一定是安全的，没有问题的。但是也有一个弊端：对象一旦向上转型为父类就无法调用子类原本特有的内容（如标红的代码）。
如何解决这个这个问题呢？答案是向下转型。
2、向下转型
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。使用格式如下：
子类类型 变量名 = (子类类型) 父类变量名;
父类和子类的代码与上述一致，测试代码如下：
                public
                class
                 Demo {

    
                public
                static
                void
                 main(String[] args) {

        Animal animal = new Cat();
        animal.eat();

        // 向下转型，进行“还原”动作
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠

        // 下面是错误的向下转型，错误写法！编译不会报错，但是运行会出现异常
        // 本来new的时候是一只猫，现在非要当做狗
        Dog dog = (Dog) animal; // java.lang.ClassCastException，类转换异常    }

}

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

3、转型异常（ClassCastException）
为了避免ClassCastException的发生（向下转型已经提到过），Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型

如果变量属于该数据类型，返回true；
如果变量不属于该数据类型，返回false。
所以，转换前我们最好先做一个判断，代码如下：
                public
                class
                 Demo {

    
                public
                static
                void
                 main(String[] args) {

        Animal animal = new Dog(); // 本来是一只狗
        animal.eat(); // 狗吃SHIT

        // 如果希望掉用子类特有方法，需要向下转型
        // 判断一下父类引用animal本来是不是Dogif (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        // 判断一下animal本来是不是Catif (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }

        // 实际开发的时候更多的是单独抽离出来使用
        pet(new Dog());
    }

    publicstaticvoid pet(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }

}

原文：https://www.cnblogs.com/onebox/p/10438923.html

内容总结

以上是互联网集市为您收集整理的【Java】面向对象之多态全部内容，希望文章能够帮你解决【Java】面向对象之多态所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1195507.html

来源：【匿名】