జావా వియుక్త పద్ధతి మరియు తరగతులు

వియుక్త పద్ధతులు జావా యొక్క శక్తివంతమైన సాధనం మరియు పాలిమార్ఫిజం విషయానికి వస్తే ఈ ఆబ్జెక్ట్-ఓరియెంటెడ్ భాషకు మరింత సామర్థ్యాలను అందిస్తాయి. మొత్తం ప్రోగ్రామ్ కోసం ప్రాథమిక ఫ్రేమ్‌వర్క్‌ను రూపొందించడానికి మరియు అవసరమైన విధంగా సర్దుబాటు చేయడానికి మిమ్మల్ని ఎనేబుల్ చేయడానికి జావా నైరూప్య పద్ధతిని ఉపయోగించవచ్చు.

వియుక్త పద్ధతి అంటే ఏమిటి?

నైరూప్య పద్ధతి అనేది అమలు లేని పద్ధతి. అంటే, ఇది కేవలం డిక్లరేషన్‌ను కలిగి ఉంది, కాబట్టి మీరు పేరు, రిటర్న్ రకం మరియు అది అంగీకరించే వేరియబుల్స్ గురించి మీకు తెలుసు. ఇక్కడ ప్రాథమిక వియుక్త పద్ధతికి ఉదాహరణ:

public abstract int example(int a1, int a2);

మీరు ఈ పద్ధతిని చూసినప్పుడు, అది పూర్ణాంకాన్ని తిరిగి ఇస్తుందని మరియు రెండు పూర్ణాంకాలను దాని వాదనగా అంగీకరిస్తుందని మీరు చెప్పగలరు. ఈ పద్ధతి ఎలా అమలు చేయబడుతుందో మీరు చెప్పలేరు. ఎందుకంటే దీన్ని అమలు చేయడానికి, మీరు దాన్ని భర్తీ చేయాలి. జావాలో వియుక్త పద్ధతిని సృష్టించేటప్పుడు, మీరు కొన్ని మార్గదర్శకాలకు కట్టుబడి ఉండాలి లేదా మీ ప్రోగ్రామ్ సరిగ్గా కంపైల్ చేయబడదు. గుర్తుంచుకో:

• జావా నైరూప్య పద్ధతులకు అమలు లేదు. అంటే, వాటిని ఎప్పుడూ కర్లీ జంట కలుపులు మరియు పద్ధతిని ఎలా ఉపయోగించాలో చెప్పే శరీరాన్ని అనుసరించకూడదు. ఇది కేవలం సెమికోలన్‌తో ముగిసింది.

• మీరు ఒక వియుక్త పద్ధతిని సృష్టించినట్లయితే, అది ఒక వియుక్త తరగతిలో మాత్రమే ఉంచబడుతుంది. అంటే, మీరు దాని లోపల ఒక వియుక్త పద్ధతిని కలిగి ఉన్న కాంక్రీట్ తరగతిని కలిగి ఉండలేరు.
  i. సైడ్ నోట్‌గా, మీకు అబ్‌స్ట్రాక్ట్ క్లాస్ ఉంటే, అది కన్‌స్ట్రక్టర్‌లను కలిగి ఉండవచ్చు. అయితే దీనికి వియుక్త పద్ధతి ఉండవలసిన అవసరం లేదు.

• ఒక కాంక్రీట్ తరగతి ఒక వియుక్త తరగతిని విస్తరించినప్పుడు, అది మాతృ తరగతి యొక్క అన్ని వియుక్త పద్ధతులను కూడా అమలు చేయాలి లేదా అది కాంక్రీటుగా ఉండకూడదు మరియు వియుక్తంగా ప్రకటించాలి.

ఆ చివరి రెండు కొంచెం గందరగోళంగా ఉండవచ్చు, కాబట్టి వెంటనే దాన్ని క్లియర్ చేద్దాం.

వియుక్త జావా తరగతులను విస్తరించడం

