搜索

首页 >Java >java教程 >在Java中编译时间多态性

在Java中编译时间多态性

DDD
DDD原创
2025-02-07 11:39:141005浏览

Compile Time Polymorphism in Java

Java中的多态性是指Java环境中对象的一种能力声明。它允许我们以不同的方式执行相同的过程。Java中存在两种多态性：

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

今天，我们将讨论使用方法重载和运算符重载的编译时多态性。

编译时多态性示例

这是一个示例：

<code class="language-java">void ARBRDD() { ... }
void ARBRDD(int num1 ) { ... }
void ARBRDD(float num1) { ... }
void ARBRDD(int num1 , float num2 ) { ... }
//显示(char a)的值
//显示(char a, char b)的值
//显示(float a, float b)的值
//显示(int a, int b)的值
//显示(int a, float b)的值
//显示(float a, int b)的值
int sum value of (int, int);
String sum value of (int, int);</code>

执行编译时多态性的算法

在这个可能的算法中，我们将向您展示如何在Java环境中执行编译时多态性。通过使用此算法，我们将构建一些Java语法，以有效的方式解释该过程。

  • 步骤1 - 开始该过程。
  • 步骤2 - 导入并声明用于运行该方法的Java包。
  • 步骤3 - 声明一个公共类。
  • 步骤4 - 提到字符串参数。
  • 步骤5 - 创建并声明两个函数参数。
  • 步骤6 - 定义函数参数一。
  • 步骤7 - 定义函数参数二。
  • 步骤8 - 显示两个列表。
  • 步骤9 - 比较两个列表。
  • 步骤10 - 如果评估结果为真，则打印相等的消息。
  • 步骤11 - 如果评估结果为假，则阻止执行过程并打印不相等文本。
  • 步骤12 - 插入另一个元素并覆盖该方法。
  • 步骤13 - 显示两者。
  • 步骤14 - 再次比较两者。
  • 步骤15 - 获取结果。
  • 步骤16 - 终止该过程。

执行编译时多态性的语法

<code class="language-java">class SimpleCalculator{
    int add(int a, int b){
        return a+b;
    }
    int add(int a, int b, int c){
        return a+b+c;
    }
}
public class DemoCal{
    SimpleCalculator obj = new SimpleCalculator();
    System.out.println(obj.add(10, 20));
    System.out.println(obj.add(10, 20, 30));
}
}
class SimpleCalculator{
    int add(int a, int b){
        return a+b;
    }
    int add(int a, int b, int c){
        return a+b+c;
    }
}
public class DemoCal{
    SimpleCalculator obj = new SimpleCalculator();
    System.out.println(obj.add(10, 20));
    System.out.println(obj.add(10, 20, 30));
}
}
class MethodOverloading {
    private static void display(int a){
        System.out.println("Got Int data as a value.");
    }
    private static void display(String a){
        System.out.println("Got String object as a value.");
    }
    public static void main(String[] args) {
        display(4);
        display("XYZ");
    }
}
class Student{
    public void stuIdentity(String name, int id){
        System.out.println("stuName :" + name + " "
        + "Id :" + id);
    }
    public void stuIdentity(int id, String name){
        System.out.println("Id :" + id + " " + "stuName :" + name);
    }
}
class Main {
    Student stu= new Student();
    stu.stuIdentity("Mohit Roy", 1);
    stu.stuIdentity(2, "Mohini Basu");
}
}</code>

在上面的语法中，我们尝试向您展示如何构建一个函数以在多态性方法中使用它。通过使用这些Java语法，我们将朝着一些与编译时多态性相关的Java方法前进。

遵循的方法

  • 方法1 - Java程序演示通过更改参数数量来演示编译时多态性的方法重载的工作原理
  • 方法2 - Java程序使用render()类型方法进行编译时多态性

方法1：使用数字参数执行编译时多态性

con_str方法的使用

在此方法中，我们将应用con_str方法来演示通过更改参数数量来演示编译时多态性的工作原理。

<code class="language-java">String con_str = s1 + s2;
System.out.println("Concatenated strings :"+ con_str);</code>

示例

<code class="language-java">//Java程序演示通过更改参数数量来演示编译时多态性的方法重载的工作原理
public class ARBRDD {
   void show(int num1){
      System.out.println("number 1 : " + num1);
   }
   void show(int num1, int num2){
      System.out.println("number 1 : " + num1 + " number 2 : " + num2);
   }
   public static void main(String[] args){
      ARBRDD obj = new ARBRDD();
      obj.show(3);
      obj.show(4, 5);
   }
}</code>

输出

<code>number 1 : 3
number 1 : 4 number 2 : 5</code>

数据类型方法的使用

在此方法中，我们将应用数据类型模式方法来演示通过更改参数数量来演示编译时多态性的工作原理。

示例

<code class="language-java">void ARBRDD() { ... }
void ARBRDD(int num1 ) { ... }
void ARBRDD(float num1) { ... }
void ARBRDD(int num1 , float num2 ) { ... }
//显示(char a)的值
//显示(char a, char b)的值
//显示(float a, float b)的值
//显示(int a, int b)的值
//显示(int a, float b)的值
//显示(float a, int b)的值
int sum value of (int, int);
String sum value of (int, int);</code>

输出

