Java多态

吢禅

于 2024-09-14 12:48:32 发布

阅读量434

点赞数 14

文章标签： java 开发语言

本文链接：https://blog.csdn.net/y123916/article/details/142255539

版权

多态

多态是建立在继承和封装的基础之上

多态（Polymorphism）是面向对象编程（OOP）中的一个核心概念，它允许同一个接口被不同的底层形式（数据类型）使用。多态使得我们能够通过一个通用的接口来引用不同的具体类型，而程序运行时会根据对象的实际类型来调用相应的方法。多态主要体现在以下几个方面：

1.方法重载（Overloading）：在同一个类中定义多个同名方法，但它们的参数类型或数量不同。
2.方法重写（Overriding）：子类提供一个与父类中具有相同名称和参数列表的方法的特定实现。
3.接口实现：一个类实现一个接口，并提供接口中所有方法的具体实现。通过接口类型的引用指向实现类的对象，调用方法时会根据实际对象的类型来执行相应的方法。

多态的实现通常依赖于继承和接口。在 Java 中，多态性允许我们使用父类类型的引用来引用子类对象。例如：

 class Animal {
     public void makeSound() {
         System.out.println("Some generic sound");
     }
 }
 
 class Dog extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Bark");
     }
 }
 
 class Cat extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Meow");
     }
 }
 
 public class Main {
     public static void main(String[] args) {
         Animal myDog = new Dog();
         Animal myCat = new Cat();
 
         myDog.makeSound(); // 输出 "Bark"
         myCat.makeSound(); // 输出 "Meow"
     }
 }

在这个例子中，Animal 是一个基类，Dog 和 Cat 是它的子类。每个子类都重写了 makeSound 方法。在 main 方法中，我们创建了 Animal 类型的引用 myDog 和 myCat，分别指向 Dog 和 Cat 类的实例。调用 makeSound 方法时，实际执行的是对应子类中重写的方法，这展示了多态的特性。

多态的好处包括：

代码复用：可以使用通用的接口来处理不同类型的对象。
可扩展性：可以轻松地添加新的子类，而不需要修改使用这些对象的代码。
解耦：调

1.方法的多态

方法的多态是指同一个方法名在不同的类中可以有不同的实现，或者同一个方法在不同的对象上可以有不同的行为。在面向对象编程中，方法的多态主要通过继承和接口实现来体现。具体来说，方法的多态可以分为以下几种情况：

1. 方法重写（Method Overriding）

这是多态最常见的形式之一。当子类拥有与父类相同名称和参数列表的方法时，子类可以提供该方法的具体实现，这称为方法重写。当通过父类类型的引用调用该方法时，实际调用的是子类中重写的方法。

 class Animal {
     public void makeSound() {
         System.out.println("Some generic sound");
     }
 }
 
 class Dog extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Bark");
     }
 }
 
 class Cat extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Meow");
     }
 }
 
 public class Main {
     public static void main(String[] args) {
         Animal myDog = new Dog();
         Animal myCat = new Cat();
 
         myDog.makeSound(); // 输出 "Bark"
         myCat.makeSound(); // 输出 "Meow"
     }
 }

在这个例子中，Dog 和 Cat 类重写了 Animal 类的 makeSound 方法，展示了多态性。

2. 方法重载（Method Overloading）

方法重载是指在同一个类中定义多个同名方法，但这些方法的参数列表不同（参数类型、个数或顺序不同）。编译器根据方法调用时提供的参数来决定调用哪个方法。

 class Calculator {
     public int add(int a, int b) {
         return a + b;
     }
 
     public double add(double a, double b) {
         return a + b;
     }
 }
 
 public class Main {
     public static void main(String[] args) {
         Calculator calc = new Calculator();
         System.out.println(calc.add(5, 10)); // 输出 15
         System.out.println(calc.add(5.5, 10.5)); // 输出 16.0
     }
 }

在这个例子中，Calculator 类有两个 add 方法，它们有不同的参数类型，展示了方法重载的多态。

3. 接口中的默认方法和静态方法

在 Java 8 及以后的版本中，接口可以包含默认方法和静态方法。这意味着不同的类可以实现同一个接口，并提供这些默认方法的不同实现。

 interface Vehicle {
     default void start() {
         System.out.println("Vehicle started");
     }
 }
 
 class Car implements Vehicle {
     // Car 类可以使用 Vehicle 接口的默认方法，也可以重写它
 }
 
 class Motorcycle implements Vehicle {
     @Override
     public void start() {
         System.out.println("Motorcycle started with a roar");
     }
 }
 
 public class Main {
     public static void main(String[] args) {
         Vehicle car = new Car();
         Vehicle motorcycle = new Motorcycle();
 
         car.start(); // 输出 "Vehicle started"
         motorcycle.start(); // 输出 "Motorcycle started with a roar"
     }
 }

