ఇంటర్‌ఫేస్‌లలో డిఫాల్ట్ పద్ధతులు

జావా యొక్క ప్రతి కొత్త వెర్షన్ ఇంతకు ముందు వచ్చిన వాటికి భిన్నంగా ఉంటుంది. enumమేము కవర్ చేసిన మెటీరియల్‌లో మార్పులకు ఉదాహరణ ఇక్కడ ఉంది: జావా 5 కంటే ముందు, భాషలో s లేదు . అదేవిధంగా, జావా 8 జావా 7 నుండి చాలా భిన్నంగా ఉంటుంది. మా పాఠాలు చాలా వరకు భాష యొక్క 7వ వెర్షన్ కోసం వ్రాయబడ్డాయి, అయితే మేము ముఖ్యమైన ఆవిష్కరణలను విస్మరించము. మేము ఇప్పటికే ఈ పాఠంలో ఇంటర్‌ఫేస్‌ల గురించి మాట్లాడుతున్నందున, మేము ఒక నవీకరణను పరిశీలిస్తాము — ఇంటర్‌ఫేస్‌లలో డిఫాల్ట్ పద్ధతులు . ఇంటర్‌ఫేస్ ప్రవర్తనను అమలు చేయదని మీకు ఇప్పటికే తెలుసు . దాని పని అది అమలు చేసే అన్ని వస్తువులు కలిగి ఉండవలసిన ప్రవర్తనను వివరించడం. కానీ డెవలపర్లు తరచుగా అన్ని తరగతులలో ఒక పద్ధతి యొక్క అమలు ఒకేలా ఉండే పరిస్థితులను ఎదుర్కొంటారు. మన పాత కారు ఉదాహరణను పరిశీలిద్దాం:

public interface Car {

   public void gas();

   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

"మీ అభిప్రాయం ప్రకారం, ఈ కోడ్‌తో ఉన్న ప్రధాన సమస్య ఏమిటి? మేము పదే పదే కోడ్‌ని వ్రాసినట్లు మీరు గమనించి ఉండవచ్చు! ప్రోగ్రామింగ్‌లో ఈ సమస్య సర్వసాధారణం మరియు మీరు దీన్ని నివారించాలి. ఇంతకు ముందు నిర్దిష్ట పరిష్కారాలు లేవు అనేది మరొక విషయం. Java 8 విడుదల చేయబడింది. ఈ సంస్కరణతో డిఫాల్ట్ పద్ధతులను పేర్కొని , వాటిని ఇంటర్‌ఫేస్‌లోనే అమలు చేయగల సామర్థ్యం వచ్చింది ! మీరు దీన్ని ఎలా చేస్తారో ఇక్కడ ఉంది:

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

ఇప్పుడు అన్ని కార్లకు ఒకే విధంగా ఉండే పద్ధతులు gas()మరియు brake()పద్ధతులు ఇంటర్‌ఫేస్‌కు తరలించబడ్డాయి. పునరావృత కోడ్ అవసరం లేదు. అంతేకాదు, ప్రతి తరగతిలో పద్ధతులు అందుబాటులో ఉన్నాయి!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

పద్ధతితో 100 తరగతులు ఉంటే gas(), వాటిలో 99 మాత్రమే అదే ప్రవర్తన కలిగి ఉంటే? అది ప్రతిదీ నాశనం చేస్తుంది మరియు డిఫాల్ట్ పద్ధతిని ఈ పరిస్థితికి అనర్హమైనదిగా చేస్తుందా? అయితే, కాదు :) ఇంటర్‌ఫేస్‌లలోని డిఫాల్ట్ పద్ధతులను సాధారణ వాటిలాగే భర్తీ చేయవచ్చు.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car decelerates differently!");
   }
}

అన్ని 99 ఇతర రకాల కార్లు డిఫాల్ట్ పద్ధతిని అమలు చేస్తాయి, మరియుUnusualCarతరగతి, ఇది మినహాయింపు, మొత్తం చిత్రాన్ని పాడు చేయదు మరియు ప్రశాంతంగా దాని స్వంత ప్రవర్తనను నిర్వచిస్తుంది. ఇంటర్‌ఫేస్‌ల యొక్క బహుళ వారసత్వం. మీకు ఇప్పటికే తెలిసినట్లుగా, Java బహుళ వారసత్వానికి మద్దతు ఇవ్వదు. దీనికి చాలా కారణాలున్నాయి. మేము వాటిని ప్రత్యేక పాఠంలో వివరంగా పరిశీలిస్తాము. C++ వంటి ఇతర భాషలు దీనికి మద్దతు ఇస్తాయి. బహుళ వారసత్వం లేకుండా, తీవ్రమైన సమస్య తలెత్తుతుంది: ఒక వస్తువు అనేక విభిన్న లక్షణాలు మరియు 'ప్రవర్తన'లను కలిగి ఉంటుంది. జీవితం నుండి ఇక్కడ ఒక ఉదాహరణ: మేము మా తల్లిదండ్రులకు పిల్లలు, మా ఉపాధ్యాయులకు విద్యార్థులు మరియు మా వైద్యులకు రోగులు. జీవితంలో, మేము వేర్వేరు పాత్రలను తీసుకుంటాము మరియు తదనుగుణంగా భిన్నంగా ప్రవర్తిస్తాము: స్పష్టంగా, మేము మా సన్నిహితులతో మాట్లాడే విధంగా ఉపాధ్యాయులతో మాట్లాడము. దీన్ని కోడ్‌లోకి అనువదించడానికి ప్రయత్నిద్దాం. మనకు రెండు తరగతులు ఉన్నాయని ఊహించండి: చెరువు మరియు పక్షిశాల. చెరువు కోసం, మాకు నీటి కోడి అవసరం; పక్షిశాల కోసం, మాకు ఎగిరే పక్షులు అవసరం. దీన్ని చేయడానికి, మేము రెండు ప్రాథమిక తరగతులను సృష్టించాము:FlyingBirdమరియు Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

దీని ప్రకారం, మేము పక్షులను వారసత్వంగా పక్షిశాలకు పంపుతాము మరియు చెరువుకు FlyingBirdవారసత్వంగా వచ్చే పక్షులను పంపుతాము . Waterfowlఇదంతా చాలా సింపుల్ గా అనిపిస్తుంది. కానీ మనం బాతును ఎక్కడికి పంపాలి? అది ఈదుతూ ఎగురుతుంది. మరియు మాకు బహుళ వారసత్వం లేదు. అదృష్టవశాత్తూ, జావా ఇంటర్‌ఫేస్‌ల బహుళ అమలుకు మద్దతు ఇస్తుంది. ఒక తరగతి అనేక మంది తల్లిదండ్రులను వారసత్వంగా పొందలేనప్పటికీ, ఇది అనేక ఇంటర్‌ఫేస్‌లను సులభంగా అమలు చేయగలదు! మా బాతు ఎగిరే పక్షి మరియు వాటర్‌ఫౌల్ రెండూ కావచ్చు :) మేము కోరుకున్న ఫలితాన్ని సాధించడానికి క్లాస్‌ల కంటే తయారు చేయడం FlyingBirdమరియు ఇంటర్‌ఫేస్‌లు చేయడం అవసరం.Waterfowl

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

       System.out.println("Swim!");
   }
}

దీని ప్రకారం, మా ప్రోగ్రామ్ తరగతుల సౌలభ్యాన్ని కలిగి ఉంటుంది మరియు డిఫాల్ట్ పద్ధతులతో కలిపి, వస్తువుల ప్రవర్తనను నిర్వచించే మా సామర్థ్యం దాదాపు అపరిమితంగా మారుతుంది! :)