సంగ్రహణ అనేది జావాలో ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ (OOP) యొక్క నాలుగు ప్రాథమిక భావనలలో ఒకటి, అలాగే ఎన్క్యాప్సులేషన్, ఇన్హెరిటెన్స్ మరియు పాలిమార్ఫిజం. సంగ్రహణ అనేది అమలు వివరాలను దాచిపెట్టే ప్రక్రియను సూచిస్తుంది మరియు వినియోగదారుకు ఒక వస్తువు యొక్క ముఖ్యమైన లక్షణాలను మాత్రమే బహిర్గతం చేస్తుంది. మరో మాటలో చెప్పాలంటే, ఇది సంక్లిష్ట వ్యవస్థ కోసం సరళీకృత ఇంటర్ఫేస్ను సృష్టించే చర్య.
జావాలో సంగ్రహణ సాధించడానికి రెండు మార్గాలు ఉన్నాయి:
- వియుక్త తరగతులు: వియుక్త తరగతి అనేది తక్షణం చేయలేని తరగతి మరియు ఇతర తరగతులకు బేస్ క్లాస్గా మాత్రమే ఉపయోగించబడుతుంది. వియుక్త తరగతులు నైరూప్య మరియు వియుక్త పద్ధతులను కలిగి ఉంటాయి. వియుక్త పద్ధతులు శరీరం లేకుండా ప్రకటించబడతాయి మరియు ఉపవర్గాల ద్వారా అమలు చేయబడతాయి. నాన్-అబ్స్ట్రాక్ట్ పద్ధతులను అబ్స్ట్రాక్ట్ క్లాస్లో అమలు చేయవచ్చు లేదా సబ్క్లాస్ల ద్వారా వారసత్వంగా పొందవచ్చు.
ఉదాహరణ:
జావాabstract class Shape {
private int x;
private int y;
public Shape(int x, int y) {
this.x = x;
this.y = y;
}
public abstract double getArea();
}
class Rectangle extends Shape {
private int width;
private int height;
public Rectangle(int x, int y, int width, int height) {
super(x, y);
this.width = width;
this.height = height;
}
public double getArea() {
return width * height;
}
}
public class Main {
public static void main(String[] args) {
Shape shape = new Rectangle(0, 0, 10, 20);
System.out.println(shape.getArea()); // Output: 200.0
}
}
ఈ ఉదాహరణలో, Shape
క్లాస్ అనేది కన్స్ట్రక్టర్ మరియు వియుక్త పద్ధతిని నిర్వచించే నైరూప్య తరగతి getArea()
. తరగతి Rectangle
తరగతిని విస్తరించింది Shape
మరియు getArea()
దీర్ఘచతురస్రం యొక్క వైశాల్యాన్ని లెక్కించడం ద్వారా పద్ధతిని అమలు చేస్తుంది. తరగతి Main
ఒక Rectangle
వస్తువును సృష్టిస్తుంది మరియు దానిని Shape
వేరియబుల్కు కేటాయిస్తుంది, ఇతర తరగతులకు నైరూప్య తరగతులను బేస్ క్లాస్లుగా ఎలా ఉపయోగించవచ్చో ప్రదర్శిస్తుంది.
- ఇంటర్ఫేస్లు: ఇంటర్ఫేస్ అనేది ఒక క్లాస్ అనుసరించాల్సిన ఒప్పందాన్ని నిర్వచించే నైరూప్య పద్ధతుల సమాహారం. ఇంటర్ఫేస్లు అబ్స్ట్రాక్ట్ క్లాస్ల మాదిరిగానే ఉంటాయి, అవి ఇన్స్టాంటియేట్ చేయబడవు, కానీ అవి బహుళ తరగతుల ద్వారా అమలు చేయబడే విధంగా విభిన్నంగా ఉంటాయి. ఒక తరగతి ఒకటి లేదా అంతకంటే ఎక్కువ ఇంటర్ఫేస్లను అమలు చేయగలదు మరియు అది అమలు చేసే ఇంటర్ఫేస్లలో నిర్వచించబడిన అన్ని వియుక్త పద్ధతులకు తప్పనిసరిగా అమలును అందించాలి.
ఉదాహరణ:
csharpinterface Drawable {
public void draw();
}
class Circle implements Drawable {
private int x;
private int y;
private int radius;
public Circle(int x, int y, int radius) {
this.x = x;
this.y = y;
this.radius = radius;
}
public void draw() {
System.out.println("Drawing a circle at (" + x + ", " + y + ") with radius " + radius);
}
}
public class Main {
public static void main(String[] args) {
Drawable drawable = new Circle(0, 0, 10);
drawable.draw(); // Output: "Drawing a circle at (0, 0) with radius 10"
}
}
ఈ ఉదాహరణలో, Drawable
ఇంటర్ఫేస్ ఒకే నైరూప్య పద్ధతిని నిర్వచిస్తుంది draw()
. స్క్రీన్పై సర్కిల్ను గీసే పద్ధతికి అమలును అందించడం ద్వారా తరగతి ఇంటర్ఫేస్ను అమలు Circle
చేస్తుంది . తరగతి ఒక ఆబ్జెక్ట్ను సృష్టిస్తుంది మరియు దానిని వేరియబుల్కు కేటాయిస్తుంది, క్లాస్ అనుసరించడానికి ఒక ఒప్పందాన్ని నిర్వచించడానికి ఇంటర్ఫేస్లను ఎలా ఉపయోగించవచ్చో ప్రదర్శిస్తుంది.Drawable
draw()
Main
Circle
Drawable
జావా ప్రోగ్రామింగ్లో సంగ్రహణ అనేది ఒక ముఖ్యమైన అంశం, ఎందుకంటే ఇది సంక్లిష్ట వ్యవస్థల కోసం సరళీకృత మరియు ప్రామాణికమైన ఇంటర్ఫేస్ను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. అమలు వివరాలను దాచడం మరియు బహిర్గతం చేయడం ద్వారా