Java - Polymorfisme

Polymorfisme is het vermogen van een object om vele vormen aan te nemen. Het meest voorkomende gebruik van polymorfisme in OOP vindt plaats wanneer een verwijzing naar een bovenliggende klasse wordt gebruikt om naar een onderliggend klasseobject te verwijzen.

Elk Java-object dat meer dan één IS-A-test kan doorstaan, wordt als polymorf beschouwd. In Java zijn alle Java-objecten polymorf omdat elk object de IS-A-test zal doorstaan voor hun eigen type en voor de klasse Object.

Het is belangrijk om te weten dat de enige manier om toegang te krijgen tot een object is via een referentievariabele. Een referentievariabele kan slechts van één type zijn. Eenmaal gedeclareerd, kan het type referentievariabele niet worden gewijzigd.

De referentievariabele kan opnieuw worden toegewezen aan andere objecten, op voorwaarde dat deze niet definitief wordt verklaard. Het type van de referentievariabele zou de methoden bepalen die het op het object kan aanroepen.

Een referentievariabele kan verwijzen naar elk object van het gedeclareerde type of elk subtype van het gedeclareerde type. Een referentievariabele kan worden gedeclareerd als een klasse of interfacetype.

Voorbeeld

Laten we een voorbeeld bekijken.

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

Nu wordt de Deer-klasse als polymorf beschouwd, omdat deze meerdere overerving heeft. Het volgende geldt voor de bovenstaande voorbeelden −

Een hert IS-een dier
Een hert IS-een vegetariër
Een hert IS-een hert
Een hert IS-een object

Wanneer we de feiten van de referentievariabele toepassen op een Deer-objectreferentie, zijn de volgende verklaringen legaal −

Voorbeeld

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

Alle referentievariabelen d, a, v, o verwijzen naar hetzelfde Deer-object in de heap.

Virtuele methoden

In deze sectie laat ik u zien hoe u door het gedrag van overschreven methoden in Java kunt profiteren van polymorfisme bij het ontwerpen van uw klassen.

We hebben al het overschrijven van methoden besproken, waarbij een onderliggende klasse een methode in zijn bovenliggende klasse kan overschrijven. Een overschreven methode is in wezen verborgen in de bovenliggende klasse en wordt niet aangeroepen tenzij de onderliggende klasse het sleutelwoord super gebruikt binnen de overschrijvende methode.

Voorbeeld

/* File name : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

Stel nu dat we de Werknemersklasse als volgt uitbreiden −

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary; // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName()
      + " with salary " + salary);
   }
   
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Bestudeer nu het volgende programma zorgvuldig en probeer de output te bepalen −

/* File name : VirtualDemo.java */
public class VirtualDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Dit levert het volgende resultaat op −

Uitvoer

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

Hier instantiëren we twee Salaris-objecten. Een met een salarisreferentie s , en de andere met behulp van een werknemerreferentie e .

Tijdens het aanroepen van s.mailCheck() , ziet de compiler mailCheck() in de Salary-klasse tijdens het compileren, en de JVM roept mailCheck() aan in de Salary-klasse tijdens runtime.

mailCheck() op e is heel anders omdat e is een werknemersreferentie. Wanneer de compiler e.mailCheck() . ziet , ziet de compiler de methode mailCheck() in de klasse Employee.

Hier, tijdens het compileren, gebruikte de compiler mailCheck() in Employee om deze verklaring te valideren. Tijdens runtime roept de JVM echter mailCheck() aan in de Salarisklasse.

Dit gedrag wordt het aanroepen van virtuele methoden genoemd en deze methoden worden virtuele methoden genoemd. Een overschreven methode wordt aangeroepen tijdens runtime, ongeacht het gegevenstype dat de referentie is die tijdens het compileren in de broncode werd gebruikt.

Java - Overschrijven Java - Abstractie

Java