Java中的编译时多态性

Java中的多态性是指对象具有多种形式的能力。多态性允许我们在Java中以多种方式执行相同的操作。

多态性分为两种：

1. 编译时多态性
2. 运行时多态性

Note: Run time polymorphism is implemented through Method overriding. Whereas, Compile Time polymorphism is implemented through Method overloading and Operator overloading. 

在本文中，我们将看到编译时多态性。

编译时多态性

编译时多态性也称为静态多态性或早期绑定。编译时多态是在编译过程中解决的多态。方法的重载是通过类的引用变量来调用的。编译时多态性是通过方法重载和运算符重载来实现的。

1.方法重载

我们可以拥有一个或多个具有相同名称的方法，这些方法只能通过参数编号、类型或顺序来区分。

当一个类有许多同名但参数不同的方法时，就会发生方法重载。如果两个或多个方法具有其他数量的参数、不同的数据类型或不同数量的参数和不同的数据类型，则它们可能具有相同的名称。

例子：

void gfg() { ... }
void gfg(int num1 ) { ... }
void gfg(float num1) { ... }
void gfg(int num1 , float num2 ) { ... } 

（一种）。通过改变参数个数的方法重载

在这种类型中，方法重载是通过在函数调用中使用不同数量的参数重载方法来完成的

例子：

show( char a )
show( char a ,char b )

在给定的示例中，第一个 show 方法有一个参数，第二个 show 方法有两个方法。调用函数时，编译器会查看参数的数量并决定如何解析方法调用。

Java

// Java program to demonstrate the working of method
// overloading by changing the number of parameters
 
public class MethodOverloading {
     
      // 1 parameter
    void show(int num1)
    {
        System.out.println("number 1 : " + num1);
    }
 
    // 2 parameter
    void show(int num1, int num2)
    {
        System.out.println("number 1 : " + num1
                           + "  number 2 : " + num2);
    }
 
    public static void main(String[] args)
    {
        MethodOverloading obj = new MethodOverloading();
       
          // 1st show function
        obj.show(3);
       
          // 2nd show function
        obj.show(4, 5);
    }
}

输出

number 1 : 3
number 1 : 4  number 2 : 5

在上面的例子中，我们通过改变几个参数来实现方法重载。我们创建了两个方法，show(int num1) 和 show(int num1, int num2)。在 show(int num1) 方法显示中，一个数字和 void show(int num1, int num2 ) 显示两个数字

(b)。通过改变参数的数据类型重载方法

在这种类型中，方法重载是通过在函数调用中用不同类型的参数重载方法来完成的

例子：

show( float a float b)
show( int a, int b ) 

在上面的例子中，第一个 show 方法有两个 float 参数，第二个 show 方法有两个 int 参数。调用函数时，编译器会查看输入参数的数据类型并决定如何解析方法调用。

程序：

Java

// Java program to demonstrate the working of method
// overloading by changing the Datatype of parameter
 
public class MethodOverloading {
   
    // arguments of this function are of integer type
    static void show(int a, int b)
    {
        System.out.println("This is integer function ");
    }
   
    // argument of this function are of float type
    static void show(double a, double b)
    {
        System.out.println("This is double function ");
    }
   
    public static void main(String[] args)
    {
        // 1st show function
        show(1, 2);
       
        // 2nd show function
        show(1.2, 2.4);
    }
}

输出

This is integer function 
This is double function 

在上面的示例中，我们更改了两个函数的参数的数据类型。在第一个 show()函数中，参数的数据类型是 int。给出整数类型输入后，输出将是“这是整数函数。”在第二个 show()函数中，参数的数据类型是 double。给出双精度类型输入后，输出将是“这是双精度函数”。

（C）。通过改变参数的顺序

在这种类型中，重载取决于参数的顺序

例子：

show( int a, float b ) 
show( float a, int b )

在此示例中，参数 int 和 float 在第一个声明中使用。第二个声明中的参数是int和float，但是它们在参数列表中的顺序是不同的。

Java

// Java program to demonstrate the working of method
// overloading by changing the sequence of parameters
 
public class MethodOverloading {
 
    // arguments of this function are of int and char type
    static void show(int a, char ch)
    {
        System.out.println("integer : " + a
                           + " and character : " + ch);
    }
 
    // argument of this function are of char and int type
    static void show(char ch, int a)
    {
        System.out.println("character : " + ch
                           + " and integer : " + a);
    }
 
    public static void main(String[] args)
    {
        // 1st show function
        show(6, 'G');
 
        // 2nd show function
        show('G', 7);
    }
}

输出

integer : 6 and character : G
character : G and integer : 7

在上面的例子中，在第一个节目中，函数参数是int和char ， 在第二只鞋中，函数参数是char和int 。改变了数据类型的顺序。

方法重载的无效案例

方法重载不允许改变方法（函数）的返回类型；它发生歧义。

例子

int sum(int, int);
String sum(int, int);

因为参数是匹配的，所以上面的代码不会编译。两种方法在参数中具有相同数量的数据类型和相同的数据类型序列。

2. 运算符重载

如果一个运算符可用于执行多个函数，则称该运算符为重载。运算符重载是一种对现有运算符赋予新含义的重载方法。在Java中， +运算符被重载。另一方面， Java不允许用户定义的运算符重载。要添加整数，可以使用 +运算符作为算术加法运算符。它也可以用来将字符串连接在一起。

Java

// Java program to demonstrate the
// working of operator overloading
 
public class GFG {
 
    // function for adding two integers
    void add(int a, int b)
    {
        int sum = a + b;
        System.out.println(" Addition of two integer :"
                           + sum);
    }
 
    // function for concatenating two strings
    void add(String s1, String s2)
    {
        String con_str = s1 + s2;
        System.out.println("Concatenated strings :"
                           + con_str);
    }
 
    public static void main(String args[])
    {
        GFG obj = new GFG();
       
        // addition of two numbers
        obj.add(10, 10);
       
        // concatenation of two string
        obj.add("Operator ", " overloading ");
    }
}

输出

Addition of two integer :20
Concatenated strings :Operator  overloading 

在上面的示例中，“+”运算符已被重载。当我们向重载方法发送两个数字时，我们得到两个整数的和，当我们传递两个字符串时，我们得到连接的文本。

编译时多态的优点：

1. 它提高了代码的清晰度，并允许对类似的过程使用单一名称。
2. 它具有更快的执行时间，因为它是在编译过程的早期发现的。

编译时多态性的唯一缺点是它不包括继承。