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

జావా యొక్క ప్రతి కొత్త వెర్షన్ మునుపటి వాటి నుండి భిన్నంగా ఉంటుంది. మేము కవర్ చేసిన మెటీరియల్ నుండి అటువంటి మార్పుకు ఉదాహరణగా, enumsజావా 5 కంటే ముందు భాష లేదు. కాబట్టి, జావా 8, జావా 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 go() {
       System.out.println("Gas!");
   }

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


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

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

ఈ కోడ్‌తో ఉన్న ప్రధాన సమస్య ఏమిటని మీరు అనుకుంటున్నారు? మేము నకిలీ కోడ్‌ల సమూహాన్ని వ్రాసినట్లు మీరు బహుశా గమనించి ఉండవచ్చు! ప్రోగ్రామింగ్‌లో ఇది ఒక సాధారణ సమస్య మరియు దీనిని నివారించాలి. జావా 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 go() {
       System.out.println("This car accelerates differently!");
   }

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

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

public class Waterfowl {
}

public class FlyingBird {
}

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

public class Duck implements FlyingBird, Waterfowl {

   // Methods of both interfaces combine easily into one class
  
   @Override
   public void fly() {
       System.out.println("Flying!");
   }

   @Override
   public void swim() {

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

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