చుట్టుకొలత మరియు ప్రాంతాన్ని తిరిగి ఇచ్చే ప్రాథమిక ఆకృతుల గురించి మేము ప్రోగ్రామ్‌ను వ్రాయాలనుకుంటున్నాము. కాబట్టి మేము మాతృ వియుక్త తరగతిని సృష్టిస్తాము. కానీ ప్రతి ఆకృతికి దాని స్వంత నియమాలు ఉన్నందున, ప్రతి ఒక్కటి వేర్వేరుగా లెక్కించబడాలి, కాబట్టి మేము వియుక్త ఆకార తరగతిని ఇలా వ్రాస్తాము:

abstract class Shape {
  		String shapeName = " ";
  		Shape(String name) { 
    			this.shapeName = name; 
  		} 

abstract double area();
  		abstract double perimeter();
}

ఇప్పుడు, మనం వాస్తవానికి ఈ వియుక్త పద్ధతులను ఉపయోగించాలనుకుంటే, మనం వియుక్త జావా పేరెంట్ క్లాస్ ఆకారాన్ని పొడిగించి , ఆపై పద్ధతులను తక్షణం చేయాలి. కాబట్టి ప్రతి కాంక్రీట్ తరగతి తప్పనిసరిగా ప్రాంతం మరియు చుట్టుకొలత నైరూప్య పద్ధతులను అమలు చేయాలి.

class Quadrilateral extends Shape  
{ 
    double length, width; 
      
    Quadrilateral(double l, double w, String name) 
    { 
        super(name); 
        this.length = l; 
        this.width = w; 
    } 
      
    @Override
    public double perimeter()  
    { 
        return ((2*length)+(2*width));
    } 
      
    @Override
    public double area()  
    { 
        return (length*width); 
    } 
}

Implementing the Quadrilateral class would then look like this
class Main
{ 
    public static void main (String[] args)  
    { 
      
        // creating a Quadrilateral object using Shape as reference 
        Shape rectangle = new Quadrilateral(3,4, "Rectangle"); 
        System.out.println("Area of rectangle is " + rectangle.area()); 
        System.out.println("Perimeter of rectangle is " + rectangle.perimeter());
  
    } 
} 

కన్సోల్ నుండి అవుట్‌పుట్ ఇలా కనిపిస్తుంది:

Area of rectangle is 12.0
Perimeter of rectangle is 14.0

క్లాస్ చతుర్భుజం పేరెంట్ క్లాస్ షేప్ నుండి షేప్(స్ట్రింగ్ పేరు) కన్స్ట్రక్టర్‌ను ఇన్‌స్టంషియేట్ చేయనవసరం లేదని గమనించండి . ఎందుకంటే ఇది వియుక్త పద్ధతి కాదు. అయితే, మీరు తరగతిలో ఒక ప్రాంతం లేదా చుట్టుకొలతను మాత్రమే అమలు చేసినట్లయితే, కొత్త క్లాస్ రెండింటినీ చేర్చనందున అది వియుక్తంగా ఉండాలి. మీరు ఇంటర్‌ఫేస్‌లలో వియుక్త పద్ధతులను కూడా ఉపయోగించవచ్చు.

ఇంటర్‌ఫేస్‌లతో వియుక్త జావా పద్ధతులు

