Java 多态

文章目录

• 多态
• • 向上转型和向下转型
  • • 向上转型和重写
    • 重写和重载的区别
    • 动态绑定和静态绑定
    • 用代码来解释什么是多态
    • 向下转型
    • 多态的优点
    • 总结

      

      多态

      1. 什么是多态？为什么要使用多态？

         简单来说是多种形态，具体来说是去完成某个事情，当不同对象去完成同一件事表现出来的不同结果/状态

      打个比方就是同一个人对待不同人表现出来的形态是不同的

      

      2. 多态实现的三个条件：

      

      向上转型和向下转型

      

      向上转型和重写

      1. 将子类对象给父类类型的引用

         父类类型 对象名 = new 子类类型()

      直接赋值的

      class Animal{
          public String name;
          public int age;
          public Animal(String name,int age){
              this.name = name;
              this.age = age;
          }
          // 父类中的this是当前对象的引用
          public void eat(){
              System.out.println(this.name + " ");
          }
      }
      class Dog extends Animal{
          public Dog(String name,int age){
              super(name,age);// 调用父类的构造方法进行从父类继承过来的成员的构造
          }
          public void back(){
              System.out.println(this.name + "汪汪汪 ");
          }
      }
      public class test {
          public static void main(String[] args) {  
              // 向上转型
              Animal animal = new Dog("小白",3);
              animal.eat();// 调用父类自己的eat
          }
      }
      

      1. 第二种向上转型，传参的

         

      2. 传返回值的向上转型

      

      1. 重写的三个条件：

         父类实现的方法不满足你需要的功能的时候可以进行重写

      a. 方法的返回值一样

      方法名一样

      方法的参数列表一样

      b. 被重写的方法的访问修饰限定符在子类中的要大于等于父类的

      权限大小：private

      c. 被private的方法是不能被重写的

      d. 被static修饰的方法是不能被重写的

      e. 被final修饰的方法是不可以被重写的，因为具有了常性

      f. 构造方法也是不可以被重写的

      public final void eat(){
           // ...
      }
      

      被重写的方法返回值类型可以不同，但必须是父子关系

      

      重写：在子类和父类中有同名的方法，

      这时候子类对象给父类类型的引用（向上转型），使用该对象再调用，调用的是子类的方法，不再是父类的方法

      上面的过程叫做动态绑定

      下面是子类重写了父类的eat

      

      @override可以提示你重写是否写错了，提示语法错误

      

      重写和重载的区别

      

      1. object类是所有类的父类

      Dog类重写了自己的toString，就使用自己的toString

      没有重写就调用父类的toString

      

      动态绑定和静态绑定

      1. 静态绑定：在编译的时候就确定了调用哪个方法，比如重载
      2. 动态绑定：在编译的时候不能确定，在运行时确定调用哪个方法，比如重写

         

         

      用代码来解释什么是多态

      

      1. 不能调用子类特有的方法，只能调用父类的方法，重写啦才调用子类的方法（而且是同一个名字的方法，比如eat()）

         

      向下转型

      1. 父类对象给子类类型的引用
      2. 向下转型不安全

         

      3. 如果animal引用的对象是Cat对象的实例，如果是就成功，不是就走下面的打印

         

      多态的优点

      1. 能够降低代码的圈复杂度，避免使用大量的if-else
      2. 一段代码中条件语句和循环语句出现的个数 , 这个个数就称为 " 圈复杂度 ".

      不使用多态，打印下列图形？

      class Shape {
          public void draw() {
              System.out.println("画图");
          }
      }
      class Rect extends Shape {
          @Override
          public void draw() {
              System.out.println("⬜");
          }
      }
      class Cycle extends Shape {
          @Override
          public void draw() {
              System.out.println("⚪");
          }
      }
      class Flower extends Shape {
          @Override
          public void draw() {
              System.out.println("❀");
          }
      }
      class Test2 {
          public static void drawShapes() {
              Rect rect = new Rect();
              Cycle cycle = new Cycle();
              Flower flower = new Flower();
              String[] shapes = {"cycle","rect","cycle","rect","flower"};
              for(String shape : shapes) {
                  if(shape.equals("cycle")) {
                      cycle.draw();
                  }else if (shape.equals("rect")) {
                      rect.draw();
                  }else{
                      flower.draw();
                  }
              }
          }
          public static void main(String[] args) {
              drawShapes();
          }
      }
      

      使用多态

      public static void main(String[] args){
             Shape shapes = {new Cycle(),new Rect(),new Cycle(),new Rext(),new Flower()};
             // 向上转型
             
             for(Shape shape : shapes){
                   shape.draw();
             }
      }
      

      1. 可扩展能力强

         如果要新增一种新的形状，使用多态该代码成本也比较低

      class Flower extends Shape{
          public void draw(){
              System.out.println("花!");
          }
      }
      

      1. 属性没有多态

         当父类的成员变量和子类的成员变量同名时，通过父类引用，只能访问父类的变量

      2. 构造方法是没有多态的，因为不能重写，重写会造成构造的混乱

      

      

      总结

      1. 多态主要就是下图中的三点

         

      2. 向上转型有什么用？

         是重写的前提，一个子类对象给父类类型的引用

      3. 动态绑定有什么用？

         是实现多态的基础，在编译的时候不确定调用哪个方法，在运行的时候确定调用哪个方法

         动态绑定在编译时显示地是调用父类的方法，但是在运行时显示的是调用子类重写父类的方法