多态的概述

image.png

多态的格式与使用

  1. package com.Demo11;
  3. /*
  4. 代码当中体现多态性，其实就一句话，父类引用指向子类对象
  6. 格式：
  7. 父类名称 对象名 = new 子类名称();
  8. 或者：
  9. 接口名称 对象名 = new 实现类名称();
  10.  */
  11. public class DemoMain {
  12.     public static void main(String[] args) {
  13.         //使用态的写法
  14.         //左侧父类的引用，指向了右侧子类的对象
  15.         Fu obj = new Zi();
  17.         obj.method();
  18.         obj.methodFu();
  19.     }
  20. }
  22. ========================================================================================================================================
  23. package com.Demo11;
  25. public class Fu {
  26.     public void method(){
  27.         System.out.println("父类共有方法");
  28.     }
  29.     public void methodFu(){
  30.         System.out.println("父类独有方法");
  31.     }
  32. }
  34. ========================================================================================================================================
  35. package com.Demo11;
  37. public class Zi extends Fu{
  38.         public void method(){
  39.             System.out.println("子类的共有方法");
  40.         }
  41.         public void methodZi(){
  42.             System.out.println("子类独有方法");
  43.         }
  44. }

多态中成员变量的使用特点

  1. package com.Demo11;
  3. /*
  4. 访问成员变量的两种方式:
  5. 1.直接通过对象名称访问成员变量，看等号左边是谁，优先用谁，没有则向上找
  6. 2.间接通过成员方法访问成员变量，看该方法属于谁，优先用谁，没有则向上找
  7.  */
  8. public class DemoMain {
  9.     public static void main(String[] args) {
  10.         //使用多态的写法，杜磊引用指向子类的对象
  11.         Fu obj = new Zi();
  12.         System.out.println(obj.num);   //父 10
  13. //        System.out.println(obj.age);    //错误写法
  14.         obj.showNum();      //子类没有覆盖重写  10
  15.     }
  16. }
  18. ========================================================================================================================================
  19. package com.Demo11;
  21. public class Fu {
  22.     int num = 10;
  23.     public void method(){
  24.         System.out.println("父类共有方法");
  25.     }
  26.     public void methodFu(){
  27.         System.out.println("父类独有方法");
  28.     }
  29.     public void showNum(){
  30.         System.out.println(num);
  31.     }
  32. }
  34. ========================================================================================================================================
  35. package com.Demo11;
  37. public class Zi extends Fu{
  38.     int num = 20;
  39.     int age=30;
  40.     public void method(){
  41.         System.out.println("子类的共有方法");
  42.     }
  43.     public void methodZi(){
  44.         System.out.println("子类独有方法");
  45.     }
  46. }

多态中成员方法的使用特点

  1. package com.Demo11;
  3. /*
  4. 在多态的代码当中，成员方法的访问规则是：
  5.     看new的是谁，就看用谁，没有则向上找
  6. 口诀：编译看左边，运行看右边
  8. 对比一下：
  9. 成员变量：编译看左边，运行还看左边
  10. 成员方法：编译看左边，运行看右边
  11.  */
  12. public class DemoMain {
  13.     public static void main(String[] args) {
  14.         Fu obj = new Zi();
  16.         obj.method();      //父子都有，优先用子
  17.         obj.methodFu();   //子类没有，父类有，向上找到父类
  18.     }
  19. }
  21. ========================================================================================================================================
  22. package com.Demo11;
  24. public class Fu {
  25.     int num = 10;
  26.     public void method(){
  27.         System.out.println("父类共有方法");
  28.     }
  29.     public void methodFu(){
  30.         System.out.println("父类独有方法");
  31.     }
  32.     public void showNum(){
  33.         System.out.println(num);
  34.     }
  35. }
  37. ========================================================================================================================================
  38. package com.Demo11;
  40. public class Zi extends Fu{
  41.     int num = 20;
  42.     int age=30;
  43.     public void method(){
  44.         System.out.println("子类的共有方法");
  45.     }
  46.     public void methodZi(){
  47.         System.out.println("子类独有方法");
  48.     }
  49. }

使用多态的好处

image.png

对象的向上转型

image.png

  1. package com.Demo11;
  3. public class DemoMain {
  4.     public static void main(String[] args) {
  5.         //向上的转型就是fui引用指向子类对象
  6.         Animal obj = new Cat();
  7.         obj.eat();
  8.     }
  9. }
  11. ========================================================================================================================================
  12. package com.Demo11;
  14. public abstract class Animal {
  15.     public abstract void eat();
  16. }
  18. ========================================================================================================================================
  19. package com.Demo11;
  21. public class Cat extends Animal{
  22.     @Override
  23.     public void eat() {
  24.         System.out.println("猫吃鱼");
  25.     }
  26. }

对象的向下转型

