Դաս 23։ Java –Polymorphism

0

Պոլիմորֆիզմը օբյեկտի՝ տարբեր ֆորմաներ ընդունելու ունակությունն է։ OOP-ում պոլիմորֆիզմի ամենատարածված կիրառումը տեղի է ունենում, երբ parent class reference-ը օգտագործվում է child class object-ին հղելու համար։

Յուրաքանչյուր Java օբյեկտ, որը կարող է փոխանցել մեկից ավելի IS-A թեստ, համարվում է պոլիմորֆ: Java-ում բոլոր Java օբյեկտները պոլիմորֆ են, քանի որ ցանկացած օբյեկտ փոխանցում է IS-A թեստը իր սեփական տիպի և օբյեկտի դասի համար:

Կարևոր է իմանալ, որ օբյեկտ մուտք գործելու միակ միջոցը reference variable-ն է՝ հղումային փոփոխականը։ Այն կարող է լինել միայն մեկ տեսակի: Հայատարարվելուց հետո reference variable-ի տեսակը անհնար է փոխել:

reference variable-ը հնարավոր է վերգրել մեկ այլ օբյեկտի այն պայմանով, եթե վերջինս հայտարարագրված չէ, որպես final՝ վերջնական: reference variable-ի տեսակը որոշում են այն մեթոդները։

reference variable-ը կարող է հղել իր կողմից հայտարարված տիպի ցանկացած օբյեկտին կամ ցանկացած ենթատիպին: reference variable-ը կարող է հայտարարվել որպես դասի կամ ինտերֆեյսի տեսակի:

Օրինակ՝

public interface Vegetarian{}

public class Animal{}

public class Deer extends Animal implements Vegetarian{}

 

Այժմ, Deer դասը համարվում է պոլիմորֆ, քանի որ այն ունի բազմաթիվ ժառանգություններ: Հետևյալը true է վերը նշված օրինակների համար։

  • A Deer IS-A Animal
  • A Deer IS-A Vegetarian
  • A Deer IS-A Deer
  • A Deer IS-A Object

Երբ մենք կիրառում ենք reference variable-ի փաստերը «Deer» object reference-ի համար, ապա հետևյալ հայտարարությունները օրինական են։

 

Օրինակ՝

Deer d = new Deer();

Animal a = d;

Vegetarian v = d;

Object o = d;

 

d, a, v, o բոլոր reference variabl-ները վերաբերում են նույն Deer օբյեկտին։

 

Վիրտուալ մեթոդներ/ Virtual Methods

Այս բաժնում կտեսնենք, թե ինչպես է overridden method-ների վարքագիծը Java-ում թույլ է տալիս օգտվել պոլիմորֆիզմից դասերի ստեղծման ժամանակ:

Նախորդ դասընթացներում, մենք արդեն իսկ քննարկել ենք overridden method-ը, որտեղ child class-ը անտեսում է իր parent method-ին։ overridden method-ը թաքնված է parent class-ում և չի առաջադրվում, եթե child class-ը չի օգտագործում super keyword-ը։

Օրինակ՝

/* 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;  

}

}

Այժմ, ենթադրենք, որ ընդլայնել ենք Employee class-ը՝ 

/* 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;  

}

}

Այժմ ուշադիր ուսումնասիրեք հետևյալ ծրագրին և փորձեք որոշել արդյունքը։

/* 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();  

}

}

Արդյունքը՝

Constructing an Employee

Constructing an Employee 

Call mailCheck using Salary reference —

Within mailCheck of Salary class

ailing check to Mohd Mohtashim with salary 3600.0 

Call mailCheck using Employee reference–

Within mailCheck of Salary class

ailing check to John Adams with salary 2400.0

 

Այստեղ մենք ստեղծում ենք երկու օբյեկտ՝ Salary: Մեկը աշխատավարձի տեղեկանք (Salary reference s) օգտագործելով, մյուսը` աշխատողի հղում (employee reference e)։

Կոչ անելով s.mailCheck()-ը, compiler-ը տեսնում է mailCheck()-ը Salary class-ում, և JVM- ն կանչում է mailCheck()-ը Salary class-ում գործարկման ժամանակ:

mailCheck()-ը e-ում տարբեր է, քանի որ e-ն՝ Employee reference-ն է։ Երբ կոմպիլյատորը տեսնում է e.mailCheck ()-ը, այն տեսնում է mailCheck () մեթոդը Employee class-ում։

Այստեղ, կոմպիլացիայի ժամանակ compiler-ը օգտագործում է mailCheck()-ը Employee-ում հայտարարությունը վավերացնելու համար: Սակայն գործարկման ժամանակ, JVM-ն կանչում է mailCheck ()-ը Salary class-ում։

Այս վարքագիծը հայտնի է, որպես virtual method invocation, իսկ այս մեթոդները՝ virtual methods: overridden method-ը առաջադրվում է գործարկման ժամանակ, անկախ նրանից, թե տվյալների ինչ տեսակներ են օգտագործվել է կոդում կոմպիլացիայի ժամանակ:

Հարգելի ընթերցող, խնդրում ենք չմոռանալ like տալ մեր ֆեյսբուքյան էջին, քանի որ նորությունների մեծ մասը առաջինը տեղադրվում է հենց այնտեղ։ Ինչպես նաև հետևեք մեզ այլ սոցիալական ցանցերում և, իհարկե, գրանցվեք մեր բլոգում։

Share.