ఇంటర్‌ఫేస్ అంటే ఏమిటి మరియు అది అబ్‌స్ట్రాక్ట్ క్లాస్ నుండి ఎలా భిన్నంగా ఉందో త్వరగా సమీక్షిద్దాం. ఇంటర్‌ఫేస్‌లో, ఇంటర్‌ఫేస్‌లో ప్రకటించబడిన ఏవైనా వేరియబుల్స్ పబ్లిక్, స్టాటిక్ మరియు ఫైనల్. మరోవైపు వియుక్త తరగతులు, నాన్-ఫైనల్ వేరియబుల్స్ మాత్రమే కలిగి ఉంటాయి. ఇంటర్‌ఫేస్‌లోని ప్రతిదీ డిఫాల్ట్‌గా పబ్లిక్‌గా ఉంటుంది. ఒక వియుక్త తరగతి ప్రైవేట్, రక్షిత, పబ్లిక్ మొదలైనవి కలిగి ఉంటుంది. చివరగా, తరగతి ఇంటర్‌ఫేస్‌ను విస్తరించదు, అది అమలు చేస్తుంది. JDK 8కి ముందు, ఒక ఇంటర్‌ఫేస్‌లో నైరూప్య పద్ధతులు తప్ప మరేమీ ఉండకూడదు. ఇప్పుడు, ఇంటర్‌ఫేస్ డిఫాల్ట్ మరియు స్టాటిక్ పద్ధతులను కలిగి ఉంటుంది. దీని కారణంగా, ఉత్తమ అభ్యాసాలు వియుక్త పద్ధతులను పొడిగించదగిన టెంప్లేట్‌లుగా ఉపయోగించడం నుండి దూరంగా ఉన్నాయి మరియు ఇంటర్‌ఫేస్‌లు మరియు వాటిని అమలు చేయడంపై దృష్టి సారించాయి. కాబట్టి మీరు ఆకారాన్ని ఇంటర్‌ఫేస్‌గా సృష్టించి , ఆపై దానిని చతుర్భుజంగా అమలు చేస్తే, అది ఎలా ఉంటుంది? మొదట, మీరు షేప్ (స్ట్రింగ్ పేరు) కన్స్ట్రక్టర్‌ని తీసివేయాలి . ఇది కేవలం రెండు నైరూప్య పద్ధతులతో ఇలా కనిపిస్తుంది:

interface Shape {

  abstract double area();
  abstract double perimeter();
}


So the Quadrilateral class would then look like this:
class Quadrilateral implements Shape {  

  double length, width; 
      
    	  Quadrilateral(double l, double w) {
    
    	    this.length = l; 
    	    this.width = w; 
    	  } 
      
    	  @Override
    	  public double perimeter() {
     
    	    return ((2*length)+(2*width));
    	  } 
      
    	  @Override
    	  public double area() {
    
   	    return (length*width); 
    	  } 
}

చివరగా, షేప్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తున్నప్పుడు కొత్త చతుర్భుజాన్ని ఉపయోగించడం చాలా వరకు ఒకే విధంగా ఉంటుంది:

class Main
{ 
    public static void main (String[] args)  
    { 
      
        // creating a Quadrilateral object using Shape as reference 
        Shape rectangle = new Quadrilateral(3,4); 
        System.out.println("Area of rectangle is " + rectangle.area()); 
        System.out.println("Perimeter of rectangle is " + rectangle.perimeter());
  
    } 
}

మరియు కన్సోల్ ప్రింట్ అవుట్ ఇలా ఉంటుంది:

Area of rectangle is 12.0
Perimeter of rectangle is 14.0

మీరు ఇంటర్‌ఫేస్‌లు మరియు వియుక్త తరగతుల మధ్య వ్యత్యాసాల గురించి మరింత అన్వేషించాలనుకుంటే, మీరు మరింత సమాచారాన్ని ఇక్కడ కనుగొనవచ్చు.

కానీ వియుక్త జావా పద్ధతులను ఎందుకు ఉపయోగించాలి?

జావాలో వియుక్త పద్ధతులు ఉపయోగించబడటానికి అనేక కారణాలు ఉన్నాయి మరియు వాటిని ఉపయోగించడంతో మీరు ఎందుకు సుఖంగా ఉండాలి. సముచితమైనప్పుడు మీరు వాటిని ఎందుకు ఉపయోగించాలో ఇక్కడ మూడు శీఘ్ర కారణాలు ఉన్నాయి.