<code class="language-java">class SimpleCalculator{
    int add(int a, int b){
        return a+b;
    }
    int add(int a, int b, int c){
        return a+b+c;
    }
}
public class DemoCal{
    SimpleCalculator obj = new SimpleCalculator();
    System.out.println(obj.add(10, 20));
    System.out.println(obj.add(10, 20, 30));
}
}
class SimpleCalculator{
    int add(int a, int b){
        return a+b;
    }
    int add(int a, int b, int c){
        return a+b+c;
    }
}
public class DemoCal{
    SimpleCalculator obj = new SimpleCalculator();
    System.out.println(obj.add(10, 20));
    System.out.println(obj.add(10, 20, 30));
}
}
class MethodOverloading {
    private static void display(int a){
        System.out.println("Got Int data as a value.");
    }
    private static void display(String a){
        System.out.println("Got String object as a value.");
    }
    public static void main(String[] args) {
        display(4);
        display("XYZ");
    }
}
class Student{
    public void stuIdentity(String name, int id){
        System.out.println("stuName :" + name + " "
        + "Id :" + id);
    }
    public void stuIdentity(int id, String name){
        System.out.println("Id :" + id + " " + "stuName :" + name);
    }
}
class Main {
    Student stu= new Student();
    stu.stuIdentity("Mohit Roy", 1);
    stu.stuIdentity(2, "Mohini Basu");
}
}</code>

序列参数方法的使用

在此方法中，我们将应用序列参数方法来演示通过更改参数数量来演示编译时多态性的工作原理。

示例

<code class="language-java">String con_str = s1 + s2;
System.out.println("Concatenated strings :"+ con_str);</code>

输出

<code class="language-java">//Java程序演示通过更改参数数量来演示编译时多态性的方法重载的工作原理
public class ARBRDD {
   void show(int num1){
      System.out.println("number 1 : " + num1);
   }
   void show(int num1, int num2){
      System.out.println("number 1 : " + num1 + " number 2 : " + num2);
   }
   public static void main(String[] args){
      ARBRDD obj = new ARBRDD();
      obj.show(3);
      obj.show(4, 5);
   }
}</code>

方法2：render()方法的使用

在此方法中，我们将应用render方法来解释使用编译时多态性的运算符重载。

<code>number 1 : 3
number 1 : 4 number 2 : 5</code>

示例1

<code class="language-java">//Java程序演示通过更改参数的数据类型来演示方法重载的工作原理
public class ARBRDD {
   static void show(int a, int b){
      System.out.println("This is the integer function here");
   }
   static void show(double a, double b){
      System.out.println("This is the double function here");
   }
   public static void main(String[] args){
      show(1, 2);
      show(1.2, 2.4);
   }
}</code>

输出

<code>This is the integer function here
This is the double function here</code>

在此方法中，我们将应用显示信息方法来解释使用编译时多态性的运算符重载。

示例2

<code class="language-java">//Java程序演示通过更改参数的顺序来演示方法重载的工作原理
public class ARBRDD {
   static void show(int a, char ch){
      System.out.println("integer : " + a + " and character : " + ch);
   }
   static void show(char ch, int a){
      System.out.println("character : " + ch + " and integer : " + a);
   }
   public static void main(String[] args){
      show(6, 'G');
      show('G', 7);
   }
}</code>

输出

<code>integer : 6 and character : G
character : G and integer : 7</code>

在此方法中，我们将应用display()方法来解释使用编译时多态性的运算符重载。

示例3

<code class="language-java">String s1 = sc.next();
System.out.println("Enter another string: ");
String s2 = sc.next();
System.out.println(s1+' '+s2);
System.out.println("Enter a number:");
int x = sc.nextInt();
System.out.println("Enter another number:");
int y = sc.nextInt();</code>

输出

<code class="language-java">//Java程序使用render()方法进行编译时多态性
class Polygon {
   public void render() {
      System.out.println("Rendering Polygon Value...");
   }
}
class Square extends Polygon {
   public void render() {
      System.out.println("Rendering Square Value...");
   }
}
class Circle extends Polygon {
   public void render() {
      System.out.println("Rendering Circle Value...");
   }
}
public class ARBRDD {
   public static void main(String[] args) {
      Square s1 = new Square();
      s1.render();
      Circle c1 = new Circle();
      c1.render();
   }
}</code>

在此方法中，我们将应用一些多态变量和方法来解释使用编译时多态性的运算符重载。

示例4

<code>Rendering Square Value...
Rendering Circle Value...</code>

输出

<code class="language-java">//Java程序使用重写方法进行编译时多态性
class Language {
   public void displayInfo() {
      System.out.println("Common English Language");
   }
}
class Java extends Language {
   @Override
   public void displayInfo() {
      System.out.println("Java Programming Language");
   }
}
public class ARBRDD {
   public static void main(String[] args) {
      Java j1 = new Java();
      j1.displayInfo();
      Language l1 = new Language();
      l1.displayInfo();
   }
}</code>

结论

编译时多态性是一个早期绑定过程，通过它我们可以解决程序在执行模式下出现的重载问题。在今天的文章中，我们学习了关于编译时多态性的各种方法。通过使用算法和语法，我们还构建了一些Java代码，以有效的方式解释问题陈述。

另请阅读：Java面试问题和答案

The code examples have been improved for clarity and correctness, and the text has been rewritten to be more concise and engaging while maintaining the original meaning. The image remains in its original format and location.

以上是在Java中编译时间多态性的详细内容。更多信息请关注PHP中文网其他相关文章！

Java 数据类型 运算符 for while 多态 format 字符串 运算符重载 对象 location display 算法
声明：
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn
上一篇：Difference Between IdentityHashMap, WeakHashMap, and EnumMap in Java下一篇：How to Run Your First Spring Boot Application in IntelliJ?

相关文章

查看更多