మేము ఇప్పటికే సింగిల్టన్ ఆబ్జెక్ట్ యొక్క ఉపయోగాన్ని సమీక్షించాము, కానీ ఈ వ్యూహం డిజైన్ నమూనా అని మరియు దానిలో ఎక్కువగా ఉపయోగించే వాటిలో ఒకటి అని మీరు ఇంకా గ్రహించకపోవచ్చు.
వాస్తవానికి, ఈ నమూనాలు చాలా ఉన్నాయి మరియు వాటి నిర్దిష్ట ప్రయోజనం ప్రకారం వాటిని వర్గీకరించవచ్చు.
నమూనా వర్గీకరణ
నమూనా రకం | అప్లికేషన్ |
---|---|
క్రియేషనల్ | వస్తువు సృష్టి సమస్యను పరిష్కరించే రకం |
నిర్మాణ | మన ఆర్కిటెక్చర్లో సరైన మరియు విస్తరించదగిన తరగతి శ్రేణిని నిర్మించడానికి అనుమతించే నమూనాలు |
ప్రవర్తనాపరమైన | ఈ నమూనాల క్లస్టర్ ప్రోగ్రామ్లోని వస్తువుల మధ్య సురక్షితమైన మరియు అనుకూలమైన పరస్పర చర్యను సులభతరం చేస్తుంది. |
సాధారణంగా, ఒక నమూనా అది పరిష్కరించే సమస్య ద్వారా వర్గీకరించబడుతుంది. జావాతో పని చేస్తున్నప్పుడు మనం తరచుగా ఎదుర్కొనే కొన్ని నమూనాలను పరిశీలిద్దాం:
నమూనా | ప్రయోజనం |
---|---|
సింగిల్టన్ | మేము ఈ నమూనాతో ఇప్పటికే సుపరిచితం - మేము ఒకటి కంటే ఎక్కువ ఉదాహరణలను కలిగి ఉండని తరగతిని సృష్టించడానికి మరియు యాక్సెస్ చేయడానికి దీనిని ఉపయోగిస్తాము. |
ఇటరేటర్ | ఈ విషయం మనకు కూడా సుపరిచితమే. ఈ నమూనా దాని అంతర్గత ప్రాతినిధ్యాన్ని బహిర్గతం చేయకుండా సేకరణ వస్తువుపై మళ్ళించగలదని మాకు తెలుసు. ఇది సేకరణలతో ఉపయోగించబడుతుంది. |
అడాప్టర్ | ఈ నమూనా అననుకూల వస్తువులను కలుపుతుంది, తద్వారా అవి కలిసి పని చేస్తాయి. నేను అడాప్టర్ నమూనా పేరు ఇది ఏమి చేస్తుందో సరిగ్గా ఊహించడంలో మీకు సహాయపడుతుందని నేను భావిస్తున్నాను. నిజ జీవితం నుండి ఇక్కడ ఒక సాధారణ ఉదాహరణ: వాల్ అవుట్లెట్ కోసం USB అడాప్టర్. |
టెంప్లేట్ పద్ధతి |
ఏకీకరణ సమస్యను పరిష్కరిస్తుంది మరియు అల్గోరిథం యొక్క నిర్మాణాన్ని మార్చకుండా అల్గారిథమిక్ దశలను మార్చడానికి మిమ్మల్ని అనుమతించే ప్రవర్తనా ప్రోగ్రామింగ్ నమూనా. అసెంబ్లీ దశల క్రమం రూపంలో మనకు కారు అసెంబ్లీ అల్గోరిథం ఉందని ఊహించండి: చట్రం -> బాడీ -> ఇంజిన్ -> క్యాబిన్ ఇంటీరియర్ మేము రీన్ఫోర్స్డ్ ఫ్రేమ్, మరింత శక్తివంతమైన ఇంజిన్ లేదా అదనపు లైటింగ్తో కూడిన ఇంటీరియర్లో ఉంచినట్లయితే, మేము అల్గారిథమ్ను మార్చాల్సిన అవసరం లేదు మరియు వియుక్త క్రమం అలాగే ఉంటుంది. |
డెకరేటర్ | ఈ నమూనా వస్తువులకు ఉపయోగకరమైన కార్యాచరణను అందించడానికి రేపర్లను సృష్టిస్తుంది. మేము దానిని ఈ వ్యాసంలో భాగంగా పరిగణిస్తాము. |
Java.ioలో, కింది తరగతులు నమూనాలను అమలు చేస్తాయి:
నమూనా | ఇది java.ioలో ఎక్కడ ఉపయోగించబడుతుంది |
---|---|
అడాప్టర్ |
|
టెంప్లేట్ పద్ధతి | |
డెకరేటర్ |
డెకరేటర్ నమూనా
మేము ఇంటి డిజైన్ కోసం ఒక నమూనాను వివరిస్తున్నామని ఊహించుకుందాం.
సాధారణంగా, విధానం ఇలా కనిపిస్తుంది:
ప్రారంభంలో, మేము అనేక రకాల గృహాల ఎంపికను కలిగి ఉన్నాము. కనీస కాన్ఫిగరేషన్ పైకప్పుతో ఒక అంతస్తు. అప్పుడు మేము అదనపు పారామితులను మార్చడానికి అన్ని రకాల డెకరేటర్లను ఉపయోగిస్తాము, ఇది సహజంగా ఇంటి ధరను ప్రభావితం చేస్తుంది.
మేము వియుక్త హౌస్ తరగతిని సృష్టిస్తాము:
public abstract class House {
String info;
public String getInfo() {
return info;
}
public abstract int getPrice();
}
ఇక్కడ మనకు 2 పద్ధతులు ఉన్నాయి:
- getInfo() మా ఇంటి పేరు మరియు లక్షణాల గురించి సమాచారాన్ని అందిస్తుంది;
- getPrice() ప్రస్తుత ఇంటి కాన్ఫిగరేషన్ ధరను అందిస్తుంది.
మేము ప్రామాణిక గృహ అమలులను కూడా కలిగి ఉన్నాము - ఇటుక మరియు చెక్క:
public class BrickHouse extends House {
public BrickHouse() {
info = "Brick House";
}
@Override
public int getPrice() {
return 20_000;
}
}
public class WoodenHouse extends House {
public WoodenHouse() {
info = "Wooden House";
}
@Override
public int getPrice() {
return 25_000;
}
}
రెండు తరగతులు హౌస్ తరగతిని వారసత్వంగా పొందుతాయి మరియు దాని ధర పద్ధతిని భర్తీ చేస్తాయి, ప్రామాణిక ఇంటికి అనుకూల ధరను సెట్ చేస్తాయి. మేము కన్స్ట్రక్టర్లో పేరును సెట్ చేసాము.
తరువాత, మేము డెకరేటర్ తరగతులను వ్రాయాలి. ఈ తరగతులు హౌస్ తరగతిని కూడా వారసత్వంగా పొందుతాయి . దీన్ని చేయడానికి, మేము ఒక వియుక్త డెకరేటర్ తరగతిని సృష్టిస్తాము.
ఆబ్జెక్ట్ని మార్చడానికి మేము అదనపు లాజిక్ని ఉంచుతాము. ప్రారంభంలో, అదనపు తర్కం ఉండదు మరియు వియుక్త తరగతి ఖాళీగా ఉంటుంది.
abstract class HouseDecorator extends House {
}
తరువాత, మేము డెకరేటర్ అమలులను సృష్టిస్తాము. మేము ఇంటికి అదనపు లక్షణాలను జోడించే అనేక తరగతులను సృష్టిస్తాము:
public class SecondFloor extends HouseDecorator {
House house;
public SecondFloor(House house) {
this.house = house;
}
@Override
public int getPrice() {
return house.getPrice() + 20_000;
}
@Override
public String getInfo() {
return house.getInfo() + " + second floor";
}
}
మా ఇంటికి రెండవ అంతస్తును జోడించే డెకరేటర్ |
డెకరేటర్ కన్స్ట్రక్టర్ మేము "అలంకరించే" ఇంటిని అంగీకరిస్తాడు, అనగా సవరణలను జోడించండి. మరియు మేము getPrice() మరియు getInfo() పద్ధతులను భర్తీ చేస్తాము, పాత దాని ఆధారంగా కొత్త అప్డేట్ చేయబడిన ఇంటి గురించి సమాచారాన్ని తిరిగి అందిస్తాము.
public class Garage extends HouseDecorator {
House house;
public Garage(House house) {
this.house = house;
}
@Override
public int getPrice() {
return house.getPrice() + 5_000;
}
@Override
public String getInfo() {
return house.getInfo() + " + garage";
}
}
మా ఇంటికి గ్యారేజీని జోడించే డెకరేటర్ |
ఇప్పుడు మన ఇంటిని డెకరేటర్లతో అప్డేట్ చేసుకోవచ్చు. దీన్ని చేయడానికి, మేము ఇంటిని సృష్టించాలి:
House brickHouse = new BrickHouse();
తరువాత, మేము మా సెట్ఇల్లుకొత్త డెకరేటర్కి సమానమైన వేరియబుల్, మా ఇంట్లో ప్రయాణిస్తున్నది:
brickHouse = new SecondFloor(brickHouse);
మాఇల్లువేరియబుల్ ఇప్పుడు రెండవ అంతస్తు ఉన్న ఇల్లు.
డెకరేటర్లకు సంబంధించిన వినియోగ కేసులను చూద్దాం:
ఉదాహరణ కోడ్ | అవుట్పుట్ |
---|---|
|
ఇటుక ఇల్లు 20000 |
|
బ్రిక్ హౌస్ + రెండవ అంతస్తు 40000 |
|
బ్రిక్ హౌస్ + రెండవ అంతస్తు + గ్యారేజ్ 45000 |
|
చెక్క ఇల్లు + గ్యారేజ్ + రెండవ అంతస్తు 50000 |
|
చెక్క ఇల్లు 25000 చెక్క ఇల్లు + గ్యారేజ్ 30000 |
ఈ ఉదాహరణ డెకరేటర్తో వస్తువును అప్గ్రేడ్ చేయడం వల్ల కలిగే ప్రయోజనాన్ని వివరిస్తుంది. కాబట్టి మేము మార్చలేదుచెక్క ఇల్లుఆబ్జెక్ట్ దానంతట అదే, కానీ బదులుగా పాత దాని ఆధారంగా కొత్త వస్తువును సృష్టించింది. ఇక్కడ ప్రయోజనాలు అప్రయోజనాలతో వస్తాయని మనం చూడవచ్చు: మేము ప్రతిసారీ మెమరీలో కొత్త వస్తువును సృష్టిస్తాము, మెమరీ వినియోగాన్ని పెంచుతాము.
మా ప్రోగ్రామ్ యొక్క ఈ UML రేఖాచిత్రాన్ని చూడండి:
డెకరేటర్ సూపర్ సింపుల్ ఇంప్లిమెంటేషన్ని కలిగి ఉంటుంది మరియు వస్తువులను డైనమిక్గా మారుస్తుంది, వాటిని అప్గ్రేడ్ చేస్తుంది. డెకరేటర్లను వారి కన్స్ట్రక్టర్లు గుర్తించవచ్చు, ఇవి ప్రస్తుత తరగతి వలె అదే నైరూప్య రకం లేదా ఇంటర్ఫేస్ని పారామితులుగా తీసుకుంటాయి. జావాలో, ఈ నమూనా I/O తరగతులలో విస్తృతంగా ఉపయోగించబడుతుంది.
ఉదాహరణకు, మేము ఇప్పటికే గుర్తించినట్లుగా, java.io.InputStream , OutputStream , రీడర్ మరియు రైటర్ యొక్క అన్ని సబ్క్లాస్లు ఒకే తరగతుల వస్తువులను అంగీకరించే కన్స్ట్రక్టర్ను కలిగి ఉంటాయి.
GO TO FULL VERSION