Java中的多态性

多态性一词意味着具有多种形式。简单来说，我们可以将多态性定义为消息以多种形式显示的能力。

现实生活中的插图：多态性

一个人同时可以有不同的特征。就像一个男人同时是父亲、丈夫、雇员。因此，同一个人在不同的情况下具有不同的行为。这称为多态性。
多态性被认为是面向对象编程的重要特征之一。多态性允许我们以不同的方式执行单个操作。换句话说，多态性允许您定义一个接口并具有多个实现。 “poly”这个词意味着许多，“morphs”意味着形式，所以它意味着许多形式。

多态性的类型

Java中的多态主要分为两种：

• 编译时多态性
• 运行时多态性

类型 1：编译时多态性

它也被称为静态多态性。这种类型的多态性是通过函数重载或运算符重载来实现的。

Note: But Java doesn’t support the Operator Overloading.

方法重载：当有多个同名但参数不同的函数时，这些函数称为重载。函数可以通过更改参数数量或/和更改参数类型来重载。

示例 1

Java

// Java Program for Method overloading
// By using Different Types of Arguments 
 
// Class 1
// Helper class
class Helper {
 
    // Method with 2 integer parameters
    static int Multiply(int a, int b)
    {
 
        // Returns product of integer numbers
        return a * b;
    }
 
    // Method 2
    // With same name but with 2 double parameters
    static double Multiply(double a, double b)
    {
 
        // Returns product of double numbers
        return a * b;
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Calling method by passing
        // input as in arguments
        System.out.println(Helper.Multiply(2, 4));
        System.out.println(Helper.Multiply(5.5, 6.3));
    }
}

输出：

8
34.65

示例 2

Java

// Java program for Method Overloading
// by Using Different Numbers of Arguments
 
// Class 1
// Helper class
class Helper {
 
    // Method 1
    // Multiplication of 2 numbers
    static int Multiply(int a, int b)
    {
 
        // Return product
        return a * b;
    }
 
    // Method 2
    // // Multiplication of 3 numbers
    static int Multiply(int a, int b, int c)
    {
 
        // Return product
        return a * b * c;
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Calling method by passing
        // input as in arguments
        System.out.println(Helper.Multiply(2, 4));
        System.out.println(Helper.Multiply(2, 7, 3));
    }
}

输出：

8
42

类型 2：运行时多态性

它也被称为动态方法调度。这是一个在运行时解析对被覆盖方法的函数调用的过程。这种类型的多态性是通过方法覆盖来实现的。另一方面，当派生类具有基类的一个成员函数的定义时，就会发生方法覆盖。据说该基本函数已被覆盖。

例子

Java

// Java Program for Method Overriding
 
// Class 1
// Helper class
class Parent {
 
    // Method of parent class
    void Print()
    {
 
        // Print statement
        System.out.println("parent class");
    }
}
 
// Class 2
// Helper class
class subclass1 extends Parent {
 
    // Method
    void Print() { System.out.println("subclass1"); }
}
 
// Class 3
// Helper class
class subclass2 extends Parent {
 
    // Method
    void Print()
    {
 
        // Print statement
        System.out.println("subclass2");
    }
}
 
// Class 4
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating object of class 1
        Parent a;
 
        // Now we will be calling print methods
        // inside main() method
 
        a = new subclass1();
        a.Print();
 
        a = new subclass2();
        a.Print();
    }
}

输出：

subclass1
subclass2

输出说明：

在这个程序中，当一个子类的对象被创建时，子类内部的方法就会被调用。这是因为父类中的方法被子类覆盖了。由于该方法被重写，因此该方法在子类中比父方法具有更高的优先级。因此，子类中的主体被执行。