Zeitpolymorphismus in Java zusammenstellen

Polymorphismus in Java bezieht sich auf eine Fähigkeitserklärung von Objekten in der Java -Umgebung. Es ermöglicht es uns, denselben Prozess auf unterschiedliche Weise durchzuführen. Es gibt zwei Arten von Polymorphismen in Java:

• kompilierte Polymorphismus -Methode
• Laufzeit -Polymorphismus -Methode

Heute werden wir mit Methodenüberladung und Überladung des Bedieners über Kompilierzeitpolymorphismen diskutieren.

Compiled-Time-Polymorphismus Beispiel

Dies ist ein Beispiel:

<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>

Algorithmus zur Ausführung von Kompilierzeitpolymorphismus

In diesem möglichen Algorithmus zeigen wir Ihnen, wie Sie in einer Java-Umgebung Kompilierungs-Zeit-Polymorphismen durchführen. Durch die Verwendung dieses Algorithmus werden wir eine Java -Syntax erstellen, um den Prozess effizient zu interpretieren.

• Schritt 1 - Starten Sie den Prozess.
• Schritt 2 - Importieren und deklarieren Sie das Java -Paket, mit dem die Methode ausgeführt wurde.
• Schritt 3 - eine öffentliche Klasse deklarieren.
• Schritt 4 - Erwähnt String -Parameter.
• Schritt 5 - Erstellen und deklarieren Sie zwei Funktionsparameter.
• Schritt 6 - Funktionsparameter 1 definieren.
• Schritt 7 - Funktionsparameter zwei definieren.
• Schritt 8 - Zeigen Sie zwei Listen an.
• Schritt 9 - Vergleichen Sie zwei Listen.
• Schritt 10 - Wenn das Evaluierungsergebnis wahr ist, wird eine gleiche Nachricht gedruckt.
• Schritt 11 - Wenn das Bewertungsergebnis falsch ist, wird die Ausführung des Prozesses blockiert und ein ungleicher Text wird gedruckt.
• Schritt 12 - Ein anderes Element einfügen und die Methode überschreiben.
• Schritt 13 - beide zeigen.
• Schritt 14 - Vergleichen Sie die beiden erneut.
• Schritt 15 - Erhalten Sie die Ergebnisse.
• Schritt 16 - Beenden Sie den Prozess.

Syntax zur Ausführung des Kompilierungszeitpolymorphismus

<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>

In der obigen Syntax versuchen wir Ihnen zu zeigen, wie Sie eine Funktion erstellen, um sie in einer polymorphen Methode zu verwenden. Durch die Verwendung dieser Java-Syntaxe werden wir uns auf einige Java-Methoden zu bewegen, die sich auf den Kompilierungs-Zeitpolymorphismus beziehen.

Methoden, um

zu folgen
• Methode 1
- Java -Programm zeigt, wie Methodenüberladung beim Kompilieren von Polymorphismus funktioniert, indem die Anzahl der Parameter
• geändert wird.
Methode 2

- Java -Programme verwenden die Render () -Typmethode für den Kompilierzeitpolymorphismus

Methode 1: Verwenden Sie numerische Parameter, um Kompilierungszeitpolymorphismen durchzuführen

Verwendung der Con_str -Methode

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

In dieser Methode werden wir die CON_STR -Methode anwenden, um zu demonstrieren, wie der Polymorphismus zur Kompilierungszeit funktioniert, indem wir die Anzahl der Parameter ändern.

<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>

Beispiel

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

Ausgabe

Verwendung von Datentypmethoden

In dieser Methode werden wir die Datentyp -Mustermethode anwenden, um zu demonstrieren, wie Polymorphismus zur Kompilierung der Zeit funktioniert, indem wir die Anzahl der Parameter ändern.

Beispiel

<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>

Ausgabe

<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>

Verwenden von Sequenzparametermethoden

In dieser Methode werden wir die Sequenzparametermethode anwenden, um zu demonstrieren, wie der Polymorphismus zum Kompilierzeit funktioniert, indem wir die Anzahl der Parameter ändern.

Beispiel

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

Ausgabe

<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>

Methode 2: Verwendung von Render () Methode

Bei dieser Methode werden wir die Render-Methode anwenden, um die Überlastung des Bedieners mithilfe des Kompilierungs-Zeit-Polymorphismus zu erklären.

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

Beispiel 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>

Ausgabe

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

In dieser Methode werden die Anzeigeinformationsmethode angewendet, um die Operatorüberladung mithilfe des Kompilierungs-Zeit-Polymorphismus zu interpretieren.

Beispiel 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>

Ausgabe

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

Bei dieser Methode werden wir die Methode display () anwenden, um die Operatorüberladung mithilfe des Kompilierungszeitpolymorphismus zu erklären.

Beispiel 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>

Ausgabe

<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>

Bei dieser Methode werden einige polymorphe Variablen und Methoden angewendet, um die Überlastung des Bedieners mithilfe des Kompilierungs-Zeit-Polymorphismus zu erklären.

Beispiel 4

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

Ausgabe

<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>

Schlussfolgerung

Kompilierungszeitpolymorphismus ist ein früher Bindungsprozess, durch den wir das Überlastungsproblem lösen können, das ein Programm im Ausführungsmodus auftritt. Im heutigen Artikel lernen wir verschiedene Methoden zum Kompilierzeitpolymorphismus. Durch die Verwendung von Algorithmen und Syntax haben wir auch einen Java -Code erstellt, um Problemanweisungen auf effiziente Weise zu interpretieren.

Bitte lesen Sie auch: Java -Interview Fragen und Antworten

Die Codebeispiele wurden aus Klarheit und Korrektheit verbessert, und der Text wurde neu geschrieben, um gleichzeitig die ursprüngliche Form zu erhalten.

Das obige ist der detaillierte Inhalt vonZeitpolymorphismus in Java zusammenstellen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!