ఇంటర్‌ఫేస్‌లు

వియుక్త తరగతులు పాక్షికంగా అమలు చేయబడిన కోడ్ మరియు ఉదాహరణ ఫీల్డ్‌లను కలిగి ఉండవచ్చు, జావాలోని ఇంటర్‌ఫేస్‌లు స్వచ్ఛమైన ప్రవర్తన యొక్క ఒప్పందాలు. ఒక ఇంటర్‌ఫేస్ ఒక క్లాస్ ఏమి చేయాలి* అని నిర్వచిస్తుంది, కానీ అది *ఎలా_ చేస్తుందో కాదు.

ఇది కార్యకలాపాల నిర్వచనం మరియు వాటి వాస్తవ అమలు మధ్య పూర్తి డీకప్లింగ్‌ను అనుమతిస్తుంది.

ఇంటర్‌ఫేస్‌ను నిర్వచించడం (interface)

మేము interface కీవర్డ్‌ని ఉపయోగిస్తాము. ఇంటర్‌ఫేస్‌లో ప్రకటించబడిన అన్ని పద్ధతులు పరోక్షంగా public మరియు abstract (దీనిని పేర్కొనవలసిన అవసరం లేదు):

interface Drivable {
    void startEngine();
    void stopEngine();
}

ఇంటర్‌ఫేస్‌ని అమలు చేస్తోంది (implements)

ఒక తరగతి implements కీవర్డ్‌ని ఉపయోగించి ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది మరియు అన్ని నిర్వచించబడిన పద్ధతుల కోసం (బాడీతో) అమలును అందించడం అవసరం:

class Motorcycle implements Drivable {
    @Override
    public void startEngine() {
        System.out.println("Rombo del motore acceso!");
    }

    @Override
    public void stopEngine() {
        System.out.println("Motore spento.");
    }
}

ఇంటర్‌ఫేస్‌ల ప్రయోజనాలు

1. మల్టిపుల్ ఇన్హెరిటెన్స్: జావాలో, ఒక క్లాస్ ఓన్లీ వన్ పేరెంట్ క్లాస్ (సింగిల్ ఇన్హెరిటెన్స్)ని పొడిగించగలదు, అయితే ఇది ఒకేసారి మల్టిపుల్ ఇంటర్‌ఫేస్‌లను అమలు చేయగలదు.
   Java

   కాపీ చేయండి

   class HybridCar implements Drivable, Chargeable { ... }

2. డీకప్లింగ్: మీరు ఇంటర్‌ఫేస్ రకాన్ని ఉపయోగించి వేరియబుల్‌లను నిర్వచించవచ్చు. ఆ ఇంటర్‌ఫేస్‌ని అమలు చేసే ఏదైనా వస్తువు అటువంటి వేరియబుల్‌కు కేటాయించబడుతుంది.
   Java

   కాపీ చేయండి

   Drivable vehicle = new Motorcycle();
   vehicle.startEngine();

ఇంటర్‌ఫేస్‌లలో స్థిరాంకాలు

ఇంటర్‌ఫేస్‌లలో, ఫీల్డ్‌లను ప్రకటించడం సాధ్యమవుతుంది. మీరు ఈ మాడిఫైయర్‌లను పేర్కొనకపోయినా కూడా ఈ ఫీల్డ్‌లు పరోక్షంగా public static final (క్లాస్ స్థిరాంకాలు అని అర్థం). పర్యవసానంగా, వారు ప్రకటన చేసిన వెంటనే ప్రారంభించబడాలి:

interface PhysicsConstants {
    double GRAVITY = 9.81; // Implicitly public static final
}

డిఫాల్ట్ పద్ధతులు (default)

Java 8 నుండి ప్రారంభించి, default కీవర్డ్‌ని ఉపయోగించి ఇంటర్‌ఫేస్ లోపల డిఫాల్ట్ అమలుతో పద్ధతులను నిర్వచించడం సాధ్యమవుతుంది. ఈ పద్ధతులు అమలు చేసే తరగతులను వాటిని భర్తీ చేయమని బలవంతం చేయవు, ఇది ఫాల్‌బ్యాక్ ప్రవర్తనను అందిస్తుంది:

interface Logger {
    void log(String message);

    // Default method with a body
    default void logError(String message) {
        log("ERROR: " + message);
    }
}

మీరే ప్రయత్నించండి