image.png

  1. package com.Demo11;
  3. public class DemoMain {
  4.     public static void main(String[] args) {
  5.         //向上的转型就是父类引用指向子类对象
  6.         Animal obj = new Cat();
  7.         obj.eat();
  9.         //向下转型，进行“还原”动作
  10.         Cat cat = (Cat) obj;
  11.         cat.catchMouse();
  13.         //下面是错误的向下转型
  14.         //本来new的时候是一只猫，现在非要当做狗
  15.         //错误写法！编译不会报错，但是运行会报错
  16.         //java.lang.ClassCastException
  17.         Dog dog = (Dog) obj;
  18.     }
  19. }
  21. ========================================================================================================================================
  22. package com.Demo11;
  24. public class Cat extends Animal{
  25.     @Override
  26.     public void eat() {
  27.         System.out.println("猫吃鱼");
  28.     }
  29.     public void catchMouse(){
  30.         System.out.println("猫抓老鼠");
  31.     }
  32. }
  34. ========================================================================================================================================
  35. package com.Demo11;
  37. public class Dog extends Animal{
  38.     @Override
  39.     public void eat() {
  40.         System.out.println("狗吃骨头");
  41.     }
  42. }
  44. ========================================================================================================================================
  45. package com.Demo11;
  47. public abstract class Animal {
  48.     public abstract void eat();
  49. }

用instanceof关键字进行判断

  1. package com.Demo11;
  3. /*
  4. 如何才能知道一个父类引用的对象，本来是什么子类？
  5. 格式：
  6. 对象 instanceof 类名称
  7. 这将会得到一个boolean值结果,也就是判断前面的对象你们那当后面类型的实例
  8.  */
  9. public class DemoMain {
  10.     public static void main(String[] args) {
  11.         //向上的转型就是fui引用指向子类对象
  12.         Animal obj = new Cat();
  13.         obj.eat();    //猫吃鱼
  15.         //如果希望调用子类特有方法，需要向下转型
  16.         //判断一下父类引用obj本来是不是Dog
  17.         if (obj instanceof Dog){
  18.             Dog dog = (Dog) obj;
  19.             dog.watchHouse();
  20.         }
  21.         //判断一下父类引用obj本来是不是Cat
  22.         if(obj instanceof Cat){
  23.             Cat cat = (Cat) obj;
  24.             cat.catchMouse();
  25.         }
  26.     }
  27. }
  29. ========================================================================================================================================
  30. package com.Demo11;
  32. public class Dog extends Animal{
  33.     @Override
  34.     public void eat() {
  35.         System.out.println("狗吃骨头");
  36.     }
  37.     public void watchHouse(){
  38.         System.out.println("狗看门");
  39.     }
  40. }
  42. ========================================================================================================================================
  43. package com.Demo11;
  45. public class Cat extends Animal{
  46.     @Override
  47.     public void eat() {
  48.         System.out.println("猫吃鱼");
  49.     }
  50.     public void catchMouse(){
  51.         System.out.println("猫抓老鼠");
  52.     }
  53. }
  55. ========================================================================================================================================
  56. package com.Demo11;
  58. public abstract class Animal {
  59.     public abstract void eat();
  60. }

接口多态的综合案例-笔记本USB接口

image.png
image.png

  1. package com.Demo12;
  3. public interface UsbInterface {
  4.     public abstract void open();  //打开设备
  5.     public abstract void close();   //关闭设备
  6. }
  8. ========================================================================================================================================
  9. package com.Demo12;
  11. public class Computer {
  12.     public void powerOn(){
  13.         System.out.println("电脑开机");
  14.     }
  15.     public void powerOff(){
  16.         System.out.println("电脑关机");
  17.     }
  18.     //使用USB接口的方法，使用接口作为方法的参数
  19.     public void useDevice(UsbInterface usb){
  20.         usb.open();   //打开设备
  21.         if(usb instanceof Mouse){   //一定要先判断
  22.             Mouse mouse = (Mouse) usb;  //向下转型
  23.             mouse.click();
  24.         }else if(usb instanceof KeyBoard){   //先判断
  25.             KeyBoard keyboard =(KeyBoard) usb;
  26.             keyboard.input();
  27.         }
  28.         usb.close();   //关闭设备
  29.     }
  30. }
  32. ========================================================================================================================================
  33. package com.Demo12;
  35. public class Mouse implements UsbInterface{
  36.     @Override
  37.     public void open() {
  38.         System.out.println("打开鼠标");
  39.     }
  41.     @Override
  42.     public void close() {
  43.         System.out.println("关闭鼠标");
  44.     }
  46.     public void click(){
  47.         System.out.println("鼠标点击");
  48.     }
  49. }
  51. ========================================================================================================================================
  52. package com.Demo12;
  54. public class KeyBoard implements UsbInterface{
  55.     @Override
  56.     public void open() {
  57.         System.out.println("打开键盘");
  58.     }
  60.     @Override
  61.     public void close() {
  62.         System.out.println("关闭键盘");
  63.     }
  65.     public void input(){
  66.         System.out.println("键盘输入");
  67.     }
  68. }
  70. ========================================================================================================================================
  71. package com.Demo12;
  73. public class DemoMain {
  74.     public static void main(String[] args) {
  75.         //首先创建一个电脑类
  76.         Computer computer = new Computer();
  77.         computer.powerOn();
  79.         //首先向上转型
  80.         UsbInterface mouse = new Mouse();
  81.         //参数是USB类型，我正好传递进去的就是USB鼠标
  82.         computer.useDevice(mouse);
  84.         //创建一个USB键盘
  85.         KeyBoard keyboard = new KeyBoard();   //没有使用多态写法
  86.         //参数是USB类型，我正好传递进去的是实现类对象
  87.         computer.useDevice(keyboard);   //正确写法！也发生了向上转型
  88.         //使用子类对象，匿名对象，也可以
  89. //        computer.useDevice(new KeyBoard());   //也是正确写法
  91.         computer.powerOff();
  92.     }
  93. }