1. ప్రయత్నాల నకిలీని నివారించండి - మా ఉదాహరణ కోడింగ్‌ను తిరిగి చూడండి; మీరు మరియు మీ బృందం దీర్ఘచతురస్రం కాకుండా ఇతర ఆకృతుల కోసం తరగతులను సృష్టించాల్సిన అవసరం ఉందని ఊహించండి. మీరు ఆ తరగతిని రూపొందించడానికి ఎన్ని విభిన్న మార్గాలు ఉన్నాయి? పది? పదిహేనా? మరియు అది ఒక సాధారణ సమస్య. చాలా క్లిష్టమైన ఏదో ఊహించుకోండి. మీరు మరియు మీ బృందం వంద మార్గాలతో ముందుకు రావచ్చు. అప్పుడు మీరు వాటిని ఒక పొందికైన ప్రోగ్రామ్‌లో నేయడం అనే కష్టమైన పనిని ఎదుర్కోవలసి ఉంటుంది. ఇది మన తదుపరి విషయానికి తీసుకువస్తుంది: అమలును నిర్వచించడం.

2. జావాలోని వియుక్త పద్ధతులు ఉపయోగం మరియు అమలు యొక్క నిర్వచనాన్ని అనుమతిస్తాయి - మీరు వియుక్త తరగతి లేదా ఇంటర్‌ఫేస్‌ను ఉపయోగించినప్పుడు మరియు డిజైన్, నైరూప్య పద్ధతుల ద్వారా, మీ ఇంటర్‌ఫేస్‌తో ఇతర వ్యక్తులు ఎలా పరస్పర చర్య చేస్తారో మీరు నిర్వచిస్తున్నారు. వారు ఏ వేరియబుల్స్‌ని ఉపయోగించాలి మరియు వారు ఏ రిటర్న్ రకాలను ఆశించవచ్చో అది వారికి తెలియజేస్తుంది.
   వారు వాటిని ఓవర్‌రైడ్ చేయగలరు మరియు మీ ఇంటర్‌ఫేస్‌ను ప్రత్యేకమైన మార్గాల్లో అమలు చేసే కాంక్రీట్ క్లాస్‌లను సృష్టించగలిగినప్పటికీ, మీరు ఇప్పటికీ మీ కోడ్ కోసం ప్రధాన వినియోగాన్ని రాయిగా సెట్ చేసారు. ఎవరైనా ఆకారాన్ని అమలు చేయాలనుకుంటే, వారు చుట్టుకొలత మరియు ప్రాంతం రెండింటినీ భర్తీ చేయాలి లేదా అమలు చేయాలి.

3. రీడబిలిటీ మరియు డీబగ్గింగ్ - నైరూప్య పద్ధతులను కలిగి ఉండటం వలన మీ కోడ్ యొక్క రీడబిలిటీ పెరుగుతుంది. మీరు ఇంటర్‌ఫేస్‌ను అమలు చేసే తరగతిని వ్రాసినప్పుడు, ఏమి చూడాలో మీకు తెలుస్తుంది. ఇంటర్‌ఫేస్‌లోని ప్రతి వియుక్త పద్ధతి అమలులో ఉంటుందని మీకు తెలుసు, తద్వారా ఏదైనా బగ్‌లను చదవడం మరియు ట్రాక్ చేయడం సులభం అవుతుంది. జావా మరియు ఇతర ఆబ్జెక్ట్-ఓరియెంటెడ్ లాంగ్వేజెస్‌లో పాలిమార్ఫిజమ్‌ని సరిగ్గా ఎలా ఉపయోగించాలో నేర్చుకోవడం అనేది వియుక్త పద్ధతులు. మీరు వాటిని అర్థం చేసుకోవడం మరియు ఉపయోగించడం ప్రారంభించినప్పుడు, మీ కోడింగ్ ప్రయాణంలో పూర్తిగా కొత్త అధ్యాయం ప్రారంభమవుతుంది.