2.对象的多态

对象的多态性是指同一个对象在不同的上下文中可以表现出不同的行为或状态。在面向对象编程中，对象的多态性主要体现在通过继承和接口实现来允许一个对象以多种形态存在和被使用。对象的多态性通常与方法的多态性紧密相关，但更侧重于对象本身的行为和属性。

一个对象的编译类型和运行类型可以不一致

当一个子类继承自父类时，子类对象可以被视为父类类型的对象。这意味着，你可以用父类类型的引用指向子类的对象，并调用在父类中定义的方法。如果子类重写了这些方法，那么实际调用的是子类中重写的方法。

 class Animal {
     public void makeSound() {
         System.out.println("Some generic sound");
     }
 }
 
 class Dog extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Bark");
     }
 }
 
 class Cat extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Meow");
     }
 }
 
 public class Main {
     public static void main(String[] args) {
         Animal myDog = new Dog();
         Animal myCat = new Cat();
 
         myDog.makeSound(); // 输出 "Bark"
         myCat.makeSound(); // 输出 "Meow"
     }

接口实现中的多态

当一个类实现一个接口时，该类的对象可以被视为接口类型的对象。如果接口中定义了默认方法或抽象方法，实现类可以提供这些方法的具体实现。通过接口类型的引用调用这些方法时，实际调用的是实现类中提供的方法。

 interface Vehicle {
     void start();
 }
 
 class Car implements Vehicle {
     @Override
     public void start() {
         System.out.println("Car engine started");
     }
 }
 
 class Motorcycle implements Vehicle {
     @Override
     public void start() {
         System.out.println("Motorcycle engine started with a roar");
     }
 }
 
 public class Main {
     public static void main(String[] args) {
         Vehicle myCar = new Car();
         Vehicle myMotorcycle = new Motorcycle();
 
         myCar.start(); // 输出 "Car engine started"
         myMotorcycle.start(); // 输出 "Motorcycle engine started with a roar"
     }

应为父类类型可以指向/接收子类的对象,

向上转型

就是父类指向子类

父类 Animal 子类 dog

Animal animal = new Dog()

向下转型

语法：子类类型引用名 = (子类类型) 父类引用；
只能强转父类的引用，不能强转父类的对象；
要求父类的引用必须指向的是当前目标类型的对象；
可以调用于子类类型中所有的成员。

Java的动态绑定机制

动态绑定（Dynamic Binding），也称为运行时绑定，是面向对象编程中多态性实现的关键机制之一。它允许程序在运行时决定调用哪个方法，而不是在编译时决定。这种机制使得程序能够更加灵活和可扩展，因为它允许子类覆盖（override）父类的方法，而调用者无需知道对象的具体类型。

动态绑定的工作原理

在Java等支持多态的语言中，当一个方法被调用时，实际调用哪个方法取决于对象的实际类型（运行时类型），而不是引用变量的类型（编译时类型）。这意味着，即使通过父类类型的引用调用方法，实际执行的也是对象实际类型的方法版本。

动态绑定的条件

为了实现动态绑定，需要满足以下条件：

1.方法必须是多态的：即方法必须在父类中声明，并在子类中被覆盖（重写）。
2.方法调用必须通过引用变量进行：直接通过类名调用静态方法或构造函数不涉及动态绑定。
3.方法不能是私有的：私有方法不能被子类覆盖，因此它们不参与多态。
4.方法不能是静态的：静态方法是类方法，它们不参与对象的多态行为。

动态绑定的例子

 class Animal {
     public void makeSound() {
         System.out.println("Animal makes a sound");
      }
 }
 
 class Dog extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Dog barks");
      }
 }
 
 class Cat extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Cat meows");
      }
 }
 
 public class Main {
     public static void main(String[] args) {
         Animal myDog = new Dog();
         Animal myCat = new Cat();
 
         myDog.makeSound(); // 输出 "Dog barks"
         myCat.makeSound(); // 输出 "Cat meows"
      }
 }

1.当调用对象方法的时候,该方法会和对象的内存地址/运行类型绑定

2.当调用对象时,没有动态绑定时,哪里声明,哪里使用

动态绑定的理解: 我的理解就是基于继承,动态的(jvm根据自己的规则)选择调用子类,还是重写父类的方法,规则就是子类有选择子类,子类没用就选择父类